diff --git a/.gitignore b/.gitignore index fb42325..256a196 100644 --- a/.gitignore +++ b/.gitignore @@ -11,6 +11,9 @@ src/results/* src/logs/* idea/* src/lightning_logs/* +apptainer/* +*.yaml +*.sif notebooks/.ipynb_checkpoints/RAE-dev-checkpoint.ipynb src/utils/data/__init__.py src/utils/evaluation/__init__.py diff --git a/.isort.cfg b/.isort.cfg new file mode 100644 index 0000000..5d7bf33 --- /dev/null +++ b/.isort.cfg @@ -0,0 +1,2 @@ +[tool.isort] +profile = "black" diff --git a/README.md b/README.md index 99e629c..87ab1b1 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ # D4L-Hackaton ## Setup -We recommend creating ```venv``` or ```conda``` environment with ```python==3.12```. +We recommend creating ```venv``` or ```conda``` environment with ```python==3.12```. ### Conda and requirements.txt @@ -29,14 +29,14 @@ python3 train_and_validate.py [ARGUMENTS] with possible options: * ```-h, --help```: show this help message and exit - * ```--method``` {"omivae", "babel", "advae"} + * ```--method``` {"omivae", "babel", "advae"} * ```--config``` (default="standard"): Name of a configuration in src/config/{method} directory. * ```--cv-seed``` (default=42): Seed used to make k folds for cross validation. * ```--n-folds``` (default=5): Number of folds in cross validation. * ```--subsample-frac``` (default=None): Fraction of the data to use for cross validation. * ```--retrain``` (default=True): Retrain a model using the whole dataset. -### +### ## Dataset We use dataset from NeurIPS competition: https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE194122 named GSE194122_openproblems_neurips2021_cite_BMMC_processed.h5ad.gz. @@ -50,6 +50,17 @@ log-scaled counts, as well as Spearman correlation. probability assigned to the correct matching. The latter is a relative measure per dataset that accounts for non-identifiability among cells with the same identity. +### Pre-commit + +Before you can run hooks, you need to have the pre-commit package manager installed. + +Using pip: `pip install pre-commit`. + +In a python project, add the following to your requirements.txt (or requirements-dev.txt): `pre-commit`. + +Then run `pre-commit install` to set up the git hook scripts. + + ### Viewing logs To see the logs from different runs from the `src` directory run diff --git a/container_vaes.def b/container_vaes.def new file mode 100644 index 0000000..d3bd2c2 --- /dev/null +++ b/container_vaes.def @@ -0,0 +1,32 @@ +BootStrap: docker +From: ubuntu:22.04 + + +%files + ./requirements_vaes.txt + +%post + TZ=Europe/Berlin + ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone + + apt -y update && apt -y upgrade + + # Install python + apt install -y python3-pip + pip3 install --upgrade pip + apt-get -y install git + + echo "PYTHON VERSION" + python3 --version # 3.10.12 + pip3 --version # 23.3.2 + pip3 install -r requirements_vaes.txt + + # Clean cache to reduce size of the image + apt clean + rm -r $(pip cache dir)/* + +%startscript + PATH=$PATH:$HOME/.local/bin + +%labels + Author Ja diff --git a/mrun.py b/mrun.py new file mode 100644 index 0000000..79b8ba6 --- /dev/null +++ b/mrun.py @@ -0,0 +1,28 @@ +import glob +import os +from argparse import Namespace + +import mrunner +from mrunner.helpers import client_helper +from mrunner.helpers.client_helper import get_configuration + +from src.main import main + +# mrunner.settings.NEPTUNE_USE_NEW_API = True # comment if running locally + +if __name__ == "__main__": + params = get_configuration( + print_diagnostics=True, with_neptune=True, inject_parameters_to_gin=True + ) + params.pop("experiment_id") + # verify params: combine_with_defaults(params, defaults=vars(parse_namespace([]))) + namespace = Namespace(**params) + try: + client_helper.experiment_["neptune_path"] = os.environ["NEPTUNEPWD"] + except KeyError: + pass + + # if not namespace.cpdag and namespace.sampling: + # pass # add constraints here + + main(namespace) diff --git a/src/utils/__init__.py b/old_code/config/Untitled-2 similarity index 100% rename from src/utils/__init__.py rename to old_code/config/Untitled-2 diff --git a/old_code/old_notebooks/Deeplife_VEGA_session_without_solutions.ipynb b/old_code/old_notebooks/Deeplife_VEGA_session_without_solutions.ipynb new file mode 100644 index 0000000..8130b85 --- /dev/null +++ b/old_code/old_notebooks/Deeplife_VEGA_session_without_solutions.ipynb @@ -0,0 +1,1790 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 5297, + "status": "ok", + "timestamp": 1711629722588, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "ZtFHtTBH8Hgr", + "outputId": "ee16634f-7f73-4091-d6ff-6ada7c5d5f6d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: scanpy in /usr/local/lib/python3.10/dist-packages (1.10.0)\n", + "Requirement already satisfied: anndata>=0.8 in /usr/local/lib/python3.10/dist-packages (from scanpy) (0.10.6)\n", + "Requirement already satisfied: h5py>=3.1 in /usr/local/lib/python3.10/dist-packages (from scanpy) (3.9.0)\n", + "Requirement already satisfied: joblib in /usr/local/lib/python3.10/dist-packages (from scanpy) (1.3.2)\n", + "Requirement already satisfied: legacy-api-wrap>=1.4 in /usr/local/lib/python3.10/dist-packages (from scanpy) (1.4)\n", + "Requirement already satisfied: matplotlib>=3.6 in /usr/local/lib/python3.10/dist-packages (from scanpy) (3.7.1)\n", + "Requirement already satisfied: natsort in /usr/local/lib/python3.10/dist-packages (from scanpy) (8.4.0)\n", + "Requirement already satisfied: networkx>=2.7 in /usr/local/lib/python3.10/dist-packages (from scanpy) (3.2.1)\n", + "Requirement already satisfied: numba>=0.56 in /usr/local/lib/python3.10/dist-packages (from scanpy) (0.58.1)\n", + "Requirement already satisfied: numpy>=1.23 in /usr/local/lib/python3.10/dist-packages (from scanpy) (1.25.2)\n", + "Requirement already satisfied: packaging>=21.3 in /usr/local/lib/python3.10/dist-packages (from scanpy) (24.0)\n", + "Requirement already satisfied: pandas>=1.5 in /usr/local/lib/python3.10/dist-packages (from scanpy) (1.5.3)\n", + "Requirement already satisfied: patsy in /usr/local/lib/python3.10/dist-packages (from scanpy) (0.5.6)\n", + "Requirement already satisfied: pynndescent>=0.5 in /usr/local/lib/python3.10/dist-packages (from scanpy) (0.5.11)\n", + "Requirement already satisfied: scikit-learn>=0.24 in /usr/local/lib/python3.10/dist-packages (from scanpy) (1.2.2)\n", + "Requirement already satisfied: scipy>=1.8 in /usr/local/lib/python3.10/dist-packages (from scanpy) (1.11.4)\n", + "Requirement already satisfied: seaborn>=0.13 in /usr/local/lib/python3.10/dist-packages (from scanpy) (0.13.1)\n", + "Requirement already satisfied: session-info in /usr/local/lib/python3.10/dist-packages (from scanpy) (1.0.0)\n", + "Requirement already satisfied: statsmodels>=0.13 in /usr/local/lib/python3.10/dist-packages (from scanpy) (0.14.1)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from scanpy) (4.66.2)\n", + "Requirement already satisfied: umap-learn!=0.5.0,>=0.5 in /usr/local/lib/python3.10/dist-packages (from scanpy) (0.5.5)\n", + "Requirement already satisfied: array-api-compat!=1.5,>1.4 in /usr/local/lib/python3.10/dist-packages (from anndata>=0.8->scanpy) (1.5.1)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anndata>=0.8->scanpy) (1.2.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.6->scanpy) (1.2.0)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.6->scanpy) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.6->scanpy) (4.50.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.6->scanpy) (1.4.5)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.6->scanpy) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.6->scanpy) (3.1.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.6->scanpy) (2.8.2)\n", + "Requirement already satisfied: llvmlite<0.42,>=0.41.0dev0 in /usr/local/lib/python3.10/dist-packages (from numba>=0.56->scanpy) (0.41.1)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.5->scanpy) (2023.4)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=0.24->scanpy) (3.4.0)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.10/dist-packages (from patsy->scanpy) (1.16.0)\n", + "Requirement already satisfied: stdlib-list in /usr/local/lib/python3.10/dist-packages (from session-info->scanpy) (0.10.0)\n", + "cuda\n" + ] + } + ], + "source": [ + "#### Setup ####\n", + "# install and import required packages\n", + "!pip install scanpy\n", + "import torch\n", + "\n", + "torch.manual_seed(100)\n", + "import torch.nn as nn\n", + "import torch.utils\n", + "import torch.distributions\n", + "import torchvision\n", + "from torchvision import datasets, transforms\n", + "import math\n", + "import numpy as np\n", + "\n", + "np.random.seed(100)\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.rcParams[\"figure.dpi\"] = 200\n", + "import scanpy as sc\n", + "from collections import OrderedDict\n", + "from collections import Counter\n", + "\n", + "# select the right device, depending on whether your Colab runs on GPU or CPU\n", + "### IMPORTANT: we recommend to change your runtime to GPU, otherwise the training takes much longer\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "print(device)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6L4KM-KybhSF" + }, + "source": [ + "## Interpretable variational autoencoders for the analysis of scRNA-Seq data\n", + "### Objective\n", + "\n", + "In this practical session, you will learn how variational autoencoders (VAEs) can be modified to be biologically interpretable and how these models can be used to analyze **biological processes**.
\n", + "We will first build a \"standard\" VAE, which provides a low dimensional representation of the data set with a clear clustering into conditions and cell types, but whose features are **not directly interpretable**.
\n", + "\n", + "Then, we will modify this VAE, so that its latent variables can be directly interpreted as **biological processes**. Therefore, we will follow the same principle that is applied in **VEGA**, proposed by [Seninge *et al* (2021)](https://www.nature.com/articles/s41467-021-26017-0) (more about this later). We will use this model to compare pathway activities between cell types and treatment conditions.
\n", + "\n", + "### Data set\n", + "For the analysis, we will use a data set that contains peripheral blood mononuclear cells (PBMCs) from systemic lupus patients, treated with Interferon beta or untreated (control). The data set is already preprocessed and is stored as an **AnnData** object. You can read more about this data format [here](https://anndata.readthedocs.io/en/latest/tutorials/notebooks/getting-started.html).
\n", + "\n", + "An AnnData object contains the gene expression data in its `.X` attribute, stored as a sparse matrix. Annotations for the observations (cells) are stored in the `.obs` attribute, and annotations for the variables (genes) in the `.var` attribute. We can select specific features of the `.obs` or `.var` attribute using squared brackets, e.g. `PBMC_train.obs[\"cell_type\"]` :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 4605, + "status": "ok", + "timestamp": 1711629727186, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "9Fs0gLaK8t25", + "outputId": "7e6c526f-1379-438e-9d32-b8f9466cf6a9" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2024-03-28 12:42:02-- https://docs.google.com/uc?export=download&id=1zHJKoU8QcQB4cLR-oICO2YY4Nu-QaZHG\n", + "Resolving docs.google.com (docs.google.com)... 142.251.180.113, 142.251.180.102, 142.251.180.101, ...\n", + "Connecting to docs.google.com (docs.google.com)|142.251.180.113|:443... connected.\n", + "HTTP request sent, awaiting response... 303 See Other\n", + "Location: https://drive.usercontent.google.com/download?id=1zHJKoU8QcQB4cLR-oICO2YY4Nu-QaZHG&export=download [following]\n", + "--2024-03-28 12:42:02-- https://drive.usercontent.google.com/download?id=1zHJKoU8QcQB4cLR-oICO2YY4Nu-QaZHG&export=download\n", + "Resolving drive.usercontent.google.com (drive.usercontent.google.com)... 108.177.112.132, 2607:f8b0:4001:c5f::84\n", + "Connecting to drive.usercontent.google.com (drive.usercontent.google.com)|108.177.112.132|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 45277554 (43M) [application/octet-stream]\n", + "Saving to: ‘PBMC_train.h5ad’\n", + "\n", + "PBMC_train.h5ad 100%[===================>] 43.18M 110MB/s in 0.4s \n", + "\n", + "2024-03-28 12:42:06 (110 MB/s) - ‘PBMC_train.h5ad’ saved [45277554/45277554]\n", + "\n" + ] + } + ], + "source": [ + "# download the data\n", + "!wget --no-check-certificate 'https://docs.google.com/uc?export=download&id=1zHJKoU8QcQB4cLR-oICO2YY4Nu-QaZHG' -O PBMC_train.h5ad\n", + "# load data as anndata object\n", + "PBMC_train = sc.read_h5ad(\"PBMC_train.h5ad\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "g4dT3AMzcPAp" + }, + "source": [ + "Let's take a closer look at the data:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 295, + "status": "ok", + "timestamp": 1711629727477, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "mXW3k4tIkrIZ", + "outputId": "a0a7948f-8de5-40b7-ec0c-eb95e2c29d6f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AnnData object with n_obs × n_vars = 13515 × 6998\n", + " obs: 'condition', 'n_counts', 'n_genes', 'mt_frac', 'cell_type'\n", + " var: 'gene_symbol', 'n_cells'\n", + " uns: 'cell_type_colors', 'condition_colors', 'neighbors'\n", + " obsm: 'X_pca', 'X_tsne', 'X_umap'\n", + " obsp: 'connectivities', 'distances'\n", + "Counter({'CD4T': 4452, 'FCGR3A+Mono': 2881, 'CD14+Mono': 2049, 'B': 1448, 'NK': 931, 'CD8T': 892, 'Dendritic': 862})\n", + "Counter({'stimulated': 7109, 'control': 6406})\n" + ] + } + ], + "source": [ + "print(PBMC_train) # the data is stored as an anndata object\n", + "print(Counter(PBMC_train.obs[\"cell_type\"])) # summary of cell types\n", + "print(Counter(PBMC_train.obs[\"condition\"])) # summary of conditions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vzVxCjV2hJO8" + }, + "source": [ + "## Standard VAE\n", + "\n", + "We will first build a \"standard\" VAE. The code for this is not explained in detail, since this should be already familiar from previous sessions.
\n", + "\n", + "We define the `Encoder` as a two-layer, non-linear and fully connected neural network. The latent space is sampled from a multivariate normal distribution. We further use dropout layers in the encoder/latent space:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "FtBSMERo2S0u" + }, + "outputs": [], + "source": [ + "class Encoder(nn.Module):\n", + " def __init__(\n", + " self, latent_dims, input_dims, dropout, z_dropout\n", + " ): # dropout, z_dropout define the dropout rates of the encoder/latent space\n", + " super(Encoder, self).__init__()\n", + " self.encoder = nn.Sequential(\n", + " nn.Linear(input_dims, 800),\n", + " nn.ReLU(),\n", + " nn.Dropout(p=dropout),\n", + " nn.Linear(800, 800),\n", + " nn.ReLU(),\n", + " nn.Dropout(p=dropout),\n", + " ) # two layer, fully connected encoder with dropout\n", + "\n", + " self.mu = nn.Sequential(nn.Linear(800, latent_dims), nn.Dropout(p=z_dropout))\n", + "\n", + " self.sigma = nn.Sequential(nn.Linear(800, latent_dims), nn.Dropout(p=z_dropout))\n", + "\n", + " self.N = torch.distributions.Normal(0, 1)\n", + " self.N.loc = self.N.loc.to(device)\n", + " self.N.scale = self.N.scale.to(device)\n", + " self.kl = 0\n", + "\n", + " def forward(self, x):\n", + " x = self.encoder(x)\n", + " mu = self.mu(x)\n", + " sigma = torch.exp(self.mu(x)) # exp for numeric stability\n", + " z = mu + sigma * self.N.sample(mu.shape)\n", + " self.kl = (\n", + " 0.5 * sigma**2 + 0.5 * mu**2 - torch.log(sigma) - 1 / 2\n", + " ).sum() # calculation of kullback-leibler divergence\n", + "\n", + " return z" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZzfPCwrIiOxV" + }, + "source": [ + "We further define the `Decoder` as two-layer, non linear and fully connected neural network:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "E07kSyjt5cUf" + }, + "outputs": [], + "source": [ + "class Decoder(nn.Module):\n", + " def __init__(self, latent_dims, input_dims, dropout):\n", + " super(Decoder, self).__init__()\n", + " self.decoder = nn.Sequential(\n", + " nn.Linear(latent_dims, 800),\n", + " nn.ReLU(),\n", + " nn.Dropout(p=dropout),\n", + " nn.Linear(800, input_dims),\n", + " )\n", + "\n", + " def forward(self, z):\n", + " z = self.decoder(z)\n", + " return z" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nIA7L8O70MWM" + }, + "source": [ + "The class `VariationalAutoencoder` combines the Encoder and Decoder:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "QCoqYSVu0MWN" + }, + "outputs": [], + "source": [ + "class VariationalAutoencoder(nn.Module):\n", + " def __init__(self, latent_dims, input_dims, dropout=0.3, z_dropout=0.3):\n", + " super(VariationalAutoencoder, self).__init__()\n", + " self.encoder = Encoder(latent_dims, input_dims, dropout, z_dropout)\n", + " self.decoder = Decoder(latent_dims, input_dims, dropout)\n", + "\n", + " def forward(self, x):\n", + " z = self.encoder(x)\n", + " return self.decoder(z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6r8UBS8H0MWN" + }, + "source": [ + "In order to train the model, we use the following training function, which returns the trained model and a list of the losses after each epoch. Beta defines the weight of the KLD." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "dMrAWFLj0MWN" + }, + "outputs": [], + "source": [ + "def train(vae, data, epochs=50, beta=0.001, learning_rate=0.0001):\n", + " opt = torch.optim.Adam(vae.parameters(), lr=learning_rate) # ADAM optimizer\n", + " losses = []\n", + " klds = []\n", + " mses = []\n", + " vae.train() # train mode (then, dropout layers are considered)\n", + "\n", + " for epoch in range(epochs):\n", + " loss_e = 0\n", + " kld_e = 0\n", + " mse_e = 0\n", + "\n", + " for x in data:\n", + " x = x.to(device)\n", + " opt.zero_grad()\n", + " x_hat = vae(x)\n", + " mse = ((x - x_hat) ** 2).sum()\n", + " kld = beta * vae.encoder.kl\n", + " loss = mse + kld # loss calculation\n", + " loss.backward()\n", + " opt.step()\n", + " loss_e += loss.to(\"cpu\").detach().numpy()\n", + " kld_e += kld.to(\"cpu\").detach().numpy()\n", + " mse_e += mse.to(\"cpu\").detach().numpy()\n", + "\n", + " losses.append(loss_e / (len(data) * 128))\n", + " klds.append(kld_e / (len(data) * 128))\n", + " mses.append(mse_e / (len(data) * 128))\n", + "\n", + " print(\"epoch: \", epoch, \" loss: \", loss_e / (len(data) * 128))\n", + "\n", + " return vae, losses, klds, mses" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ipnkjDmX_qSL" + }, + "outputs": [], + "source": [ + "PBMC_trainX = torch.utils.data.DataLoader(\n", + " PBMC_train.X.A, batch_size=128\n", + ") # set up the training data in the right format\n", + "latent_dims = 50 # choose the number of latent variables" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WkFXY0QBkTRs" + }, + "source": [ + "We can now initialize our VAE and use the PBMC data to train the model:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 65786, + "status": "ok", + "timestamp": 1711629795412, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "nXinXHx40MWN", + "outputId": "8fa075b3-d789-4211-f2d1-b35e06168c09" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch: 0 loss: 513.536498591585\n", + "epoch: 1 loss: 351.178267712863\n", + "epoch: 2 loss: 305.13110049265737\n", + "epoch: 3 loss: 278.5065679010355\n", + "epoch: 4 loss: 258.0582905895305\n", + "epoch: 5 loss: 241.07480923634654\n", + "epoch: 6 loss: 226.31014431647534\n", + "epoch: 7 loss: 216.009990404237\n", + "epoch: 8 loss: 208.95971017513634\n", + "epoch: 9 loss: 204.8208218700481\n", + "epoch: 10 loss: 200.99840682407594\n", + "epoch: 11 loss: 197.2385293492731\n", + "epoch: 12 loss: 193.88886793604436\n", + "epoch: 13 loss: 191.31420430597268\n", + "epoch: 14 loss: 190.22944007729583\n", + "epoch: 15 loss: 189.4800892955852\n", + "epoch: 16 loss: 187.6732131670106\n", + "epoch: 17 loss: 186.64440831598245\n", + "epoch: 18 loss: 186.33485772474756\n", + "epoch: 19 loss: 184.78939711372809\n", + "epoch: 20 loss: 184.66170264190097\n", + "epoch: 21 loss: 184.67536220910415\n", + "epoch: 22 loss: 184.0615051557433\n", + "epoch: 23 loss: 182.80410162008033\n", + "epoch: 24 loss: 182.2869801071455\n", + "epoch: 25 loss: 181.94199738412533\n", + "epoch: 26 loss: 181.29860737638654\n", + "epoch: 27 loss: 181.16909775643978\n", + "epoch: 28 loss: 180.76597278522996\n", + "epoch: 29 loss: 180.32100641502524\n", + "epoch: 30 loss: 180.14688750932802\n", + "epoch: 31 loss: 179.79329659803858\n", + "epoch: 32 loss: 179.68623913459058\n", + "epoch: 33 loss: 179.35109055717035\n", + "epoch: 34 loss: 178.9588841132398\n", + "epoch: 35 loss: 178.40895721147646\n", + "epoch: 36 loss: 178.81060697447577\n", + "epoch: 37 loss: 178.28595827210626\n", + "epoch: 38 loss: 177.73108226848098\n", + "epoch: 39 loss: 177.4495548752119\n", + "epoch: 40 loss: 178.277207716456\n", + "epoch: 41 loss: 178.6926444431521\n", + "epoch: 42 loss: 176.63536554012657\n", + "epoch: 43 loss: 176.46553255477042\n", + "epoch: 44 loss: 176.01040361512383\n", + "epoch: 45 loss: 175.1845459128326\n", + "epoch: 46 loss: 175.10018978478774\n", + "epoch: 47 loss: 174.6172999256062\n", + "epoch: 48 loss: 174.26528088551646\n", + "epoch: 49 loss: 174.061468952107\n" + ] + } + ], + "source": [ + "vae = VariationalAutoencoder(\n", + " latent_dims=latent_dims, input_dims=PBMC_train.shape[1]\n", + ").to(device)\n", + "vae, losses, klds, mses = train(\n", + " vae, PBMC_trainX, beta=0.001\n", + ") # takes about 1 min on GPU" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ldnfLVuM0MWN" + }, + "source": [ + "We can plot the loss curve and see that it converges well:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 860 + }, + "executionInfo": { + "elapsed": 608, + "status": "ok", + "timestamp": 1711629796009, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "bl0vqNG_FlSK", + "outputId": "cdad9d51-5b19-4ef0-f715-a9e41047a86e" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 184, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(losses)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JuzZJKDAYxUB" + }, + "source": [ + "We can further look at the MSE and the KLD:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 860 + }, + "executionInfo": { + "elapsed": 16, + "status": "ok", + "timestamp": 1711629796009, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "Retul8fOYw9z", + "outputId": "3d7f701b-ae02-47ee-cacf-44b378455cd7" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 185, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(mses, label=\"MSE\")\n", + "plt.plot(klds, label=\"KLD\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tiLC5hYNcSl_" + }, + "source": [ + "We can project the data to the latent space, and store this in the anndata object:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "vswu3hZ8cKoa" + }, + "outputs": [], + "source": [ + "def to_latent(vae, adata):\n", + " latent = []\n", + " data = torch.tensor(adata.X.A).to(device)\n", + " vae.eval() # we need to set the model to evaluation mode, so that the dropout is no longer considered\n", + " z = vae.encoder(data)\n", + " latent += [z.to(\"cpu\")]\n", + " return torch.cat(latent).detach().numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "gvL75XqjczEi" + }, + "outputs": [], + "source": [ + "PBMC_train.obsm[\"latent_embedding\"] = to_latent(vae, PBMC_train)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LtCWggV_is46" + }, + "source": [ + "We can further visualize the embedding of the cells in the latent space using UMAP: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "executionInfo": { + "elapsed": 2877, + "status": "ok", + "timestamp": 1711630077524, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "E5rhYljygvdr", + "outputId": "4f9aa10a-f9b0-4958-ef27-f338ad7a7026" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pp.neighbors(\n", + " PBMC_train, use_rep=\"latent_embedding\", n_neighbors=15\n", + ") # use_rep specifies that the calculation is based on the latent embedding\n", + "sc.tl.umap(PBMC_train, random_state=1) # set random state to ensure reproducibility\n", + "sc.pl.umap(PBMC_train, color=[\"cell_type\", \"condition\"], size=10, ncols=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bC9aWVLPkyO9" + }, + "source": [ + "We can see a clear separation into cell types and conditions. However, the latent variables are **not directly interpretable**, i.e. we don't know the biological importance of these features.
\n", + "\n", + "> Repeat this analysis with a smaller latent space (reduce the number of `latent_dims`) → Can you see an effect? If so, can you explain it?\n", + "\n", + "> How does the proportions of the MSE and KLD in the loss function affect the cell's embedding in the latent space? To assess this, try larger values for `beta`. Can you explain the observed changes in the latent embedding?\n", + "\n", + "## Biologically Interpretable VAEs\n", + "To achieve a **direct interpretability** of the model's features, we can modify the architecture of the VAE. Our aim is, that every latent variable represents a **biological pathway**. We follow the same principle that is applied in **VEGA** ([Seninge *et al* (2021)](https://www.nature.com/articles/s41467-021-26017-0)).
\n", + "\n", + "We want to provide the interpretability through the model's **decoder**, and therefore apply the following modifications:\n", + "\n", + "1. **one-layer** decoder: every latent variable is directly connected to the output variables.\n", + "2. **linear** decoder: we do not use any activation function (sigmoid, ReLU,...) in the decoder.\n", + "3. **positive** decoder: we restrict the decoder weights to positive values by setting all negative weights to zero. This allows direct interpretability of the activities of the latent variables.\n", + "4. **sparse** decoder: we use prior-defined gene modules to define the decoder connections. Every latent variable is associated with a specific biological term (pathway) and is only connected to output genes that are related to this pathway." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GG1enDZ5krIe" + }, + "source": [ + "We first need to provide the gene modules that define the model's decoder connections. We use a .gmt file that contains genesets of pathways." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 346, + "status": "ok", + "timestamp": 1711629815279, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "YZ_bUlfZ3TU7", + "outputId": "6eb23d86-6b69-4155-c597-f5e59f39d580" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2024-03-28 12:43:33-- https://raw.githubusercontent.com/LucasESBS/vega-reproducibility/main/data/reactomes.gmt\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.111.133, 185.199.109.133, 185.199.110.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.111.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 330737 (323K) [text/plain]\n", + "Saving to: ‘reactomes.gmt’\n", + "\n", + "reactomes.gmt 100%[===================>] 322.99K --.-KB/s in 0.03s \n", + "\n", + "2024-03-28 12:43:34 (9.85 MB/s) - ‘reactomes.gmt’ saved [330737/330737]\n", + "\n" + ] + } + ], + "source": [ + "# download the .gmt file\n", + "\n", + "!wget -O reactomes.gmt https://raw.githubusercontent.com/LucasESBS/vega-reproducibility/main/data/reactomes.gmt" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dapo0ZwqkrIe" + }, + "source": [ + "Lets first have a look at this file:
\n", + "The first column specifies the gene modulating variable (GMV), in this case the pathway. The second column includes information of the data base, and the following columns contain the genes of the geneset:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 9, + "status": "ok", + "timestamp": 1711629815279, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "WmCD3kj43odm", + "outputId": "5e03cf83-f0bc-4377-b962-edeab344bd4c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "REACTOME_GLYCOGEN_BREAKDOWN_GLYCOGENOLYSIS\thttp://www.broadinstitute.org/gsea/msigdb/cards/REACTOME_GLYCOGEN_BREAKDOWN_GLYCOGENOLYSIS\tAGL\tGYG1\tPGM1\tPHKA1\tPHKA2\tPHKB\tPHKG1\tPHKG2\tPGM2\tPYGB\tPYGL\tPYGM\tPHKA1P1\tLOC650556\tCALM1\tCALM2\tCALM3\tGYG2\n", + "\n", + "REACTOME_TRANSLATION\thttp://www.broadinstitute.org/gsea/msigdb/cards/REACTOME_TRANSLATION\tSEC61B\tRPL35\tEEF1DP1\tRPL7AP27\tDDOST\tEEF1A1\tEEF1B2\tEEF1D\tEEF1G\tEEF2\tEIF1AX\tEIF2S1\tEIF2B1\tEIF2S3\tEIF4A1\tEIF4A2\tEIF4B\tEIF4E\tEIF4EBP1\tEIF4G1\tEIF5\tETF1\tFAU\tTRAM1\tSEC11A\tSEC61G\tRPL13A\tGSPT2\tRPL36\tPABPC1\tEIF3K\tRPL10P16\tFAM153A\tSPCS1\tSEC61A1\tEIF3FP3\tRPL36P14\tEIF3E\tRPSAP12\tRPS8P10\tRPL7AP66\tRPL10P9\tRPS12P4\tRPSA\tRPS26P10\tRPL23AP2\tRPS12P22\tRPL21P29\tRPS26P35\tRPL10A\tRPL26L1\tSEC61A2\tSRPRB\tSPCS3\tRPL3\tRPL3L\tRPL4\tRPL5\tRPL6\tRPL7\tRPL7A\tRPL8\tRPL9\tRPL10\tRPL11\tRPL12\tRPL13\tRPL15\tRPL17\tRPL18\tRPL18A\tRPL19\tRPL21\tRPL22\tRPL23A\tRPL24\tRPL26\tRPL27\tRPL30\tRPL27A\tRPL28\tRPL29\tRPL31\tRPL32\tRPL34\tRPL35A\tRPL37\tRPL37A\tRPL38\tRPL39\tRPL41\tRPL36A\tRPLP0\tRPLP1\tRPLP2\tRPN1\tRPN2\tRPS2\tRPS3\tRPS3A\tRPS4X\tRPS4Y1\tRPS5\tRPS6\tRPS7\tRPS8\tRPS9\tRPS10\tRPS11\tRPS12\tRPS13\tRPS14\tRPS15\tRPS15A\tRPS16\tRPS17\tRPS18\tRPS19\tRPS20\tRPS21\tRPS23\tRPS24\tRPS25\tRPS26\tRPS27\tRPS27A\tRPS28\tRPS29\tRPL6P19\tLOC647030\tLOC641895\tRPL36AP31\tRPS29P3\tRPS26P28\tRPL36AP8\tRPL26P22\tRPS26P20\tRPS15AP11\tRPS26P50\tRPL22P11\tRPL17P6\tRPS13P8\tRPS28P4\tRPL32P16\tLOC646184\tRPS28P7\tRPL12P2\tLOC647074\tRPL23AP42\tRPL5P1\tRPL36AP51\tLOC649602\tLOC650638\tRPS28P9\tRPL34P27\tLOC651825\tLOC651894\tLOC652607\tRPL26P30\tRPSAP9\tSRP9P1\tRPL19P9\tLOC653566\tRPL21P119\tRPL31P17\tLOC653881\tLOC653994\tSRP9\tSRP14\tSRP19\tSRP54\tSRP68\tSRP72\tSRPR\tSSR1\tSSR2\tSSR3\tSSR4\tRPL31P31\tRPL15P17\tRPL23AP18\tRPL26P24\tRPL21P75\tRPS27AP11\tRPS26P7\tRPL21P134\tRPS26P25\tRPS19P3\tRPL36AP23\tRPS18P10\tRPL17P36\tRPL36AP37\tRPL21P16\tRPL23AP74\tRPS15P5\tRPL23AP63\tLOC729998\tRPS10P9\tLOC730343\tRPS18P5\tUBA52\tRPL34P31\tEIF4H\tEIF3A\tEIF3B\tEIF3C\tEIF3D\tEIF3F\tEIF3G\tEIF3H\tEIF3I\tEIF3J\tEIF2B4\tEIF2B3\tEIF2B2\tEIF2B5\tEIF2S2\tRPL14\tSEC11C\tRPL23\tEIF5B\tSPCS2\n", + "\n", + "REACTOME_PYRIMIDINE_CATABOLISM\thttp://www.broadinstitute.org/gsea/msigdb/cards/REACTOME_PYRIMIDINE_CATABOLISM\tUPP2\tDPYD\tDPYS\tTYMP\tNT5C\tNT5E\tNT5C3\tUPB1\tNT5M\tAGXT2\tUPP1\tNT5C1A\n", + "\n", + "REACTOME_RNA_POL_III_TRANSCRIPTION_INITIATION_FROM_TYPE_2_PROMOTER\thttp://www.broadinstitute.org/gsea/msigdb/cards/REACTOME_RNA_POL_III_TRANSCRIPTION_INITIATION_FROM_TYPE_2_PROMOTER\tPOLR3F\tPOLR3C\tPOLR3A\tLZTS1\tPOLR3H\tBRF1\tGTF3C2\tPOLR1D\tPOLR3K\tPOLR2E\tPOLR2F\tPOLR2H\tPOLR2K\tPOLR2L\tPOLR3B\tPOLR3E\tPOLR3D\tTBP\tPOLR3GL\tGTF3C5\tGTF3C4\tGTF3C3\tPOLR1C\n", + "\n", + "REACTOME_INHIBITION_OF_THE_PROTEOLYTIC_ACTIVITY_OF_APC_C_REQUIRED_FOR_THE_ONSET_OF_ANAPHASE_BY_MITOTIC_SPINDLE_CHECKPOINT_COMPONENTS\thttp://www.broadinstitute.org/gsea/msigdb/cards/REACTOME_INHIBITION_OF_THE_PROTEOLYTIC_ACTIVITY_OF_APC_C_REQUIRED_FOR_THE_ONSET_OF_ANAPHASE_BY_MITOTIC_SPINDLE_CHECKPOINT_COMPONENTS\tANAPC10\tUBE2C\tCDC26\tANAPC2\tANAPC4\tMAD2L1\tANAPC5\tANAPC7\tANAPC11\tANAPC1\tLOC647654\tLOC649620\tLOC650621\tLOC651763\tBUB1B\tCDC26P1\tLOC730594\tUBE2D1\tUBE2E1\tCDC23\tCDC16\tBUB3\tCDC20\tCDC27\n", + "\n", + "REACTOME_PYRUVATE_METABOLISM_AND_CITRIC_ACID_TCA_CYCLE\thttp://www.broadinstitute.org/gsea/msigdb/cards/REACTOME_PYRUVATE_METABOLISM_AND_CITRIC_ACID_TCA_CYCLE\tADHFE1\tCS\tDLAT\tDLD\tDLST\tFH\tNNT\tSLC16A8\tLOC283398\tIDH1\tIDH2\tIDH3A\tIDH3B\tIDH3G\tLDHA\tLDHB\tMDH2\tOGDH\tACO2\tPDHA1\tPDHB\tPDK1\tPDK2\tPDK3\tPDK4\tPDP1\tPDPR\tPDP2\tSDHA\tSDHB\tSDHC\tSDHD\tSUCLA2P1\tLOC646675\tLOC646677\tLOC650667\tLOC650674\tLOC650883\tLOC651820\tSLC16A1\tBSG\tD2HGDH\tL2HGDH\tPDHX\tSUCLG2\tSUCLG1\tSUCLA2\tSLC16A3\n", + "\n", + "REACTOME_EXTRINSIC_PATHWAY_FOR_APOPTOSIS\thttp://www.broadinstitute.org/gsea/msigdb/cards/REACTOME_EXTRINSIC_PATHWAY_FOR_APOPTOSIS\tFAS\tFASLG\tTNF\tTNFRSF1A\tTRAF2\tCASP8\tCASP10\tTRADD\tRIPK1\tTNFSF10\tFADD\tTNFRSF10B\tCFLAR\n", + "\n", + "REACTOME_PTM_GAMMA_CARBOXYLATION_HYPUSINE_FORMATION_AND_ARYLSULFATASE_ACTIVATION\thttp://www.broadinstitute.org/gsea/msigdb/cards/REACTOME_PTM_GAMMA_CARBOXYLATION_HYPUSINE_FORMATION_AND_ARYLSULFATASE_ACTIVATION\tARSK\tDHPS\tEIF5A\tF2\tF7\tF9\tF10\tARSG\tSUMF2\tGGCX\tSUMF1\tARSI\tARSH\tARSA\tARSB\tSTS\tARSE\tARSF\tFURIN\tPROC\tPROS1\tEIF5A2\tLOC652612\tVKORC1\tARSJ\tDOHH\tPROZ\n", + "\n", + "REACTOME_APOPTOTIC_CLEAVAGE_OF_CELLULAR_PROTEINS\thttp://www.broadinstitute.org/gsea/msigdb/cards/REACTOME_APOPTOTIC_CLEAVAGE_OF_CELLULAR_PROTEINS\tBCAP31\tADD1\tCTNNB1\tDSG1\tDSG2\tDSG3\tDSP\tACIN1\tFNTA\tGAS2\tDBNL\tGSN\tAPC\tBIRC2\tLMNA\tLMNB1\tMAPT\tOCLN\tMST4\tPKP1\tPLEC\tPRKCD\tPRKCQ\tPTK2\tROCK1\tSATB1\tLOC647859\tLOC652460\tBMX\tSPTAN1\tTJP1\tROCK1P1\tVIM\tCASP3\tCASP6\tCASP7\tCASP8\tSTK24\tTJP2\tCDH1\n", + "\n", + "REACTOME_RNA_POL_I_TRANSCRIPTION_TERMINATION\thttp://www.broadinstitute.org/gsea/msigdb/cards/REACTOME_RNA_POL_I_TRANSCRIPTION_TERMINATION\tCDK7\tERCC2\tERCC3\tPOLR1A\tPTRF\tGTF2H1\tGTF2H2\tGTF2H3\tGTF2H4\tMNAT1\tPOLR1D\tPOLR2H\tPOLR2K\tLOC652857\tGTF2H2B\tUBTF\tPOLR1B\tTAF1C\tTAF1B\tTAF1A\tCCNH\tPOLR1C\n", + "\n" + ] + } + ], + "source": [ + "with open(\"reactomes.gmt\") as gmt_file: # print first lines of the gmt file\n", + " gmt_head = gmt_file.readlines()[0:10]\n", + " for row in gmt_head:\n", + " print(row)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B6mWBaaskrIf" + }, + "source": [ + "Based on this .gmt file, we first write a function to create a **mask $M$**, that we will use later to define the decoder connections.
\n", + "\n", + "The rows of the mask $M$ correspond to genes (of the data set), the columns to pathways (of the .gmt file). If the gene $i$ is annotated in the gene set of the pathway $j$, the corresponding entry of the matrix $M(i,j)$ contains the value 1, otherwise the value 0.
\n", + "\n", + "We can further add **fully connected nodes** to the latent space (with the parameter `add_nodes`), that are connected to all output variables. This allows better data reconstruction and compensates for connections, that are missing in our prior defined gene sets (these are likely incomplete). These fully connected nodes are also included in the mask (all values are ones)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "wv9NW-tmoWxY" + }, + "outputs": [], + "source": [ + "####### In the following sections, we used and adapted code from https://github.com/LucasESBS/vega ######\n", + "\n", + "\n", + "def create_mask(adata, gmt_path: str = None, add_nodes: int = 1, sep=\"\\t\"):\n", + " \"\"\"\n", + " Initialize mask M for GMVs from a .gmt file\n", + " Args:\n", + " adata (Anndata): Scanpy single-cell object, we will store the computed mask and the names of the biological processes there\n", + " gmt_path (str): path to .gmt file\n", + " add_nodes (int): Additional latent nodes for capturing additional variance\n", + " Return:\n", + " adata (Anndata): Scanpy single-cell object that now stores the computed mask and the names of biological processes (in the .uns[\"_vega\"] attribute)\n", + " mask (array): mask M that specifies whether a gene is included in the gene set of a pathway (value one) or not (value zero)\n", + " \"\"\"\n", + "\n", + " gmv_dict = OrderedDict()\n", + " with open(gmt_path) as f:\n", + " for line in f.readlines():\n", + " line = line.strip()\n", + " spli = line.split(sep)\n", + " gmv_dict[spli[0]] = spli[2:]\n", + "\n", + " feature_list = adata.var.index.tolist()\n", + "\n", + " # Create mask\n", + " mask = np.zeros((len(feature_list), len(gmv_dict)))\n", + " for j, k in enumerate(gmv_dict.keys()):\n", + " for i in range(mask.shape[0]):\n", + " if feature_list[i] in gmv_dict[k]:\n", + " mask[i, j] = 1.0\n", + " # Add unannotated nodes\n", + " vec = np.ones((mask.shape[0], add_nodes))\n", + " mask = np.hstack((mask, vec))\n", + "\n", + " adata.uns[\n", + " \"_vega\"\n", + " ] = dict() # create attribute \"_vega\" to store the mask and pathway information\n", + " adata.uns[\"_vega\"][\"mask\"] = mask\n", + " adata.uns[\"_vega\"][\"gmv_names\"] = list(gmv_dict.keys()) + [\n", + " \"UNANNOTATED_\" + str(k) for k in range(add_nodes)\n", + " ]\n", + "\n", + " return adata, mask" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "76PRg_n51Rc0" + }, + "outputs": [], + "source": [ + "# we can now create the mask from the .gmt file and our data set\n", + "PBMC_train, mask = create_mask(PBMC_train, gmt_path=\"reactomes.gmt\", add_nodes=1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 15, + "status": "ok", + "timestamp": 1711629819001, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "_cOZ86e65ACs", + "outputId": "8675d3ca-fe2c-4d39-8aba-5c132d6fedf0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0. 0. 0. ... 0. 0. 1.]\n", + " [0. 0. 0. ... 0. 0. 1.]\n", + " [0. 0. 0. ... 0. 0. 1.]\n", + " ...\n", + " [0. 0. 0. ... 0. 0. 1.]\n", + " [0. 0. 0. ... 0. 0. 1.]\n", + " [0. 0. 0. ... 0. 0. 1.]]\n" + ] + } + ], + "source": [ + "# Let's take a look at the mask:\n", + "print(mask)\n", + "# we can see that the mask stores zeroes and ones\n", + "# the last column contains only ones, since this column represents the fully connected node (connected to all output genes)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uRLANOr7krIg" + }, + "source": [ + "Since we want to achieve the interpretability through the model's **decoder**, we can just modify this part of the architecture while using the same encoder as before:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "vr4zoHCFn4Mh" + }, + "outputs": [], + "source": [ + "# define VEGA's decoder\n", + "\n", + "\n", + "class DecoderVEGA(nn.Module):\n", + " \"\"\"\n", + " Define VEGA's decoder (sparse, one-layer, linear, positive)\n", + " \"\"\"\n", + "\n", + " def __init__(self, mask):\n", + " super(DecoderVEGA, self).__init__()\n", + "\n", + " self.sparse_layer = nn.Sequential(\n", + " SparseLayer(mask)\n", + " ) # we define the architecture of the decoder below with the class \"SparseLayer\"\n", + "\n", + " def forward(self, x):\n", + " z = self.sparse_layer(x.to(device))\n", + " return z\n", + "\n", + " def positive_weights(self):\n", + " \"\"\"\n", + " constrain the decoder to positive weights (set negative weigths to zero)\n", + " \"\"\"\n", + " w = self.sparse_layer[0].weight\n", + " w.data = w.data.clamp(0)\n", + " return w\n", + "\n", + "\n", + "# define a class SparseLayer, that specifies the decoder architecture (sparse connections based on the mask)\n", + "class SparseLayer(nn.Module):\n", + " def __init__(self, mask):\n", + " \"\"\"\n", + " Extended torch.nn module which mask connection\n", + " \"\"\"\n", + " super(SparseLayer, self).__init__()\n", + "\n", + " self.mask = nn.Parameter(\n", + " torch.tensor(mask, dtype=torch.float).t(), requires_grad=False\n", + " )\n", + " self.weight = nn.Parameter(torch.Tensor(mask.shape[1], mask.shape[0]))\n", + " self.bias = nn.Parameter(torch.Tensor(mask.shape[1]))\n", + " self.reset_parameters()\n", + "\n", + " # mask weight\n", + " self.weight.data = self.weight.data * self.mask\n", + "\n", + " def reset_parameters(self):\n", + " stdv = 1.0 / math.sqrt(self.weight.size(1))\n", + " self.weight.data.uniform_(-stdv, stdv)\n", + " self.bias.data.uniform_(-stdv, stdv)\n", + "\n", + " def forward(self, input):\n", + " # See the autograd section for explanation of what happens here\n", + " return SparseLayerFunction.apply(input, self.weight, self.bias, self.mask)\n", + "\n", + "\n", + "######### You don't need to understand this part of the code in detail #########\n", + "class SparseLayerFunction(torch.autograd.Function):\n", + " \"\"\"\n", + " We define our own autograd function which masks it's weights by 'mask'.\n", + " For more details, see https://pytorch.org/docs/stable/notes/extending.html\n", + " \"\"\"\n", + "\n", + " # Note that both forward and backward are @staticmethods\n", + " @staticmethod\n", + " def forward(ctx, input, weight, bias, mask):\n", + " weight = weight * mask # change weight to 0 where mask == 0\n", + " # calculate the output\n", + " output = input.mm(weight.t())\n", + " output += bias.unsqueeze(0).expand_as(\n", + " output\n", + " ) # Add bias to all values in output\n", + " ctx.save_for_backward(input, weight, bias, mask)\n", + " return output\n", + "\n", + " @staticmethod\n", + " def backward(ctx, grad_output): # define the gradient formula\n", + " input, weight, bias, mask = ctx.saved_tensors\n", + " grad_input = grad_weight = grad_bias = grad_mask = None\n", + "\n", + " # These needs_input_grad checks are optional and only to improve efficiency\n", + " if ctx.needs_input_grad[0]:\n", + " grad_input = grad_output.mm(weight)\n", + " if ctx.needs_input_grad[1]:\n", + " grad_weight = grad_output.t().mm(input)\n", + " # change grad_weight to 0 where mask == 0\n", + " grad_weight = grad_weight * mask\n", + " if ctx.needs_input_grad[2]:\n", + " grad_bias = grad_output.sum(0).squeeze(0)\n", + "\n", + " return grad_input, grad_weight, grad_bias, grad_mask" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "w_K6yFgs8rRO" + }, + "outputs": [], + "source": [ + "class VEGA(nn.Module):\n", + " def __init__(self, latent_dims, input_dims, mask, dropout=0.3, z_dropout=0.3):\n", + " super(VEGA, self).__init__()\n", + " self.encoder = Encoder(\n", + " latent_dims, input_dims, dropout, z_dropout\n", + " ) # we use the same encoder as before (two-layer, fully connected, non-linear)\n", + " self.decoder = DecoderVEGA(mask)\n", + "\n", + " def forward(self, x):\n", + " z = self.encoder(x)\n", + " return self.decoder(z)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "puReN5l2JC9t" + }, + "outputs": [], + "source": [ + "# training loop\n", + "def trainVEGA(vae, data, epochs=100, beta=0.0001, learning_rate=0.001):\n", + " opt = torch.optim.Adam(vae.parameters(), lr=learning_rate, weight_decay=5e-4)\n", + " vae.train() # train mode\n", + " losses = []\n", + " klds = []\n", + " mses = []\n", + "\n", + " for epoch in range(epochs):\n", + " loss_e = 0\n", + " kld_e = 0\n", + " mse_e = 0\n", + "\n", + " for x in data:\n", + " x = x.to(device)\n", + " opt.zero_grad()\n", + " x_hat = vae(x)\n", + " mse = ((x - x_hat) ** 2).sum()\n", + " kld = beta * vae.encoder.kl\n", + " loss = mse + kld # loss calculation\n", + " loss.backward()\n", + " opt.step()\n", + " loss_e += loss.to(\"cpu\").detach().numpy()\n", + " kld_e += kld.to(\"cpu\").detach().numpy()\n", + " mse_e += mse.to(\"cpu\").detach().numpy()\n", + " vae.decoder.positive_weights() # we restrict the decoder for positive weights\n", + "\n", + " losses.append(loss_e / (len(data) * 128))\n", + " klds.append(kld_e / (len(data) * 128))\n", + " mses.append(mse_e / (len(data) * 128))\n", + "\n", + " print(\"epoch: \", epoch, \" loss: \", loss_e / (len(data) * 128))\n", + "\n", + " return vae, losses, klds, mses" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-bOUK1mgo4A9" + }, + "source": [ + "We initialize the VEGA model, based on the mask that we constructed above:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 108636, + "status": "ok", + "timestamp": 1711629927631, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "3wk38R6k5nBV", + "outputId": "3abacb47-1366-4c86-d42e-15f317f6da1e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch: 0 loss: 340.5863746787017\n", + "epoch: 1 loss: 309.39660126308223\n", + "epoch: 2 loss: 296.94265948601486\n", + "epoch: 3 loss: 285.03912382305793\n", + "epoch: 4 loss: 277.34535246075325\n", + "epoch: 5 loss: 270.0902613513875\n", + "epoch: 6 loss: 264.2828821146263\n", + "epoch: 7 loss: 259.6643161413805\n", + "epoch: 8 loss: 254.80099156217756\n", + "epoch: 9 loss: 250.54355434201798\n", + "epoch: 10 loss: 246.79649007545328\n", + "epoch: 11 loss: 243.5580506234799\n", + "epoch: 12 loss: 240.12999840502468\n", + "epoch: 13 loss: 236.9556444276054\n", + "epoch: 14 loss: 234.26188530112213\n", + "epoch: 15 loss: 232.0707636419332\n", + "epoch: 16 loss: 229.24071373129792\n", + "epoch: 17 loss: 227.13787985747715\n", + "epoch: 18 loss: 224.1689058699698\n", + "epoch: 19 loss: 221.9946587040739\n", + "epoch: 20 loss: 220.0604763390883\n", + "epoch: 21 loss: 217.88739870179376\n", + "epoch: 22 loss: 215.8685381187583\n", + "epoch: 23 loss: 214.59035110473633\n", + "epoch: 24 loss: 213.3572571952388\n", + "epoch: 25 loss: 211.6262318593151\n", + "epoch: 26 loss: 210.7532768969266\n", + "epoch: 27 loss: 209.6019000647203\n", + "epoch: 28 loss: 208.4586658117906\n", + "epoch: 29 loss: 207.38681267792325\n", + "epoch: 30 loss: 206.40753418544554\n", + "epoch: 31 loss: 205.88464369863834\n", + "epoch: 32 loss: 204.8888107875608\n", + "epoch: 33 loss: 204.20026131396023\n", + "epoch: 34 loss: 203.73860859421063\n", + "epoch: 35 loss: 203.2030366141841\n", + "epoch: 36 loss: 202.19532631928067\n", + "epoch: 37 loss: 202.04097431110887\n", + "epoch: 38 loss: 201.53788455027455\n", + "epoch: 39 loss: 200.94347100887657\n", + "epoch: 40 loss: 200.61125996427717\n", + "epoch: 41 loss: 200.27582636419334\n", + "epoch: 42 loss: 200.54599625209593\n", + "epoch: 43 loss: 200.13075637817383\n", + "epoch: 44 loss: 199.45993848116893\n", + "epoch: 45 loss: 199.10142171607828\n", + "epoch: 46 loss: 198.73084662095556\n", + "epoch: 47 loss: 198.30178775427476\n", + "epoch: 48 loss: 198.16188891428823\n", + "epoch: 49 loss: 198.2093222995974\n", + "epoch: 50 loss: 198.4439872165896\n", + "epoch: 51 loss: 197.80237147493182\n", + "epoch: 52 loss: 197.3339367992473\n", + "epoch: 53 loss: 197.66157783652253\n", + "epoch: 54 loss: 197.48313054498635\n", + "epoch: 55 loss: 197.33541690178637\n", + "epoch: 56 loss: 196.9069519762723\n", + "epoch: 57 loss: 196.98506531625424\n", + "epoch: 58 loss: 196.80326353828863\n", + "epoch: 59 loss: 197.7941747701393\n", + "epoch: 60 loss: 197.00756699184203\n", + "epoch: 61 loss: 196.82669873507518\n", + "epoch: 62 loss: 196.63427719979916\n", + "epoch: 63 loss: 196.88535510369067\n", + "epoch: 64 loss: 196.41990834362102\n", + "epoch: 65 loss: 196.64218348377156\n", + "epoch: 66 loss: 196.3811110730441\n", + "epoch: 67 loss: 196.09772448269825\n", + "epoch: 68 loss: 196.09648434620982\n", + "epoch: 69 loss: 195.9815591776146\n", + "epoch: 70 loss: 195.931324868832\n", + "epoch: 71 loss: 196.1854161676371\n", + "epoch: 72 loss: 196.13399440837355\n", + "epoch: 73 loss: 196.49724348536077\n", + "epoch: 74 loss: 196.27443068882204\n", + "epoch: 75 loss: 196.07327428853736\n", + "epoch: 76 loss: 195.93591574902806\n", + "epoch: 77 loss: 195.9491539721219\n", + "epoch: 78 loss: 195.7863025305406\n", + "epoch: 79 loss: 196.1945345896595\n", + "epoch: 80 loss: 195.73907211591612\n", + "epoch: 81 loss: 195.52302752800708\n", + "epoch: 82 loss: 195.66712059164948\n", + "epoch: 83 loss: 195.8698458401662\n", + "epoch: 84 loss: 195.7220373333625\n", + "epoch: 85 loss: 196.3299692981648\n", + "epoch: 86 loss: 196.02604488156877\n", + "epoch: 87 loss: 195.7383868379413\n", + "epoch: 88 loss: 195.55521565563274\n", + "epoch: 89 loss: 195.93327986519293\n", + "epoch: 90 loss: 196.30167180187297\n", + "epoch: 91 loss: 195.905688735674\n", + "epoch: 92 loss: 195.6414948949274\n", + "epoch: 93 loss: 195.53134529545622\n", + "epoch: 94 loss: 195.58839941924472\n", + "epoch: 95 loss: 195.4914650827084\n", + "epoch: 96 loss: 195.36164380919257\n", + "epoch: 97 loss: 195.45832990250497\n", + "epoch: 98 loss: 195.86898551796966\n", + "epoch: 99 loss: 195.4500675561293\n" + ] + } + ], + "source": [ + "vega = VEGA(\n", + " latent_dims=mask.shape[1],\n", + " input_dims=mask.shape[0],\n", + " mask=mask.T,\n", + " z_dropout=0.5,\n", + " dropout=0.3,\n", + ").to(device)\n", + "# model training\n", + "vega, vega_losses, vega_klds, vega_mses = trainVEGA(\n", + " vega, PBMC_trainX, epochs=100, beta=0.0001\n", + ") # takes about 2 mins on GPU" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 860 + }, + "executionInfo": { + "elapsed": 691, + "status": "ok", + "timestamp": 1711629928311, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "Nq7kZZsv5vak", + "outputId": "21a9edf2-bc5b-4a7a-ec1c-a37ed4ff5053" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 198, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the loss curve\n", + "plt.plot(vega_losses)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 860 + }, + "executionInfo": { + "elapsed": 365, + "status": "ok", + "timestamp": 1711629928665, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "pVWBtQA7aqOc", + "outputId": "fe6f64f6-63f4-42ca-efce-7dc4c07f6e0b" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 199, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot mse and kld\n", + "plt.plot(vega_mses, label=\"MSE\")\n", + "plt.plot(vega_klds, label=\"KLD\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 10, + "status": "ok", + "timestamp": 1711629928666, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "DA1Xm6LjCEHe", + "outputId": "1dddd02f-fde8-4e4f-97a6-a99bfc504b26" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(0, device='cuda:0')\n" + ] + } + ], + "source": [ + "# we can see that all decoder weights are positive:\n", + "print(\n", + " torch.sum(vega.state_dict()[\"decoder.sparse_layer.0.weight\"] < 0)\n", + ") # zero negative weights" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Dn14hfU4pNcn" + }, + "source": [ + "Again, we can have a look at the embedding of the cells in the latent space, colored by condition and cell type:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "executionInfo": { + "elapsed": 18540, + "status": "ok", + "timestamp": 1711631304802, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "bunPATWUJbZ5", + "outputId": "71535dfd-c88f-4353-fdaf-663046a5d3a7" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "PBMC_train.obsm[\"latent_embedding\"] = to_latent(\n", + " vega, PBMC_train\n", + ") # project the cells to the model's latent space\n", + "\n", + "# UMAP based on the latent embedding\n", + "sc.pp.neighbors(PBMC_train, use_rep=\"latent_embedding\", n_neighbors=15)\n", + "sc.tl.umap(PBMC_train, random_state=1) # set random state to ensure reproducibility\n", + "sc.pl.umap(PBMC_train, color=[\"cell_type\", \"condition\"], size=10, ncols=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yr71nEQKp0Ie" + }, + "source": [ + "Since the latent variables now each correspond to a specific pathway, we can further color the cells according to pathway activities:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 876 + }, + "executionInfo": { + "elapsed": 1118, + "status": "ok", + "timestamp": 1711631360242, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "IscMceywpu84", + "outputId": "aecaed1e-6eb9-455e-d074-0ff5e43d776e" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pathway_of_interest = \"REACTOME_INTERFERON_ALPHA_BETA_SIGNALING\"\n", + "\n", + "pathways = PBMC_train.uns[\"_vega\"][\"gmv_names\"] # the names of the GMVs are stored here\n", + "pw_activities = PBMC_train.obsm[\n", + " \"latent_embedding\"\n", + "] # pathway activities (we stored them here when projecting the data to the latent space (see above))\n", + "\n", + "# for visualization with the scanpy package, we need to provide the annotation (based on which cells should be colored) in the .obs attribute\n", + "PBMC_train.obs[pathway_of_interest] = PBMC_train.obsm[\"latent_embedding\"][\n", + " :, pathways.index(pathway_of_interest)\n", + "]\n", + "sc.pl.umap(PBMC_train, color=[pathway_of_interest], size=10, ncols=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cUPJe9xoqX0D" + }, + "source": [ + "As expected, the `\"REACTOME_INTERFERON_ALPHA_BETA_SIGNALING\"` pathway is more active in IFNb stimulated cells!\n", + "\n", + "> Color the cells according to `'REACTOME_ANTIVIRAL_MECHANISM_BY_IFN_STIMULATED_GENES'`, `'REACTOME_DOPAMINE_NEUROTRANSMITTER_RELEASE_CYCLE'` and `'REACTOME_DOWNSTREAM_SIGNALING_EVENTS_OF_B_CELL_RECEPTOR_BCR'`. Can you observe the expected results? If not, what could be the reason for this?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SGb6PP2P7klG" + }, + "source": [ + "We can further determine important genes for specific pathways by looking at the **decoder weights**.
\n", + "We therefore define a function to plot the ranked weights:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "h5pYQ7us7fwu" + }, + "outputs": [], + "source": [ + "def plot_ranked_gene_weights(model: VEGA, adata, gmv, n_genes: int = 10):\n", + " \"\"\"\n", + " Plot gene members of input GMVs according to their magnitude.\n", + " \"\"\"\n", + " w = vega.state_dict()[\"decoder.sparse_layer.0.weight\"].to(\"cpu\")\n", + " gmv_names = list(adata.uns[\"_vega\"][\"gmv_names\"])\n", + " gene_names = adata.var.index.tolist()\n", + "\n", + " # Get values\n", + " i = gmv_names.index(gmv)\n", + " w_i = w[:, i].detach().numpy()\n", + " sort_idx = np.argsort(w_i)[::-1]\n", + " sort_w = w_i[sort_idx][:n_genes]\n", + " genes = np.array(gene_names)[sort_idx][:n_genes]\n", + "\n", + " # Set plot params\n", + " ymin = np.min(sort_w)\n", + " ymax = np.max(sort_w)\n", + " ymax += 0.3 * (ymax - ymin)\n", + "\n", + " # Plot\n", + " for ig, gene_name in enumerate(genes):\n", + " plt.text(\n", + " ig,\n", + " sort_w[ig],\n", + " gene_name,\n", + " rotation=\"vertical\",\n", + " verticalalignment=\"bottom\",\n", + " horizontalalignment=\"center\",\n", + " color=\"black\",\n", + " )\n", + " plt.title(gmv)\n", + " plt.ylim(ymin, ymax)\n", + " plt.xlim(-0.9, n_genes - 0.1)\n", + " plt.xlabel(\"Ranking\")\n", + " plt.ylabel(\"Weight magnitude\")\n", + " plt.xticks(np.arange(0, n_genes, step=1), labels=np.arange(1, n_genes + 1, step=1))\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CETpPaRZn9TT" + }, + "source": [ + "For instance, we can identify ISGs (Interferon stimulated genes) and IFITs (Interferon Induced Proteins With Tetratricopeptide Repeat) for the Interferon alpha/beta signaling pathway:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 924 + }, + "executionInfo": { + "elapsed": 20, + "status": "ok", + "timestamp": 1711629946235, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "fCYC-NNM7jIW", + "outputId": "5af6caac-c241-41be-86b2-41a457a22bc6" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_ranked_gene_weights(\n", + " vega, gmv=\"REACTOME_INTERFERON_ALPHA_BETA_SIGNALING\", adata=PBMC_train, n_genes=20\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jdLCTD-ekrIk" + }, + "source": [ + "## Exercises\n", + "1. Adding fully connected nodes improves the data reconstruction and can compensate for missing links in our prior defined gene modules. However, what potential drawbacks might arise from adding too many of these nodes?\n", + "\n", + "2. As you have seen above, we added a dropout layer in the model's latent space. What could be the advantage of this?\n", + "\n", + "3. We provide a set of validation data below (`PBMC_valid`).
\n", + "Can you add this validation data to the training loop, and check whether our model is **overfitted**? For this, plot both loss curves (training and validation), and explain how we could identify potential overfitting based on these curves.
\n", + "Can you explain why the loss of the validation set is smaller than the loss of the training set?\n", + "
*Hint:* First, you need to set up the data set in the right format with the `torch.utils.data.DataLoader()` function. Then, iterate over this data within the training loop. Make sure to set the model to evaluation mode (with `vae.eval()`) and to not update the parameters, since this is only for validation!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 3342, + "status": "ok", + "timestamp": 1711629949558, + "user": { + "displayName": "Anna von Bachmann", + "userId": "01675554630686370026" + }, + "user_tz": -60 + }, + "id": "-P5cRIzqvp7M", + "outputId": "fbd396d5-c7b6-46c6-9c69-0858619a3167" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2024-03-28 12:45:45-- https://docs.google.com/uc?export=download&id=1rJKZYIG7rv7BQbDD9RElYOgHcxxzjcYj\n", + "Resolving docs.google.com (docs.google.com)... 142.251.180.102, 142.251.180.101, 142.251.180.113, ...\n", + "Connecting to docs.google.com (docs.google.com)|142.251.180.102|:443... connected.\n", + "HTTP request sent, awaiting response... 303 See Other\n", + "Location: https://drive.usercontent.google.com/download?id=1rJKZYIG7rv7BQbDD9RElYOgHcxxzjcYj&export=download [following]\n", + "--2024-03-28 12:45:45-- https://drive.usercontent.google.com/download?id=1rJKZYIG7rv7BQbDD9RElYOgHcxxzjcYj&export=download\n", + "Resolving drive.usercontent.google.com (drive.usercontent.google.com)... 108.177.112.132, 2607:f8b0:4001:c12::84\n", + "Connecting to drive.usercontent.google.com (drive.usercontent.google.com)|108.177.112.132|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 10923368 (10M) [application/octet-stream]\n", + "Saving to: ‘PBMC_valid.h5ad’\n", + "\n", + "PBMC_valid.h5ad 100%[===================>] 10.42M 40.9MB/s in 0.3s \n", + "\n", + "2024-03-28 12:45:49 (40.9 MB/s) - ‘PBMC_valid.h5ad’ saved [10923368/10923368]\n", + "\n" + ] + } + ], + "source": [ + "# download the data\n", + "!wget --no-check-certificate 'https://docs.google.com/uc?export=download&id=1rJKZYIG7rv7BQbDD9RElYOgHcxxzjcYj' -O PBMC_valid.h5ad\n", + "# load data as anndata object\n", + "PBMC_valid = sc.read_h5ad(\"PBMC_valid.h5ad\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "GQl_oew2bDIr" + }, + "outputs": [], + "source": [ + "###### provide your solution for exercise 3 here ######\n", + "\n", + "### Here you should set up the data\n", + "PBMC_validX =\n", + "\n", + "### training loop\n", + "def trainVEGA_with_valid(vae, data, val_data, epochs=100, beta = 0.0001, learning_rate = 0.001):\n", + " opt = torch.optim.Adam(vae.parameters(), lr = learning_rate, weight_decay = 5e-4)\n", + " train_losses = []\n", + " valid_losses = []\n", + " for epoch in range(epochs):\n", + " train_loss_e = 0\n", + " valid_loss_e = 0\n", + " vae.train() #train mode\n", + "\n", + " for x in data:\n", + " x = x.to(device) # GPU\n", + " opt.zero_grad()\n", + " x_hat = vae(x)\n", + " loss = ((x - x_hat)**2).sum() + beta* vae.encoder.kl\n", + " loss.backward()\n", + " opt.step()\n", + " train_loss_e += loss.to('cpu').detach().numpy()\n", + " vae.decoder.positive_weights() # we restrict the decoder to positive weights\n", + " train_losses.append(train_loss_e/(len(data)*128))\n", + "\n", + " #### Here you should add the validation loop\n", + "\n", + " print(\"epoch: \", epoch, \" train_loss: \", train_loss_e/(len(data)*128))\n", + " #### print also the validation loss after each epoch!\n", + "\n", + " return vae, train_losses, valid_losses\n", + "\n", + "\n", + "# model initialization and training\n", + "vega = VEGA(latent_dims= mask.shape[1], input_dims = mask.shape[0], mask = mask.T, dropout = 0.3, z_dropout = 0.3).to(device)\n", + "vega, train_losses, valid_losses = trainVEGA_with_valid(vega, PBMC_trainX, PBMC_validX, epochs = 50, beta = 0.0001)\n", + "\n", + "\n", + "### plot the loss curves:\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/old_code/old_notebooks/ab-experiments-normal.ipynb b/old_code/old_notebooks/ab-experiments-normal.ipynb new file mode 100644 index 0000000..81d8864 --- /dev/null +++ b/old_code/old_notebooks/ab-experiments-normal.ipynb @@ -0,0 +1,1805 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n" + ] + } + ], + "source": [ + "import torch; torch.manual_seed(100)\n", + "import math\n", + "\n", + "import numpy as np\n", + "import torch.distributions\n", + "import torch.nn as nn\n", + "import torch.utils\n", + "import torchvision\n", + "from torchvision import datasets, transforms\n", + "\n", + "np.random.seed(100)\n", + "import matplotlib.pyplot as plt; plt.rcParams['figure.dpi'] = 200\n", + "from collections import Counter, OrderedDict\n", + "\n", + "import pytorch_lightning as pl\n", + "import scanpy as sc\n", + "import torch.nn.functional as F\n", + "from torch.utils.data import DataLoader, random_split\n", + "import pandas as pd\n", + "\n", + "# select the right device, depending on whether your Colab runs on GPU or CPU\n", + "### IMPORTANT: we recommend to change your runtime to GPU, otherwise the training takes much longer\n", + "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n", + "print(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + } + ], + "source": [ + "# download the data\n", + "# !wget --no-check-certificate 'https://docs.google.com/uc?export=download&id=1zHJKoU8QcQB4cLR-oICO2YY4Nu-QaZHG' -O PBMC_train.h5ad\n", + "# load data as anndata object\n", + "PBMC_train = sc.read_h5ad(\"../data/GSE194122_openproblems_neurips2021_cite_BMMC_processed.h5ad\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['GEX_n_genes_by_counts', 'GEX_pct_counts_mt', 'GEX_size_factors',\n", + " 'GEX_phase', 'ADT_n_antibodies_by_counts', 'ADT_total_counts',\n", + " 'ADT_iso_count', 'cell_type', 'batch', 'ADT_pseudotime_order',\n", + " 'GEX_pseudotime_order', 'Samplename', 'Site', 'DonorNumber', 'Modality',\n", + " 'VendorLot', 'DonorID', 'DonorAge', 'DonorBMI', 'DonorBloodType',\n", + " 'DonorRace', 'Ethnicity', 'DonorGender', 'QCMeds', 'DonorSmoker',\n", + " 'is_train'],\n", + " dtype='object')" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "PBMC_train.obs.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AnnData object with n_obs × n_vars = 90261 × 14087\n", + " obs: 'GEX_n_genes_by_counts', 'GEX_pct_counts_mt', 'GEX_size_factors', 'GEX_phase', 'ADT_n_antibodies_by_counts', 'ADT_total_counts', 'ADT_iso_count', 'cell_type', 'batch', 'ADT_pseudotime_order', 'GEX_pseudotime_order', 'Samplename', 'Site', 'DonorNumber', 'Modality', 'VendorLot', 'DonorID', 'DonorAge', 'DonorBMI', 'DonorBloodType', 'DonorRace', 'Ethnicity', 'DonorGender', 'QCMeds', 'DonorSmoker', 'is_train'\n", + " var: 'feature_types', 'gene_id'\n", + " uns: 'dataset_id', 'genome', 'organism'\n", + " obsm: 'ADT_X_pca', 'ADT_X_umap', 'ADT_isotype_controls', 'GEX_X_pca', 'GEX_X_umap'\n", + " layers: 'counts'\n", + "Counter({'CD14+ Mono': 21693, 'CD4+ T activated': 6966, 'CD4+ T naive': 5897, 'NK': 5434, 'Reticulocyte': 4272, 'Erythroblast': 4039, 'Naive CD20+ B IGKC+': 3990, 'CD8+ T naive': 3107, 'CD16+ Mono': 2635, 'NK CD158e1+': 2167, 'Naive CD20+ B IGKC-': 1979, 'G/M prog': 1881, 'pDC': 1758, 'HSC': 1703, 'cDC2': 1702, 'Lymph prog': 1681, 'Transitional B': 1575, 'Proerythroblast': 1512, 'CD8+ T CD57+ CD45RO+': 1470, 'Normoblast': 1435, 'CD8+ T CD57+ CD45RA+': 1303, 'CD8+ T TIGIT+ CD45RO+': 1160, 'CD4+ T activated integrinB7+': 1056, 'CD8+ T TIGIT+ CD45RA+': 1032, 'CD8+ T CD49f+': 912, 'CD8+ T CD69+ CD45RO+': 897, 'B1 B IGKC+': 820, 'MAIT': 756, 'CD8+ T CD69+ CD45RA+': 740, 'MK/E prog': 690, 'gdT CD158b+': 674, 'B1 B IGKC-': 613, 'T reg': 609, 'ILC1': 552, 'Plasma cell IGKC+': 288, 'Plasma cell IGKC-': 239, 'ILC': 238, 'Plasmablast IGKC+': 232, 'gdT TCRVD2+': 191, 'Plasmablast IGKC-': 130, 'CD4+ T CD314+ CD45RA+': 93, 'dnT': 56, 'CD8+ T naive CD127+ CD26- CD101-': 42, 'T prog cycling': 24, 'cDC1': 18})\n" + ] + } + ], + "source": [ + "print(PBMC_train) #the data is stored as an anndata object\n", + "print(Counter(PBMC_train.obs[\"cell_type\"])) #summary of cell types" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "class Exp(nn.Module):\n", + " \"\"\"Applies torch.exp, clamped to improve stability during training\"\"\"\n", + "\n", + " def __init__(self, minimum=1e-5, maximum=1e6):\n", + " \"\"\"Values taken from DCA\"\"\"\n", + " super(Exp, self).__init__()\n", + " self.min_value = minimum\n", + " self.max_value = maximum\n", + "\n", + " def forward(self, input):\n", + " return torch.clamp(\n", + " torch.exp(input),\n", + " min=self.min_value,\n", + " max=self.max_value,\n", + " )\n", + "\n", + "\n", + "class ClippedSoftplus(nn.Module):\n", + " def __init__(self, beta=1, threshold=20, minimum=1e-4, maximum=1e3):\n", + " super(ClippedSoftplus, self).__init__()\n", + " self.beta = beta\n", + " self.threshold = threshold\n", + " self.min_value = minimum\n", + " self.max_value = maximum\n", + "\n", + " def forward(self, input):\n", + " return torch.clamp(\n", + " F.softplus(input, self.beta, self.threshold),\n", + " min=self.min_value,\n", + " max=self.max_value,\n", + " )\n", + "\n", + " def extra_repr(self):\n", + " return \"beta={}, threshold={}, min={}, max={}\".format(\n", + " self.beta,\n", + " self.threshold,\n", + " self.min_value,\n", + " self.max_value,\n", + " )\n", + "\n", + "\n", + "\n", + "def negative_binom_loss(preds, theta, truth, scale_factor: float = 1.0, eps: float = 1e-10, mean: bool = True, debug=True):\n", + " \"\"\"Calculates negative binomial loss as defined in the NB class in link above\"\"\"\n", + " y_true = truth\n", + " y_pred = preds * scale_factor\n", + "\n", + " if debug: # Sanity check before loss calculation\n", + " assert not torch.isnan(y_pred).any(), y_pred\n", + " assert not torch.isinf(y_pred).any(), y_pred\n", + " assert not (y_pred < 0).any() # should be non-negative\n", + " assert not (theta < 0).any()\n", + "\n", + " # Clip theta values\n", + " theta = torch.clamp(theta, max=1e6)\n", + "\n", + " t1 = (\n", + " torch.lgamma(theta + eps)\n", + " + torch.lgamma(y_true + 1.0)\n", + " - torch.lgamma(y_true + theta + eps)\n", + " )\n", + " t2 = (theta + y_true) * torch.log1p(y_pred / (theta + eps)) + (\n", + " y_true * (torch.log(theta + eps) - torch.log(y_pred + eps))\n", + " )\n", + " if debug: # Sanity check after calculating loss\n", + " assert not torch.isnan(t1).any(), t1\n", + " assert not torch.isinf(t1).any(), (t1, torch.sum(torch.isinf(t1)))\n", + " assert not torch.isnan(t2).any(), t2\n", + " assert not torch.isinf(t2).any(), t2\n", + "\n", + " retval = t1 + t2\n", + " if debug:\n", + " assert not torch.isnan(retval).any(), retval\n", + " assert not torch.isinf(retval).any(), retval\n", + "\n", + " return torch.mean(retval) if mean else retval" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "class Encoder(nn.Module):\n", + " def __init__(self, latent_dims, hidden_dims, input_dims, dropout, z_dropout): #dropout, z_dropout define the dropout rates of the encoder/latent space\n", + " super(Encoder, self).__init__()\n", + " self.encoder = nn.Sequential(nn.Linear(input_dims, hidden_dims),\n", + " nn.ReLU(),\n", + " nn.Dropout(p = dropout),\n", + " nn.Linear(hidden_dims, hidden_dims),\n", + " nn.ReLU(),\n", + " nn.Dropout(p = dropout),\n", + " nn.Linear(hidden_dims, hidden_dims),\n", + " nn.ReLU(),\n", + " nn.Dropout(p = dropout),\n", + " ) #two layer, fully connected encoder with dropout\n", + "\n", + "\n", + " self.mu = nn.Sequential(nn.Linear(hidden_dims, latent_dims),\n", + " nn.Dropout(p = z_dropout))\n", + "\n", + " self.sigma = nn.Sequential(nn.Linear(hidden_dims, latent_dims),\n", + " nn.Dropout(p = z_dropout))\n", + "\n", + " self.N = torch.distributions.Normal(0, 1)\n", + " self.N.loc = self.N.loc.to(device)\n", + " self.N.scale = self.N.scale.to(device)\n", + " self.kl = 0\n", + "\n", + " def forward(self, x):\n", + " x = self.encoder(x)\n", + " mu = self.mu(x)\n", + " sigma = torch.exp(self.mu(x)) # exp for numeric stability\n", + " z = mu + sigma*self.N.sample(mu.shape)\n", + " self.kl = (0.5*sigma**2 + 0.5*mu**2 - torch.log(sigma) - 1/2).sum() #calculation of kullback-leibler divergence\n", + "\n", + " return z\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "class Decoder(nn.Module):\n", + " def __init__(self, latent_dims, hidden_dims, input_dims, dropout):\n", + " super(Decoder, self).__init__()\n", + " self.decoder = nn.Sequential(nn.Linear(latent_dims, hidden_dims),\n", + " nn.ReLU(),\n", + " nn.Dropout(p = dropout),\n", + " nn.Linear(hidden_dims, hidden_dims),\n", + " nn.ReLU(),\n", + " nn.Dropout(p = dropout),\n", + " nn.Linear(hidden_dims, input_dims),\n", + " \n", + " )\n", + "\n", + " def forward(self, z):\n", + " decoded = self.decoder(z)\n", + " return decoded" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# class VariationalAutoencoder(nn.Module):\n", + "# def __init__(self, latent_dims, input_dims, hidden_dims, dropout = 0.3, z_dropout=0.3):\n", + "# super(VariationalAutoencoder, self).__init__()\n", + "# self.encoder = Encoder(latent_dims, hidden_dims, input_dims, dropout, z_dropout)\n", + "# self.decoder = Decoder(latent_dims, hidden_dims, input_dims, dropout)\n", + "\n", + "# def forward(self, x):\n", + "# z = self.encoder(x)\n", + "# return self.decoder(z)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Variational Autoencoder definition\n", + "class VariationalAutoencoder(pl.LightningModule):\n", + " def __init__(self, latent_dims, hidden_dims, input_dims, dropout=0.3, z_dropout=0.3, learning_rate=1e-3, beta = 0.001):\n", + " super(VariationalAutoencoder, self).__init__()\n", + " self.save_hyperparameters()\n", + " self.encoder = Encoder(latent_dims, hidden_dims, input_dims, dropout, z_dropout)\n", + " self.decoder = Decoder(latent_dims, hidden_dims, input_dims, dropout)\n", + " self.learning_rate = learning_rate\n", + " self.beta = beta\n", + "\n", + " def forward(self, x):\n", + " z = self.encoder(x)\n", + " return self.decoder(z)\n", + "\n", + " def training_step(self, batch, batch_idx):\n", + " x = batch\n", + " x = x.view(x.size(0), -1)\n", + " x_reconstructed = self(x)\n", + " kld = self.beta * self.encoder.kl\n", + " recon_loss = F.mse_loss(x_reconstructed, x, reduction='mean')\n", + " loss = recon_loss + kld\n", + " self.log('train_loss', loss, on_step=True, on_epoch=True, prog_bar=True, logger=True)\n", + " self.log('train_recon_loss', recon_loss, on_step=True, on_epoch=True, prog_bar=True, logger=True)\n", + " self.log('train_kld', kld, on_step=True, on_epoch=True, prog_bar=True, logger=True)\n", + " return loss\n", + "\n", + " def validation_step(self, batch, batch_idx):\n", + " x = batch\n", + " x = x.view(x.size(0), -1)\n", + " x_reconstructed = self(x)\n", + " kld = self.beta * self.encoder.kl\n", + " recon_loss = F.mse_loss(x_reconstructed, x, reduction='mean')\n", + " loss = recon_loss + kld\n", + " self.log('val_loss', loss, on_step=True, on_epoch=True, prog_bar=True, logger=True)\n", + " self.log('val_recon_loss', recon_loss, on_step=True, on_epoch=True, prog_bar=True, logger=True)\n", + " self.log('val_kld', kld, on_step=True, on_epoch=True, prog_bar=True, logger=True)\n", + "\n", + " def test_step(self, batch, batch_idx):\n", + " x = batch\n", + " x = x.view(x.size(0), -1)\n", + " x_reconstructed = self(x)\n", + " kld = self.beta * self.encoder.kl\n", + " recon_loss = F.mse_loss(x_reconstructed, x, reduction='mean')\n", + " loss = recon_loss + kld\n", + " self.log('test_loss', loss, on_step=True, on_epoch=True, prog_bar=True, logger=True)\n", + " self.log('test_recon_loss', recon_loss, on_step=True, on_epoch=True, prog_bar=True, logger=True)\n", + " self.log('test_kld', kld, on_step=True, on_epoch=True, prog_bar=True, logger=True)\n", + "\n", + " def configure_optimizers(self):\n", + " optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)\n", + " return optimizer" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "AL627309.5 GEX\n", + "LINC01409 GEX\n", + "LINC01128 GEX\n", + "LINC00115 GEX\n", + "FAM41C GEX\n", + " ... \n", + "HLA-E ADT\n", + "CD82 ADT\n", + "CD101 ADT\n", + "CD88 ADT\n", + "CD224 ADT\n", + "Name: feature_types, Length: 14087, dtype: category\n", + "Categories (2, object): ['ADT', 'GEX']" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "PBMC_train.var[\"feature_types\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\preprocessing\\_normalization.py:170: UserWarning: Received a view of an AnnData. Making a copy.\n", + " view_to_actual(adata)\n" + ] + }, + { + "ename": "MemoryError", + "evalue": "Unable to allocate 38.7 MiB for an array with shape (10141612,) and data type int32", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mMemoryError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[33], line 6\u001b[0m\n\u001b[0;32m 2\u001b[0m GEX_mask \u001b[38;5;241m=\u001b[39m PBMC_train\u001b[38;5;241m.\u001b[39mvar[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfeature_types\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mGEX\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 4\u001b[0m ADT_anndata \u001b[38;5;241m=\u001b[39m PBMC_train[:, ADT_mask]\n\u001b[1;32m----> 6\u001b[0m \u001b[43msc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnormalize_total\u001b[49m\u001b[43m(\u001b[49m\u001b[43mADT_anndata\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 7\u001b[0m \u001b[38;5;66;03m# ADT_data = PBMC_train.X[:, ADT_mask]\u001b[39;00m\n\u001b[0;32m 8\u001b[0m \u001b[38;5;66;03m# GEX_data = PBMC_train.X[:, GEX_mask]\u001b[39;00m\n", + "File \u001b[1;32mc:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\preprocessing\\_normalization.py:170\u001b[0m, in \u001b[0;36mnormalize_total\u001b[1;34m(adata, target_sum, exclude_highly_expressed, max_fraction, key_added, layer, layers, layer_norm, inplace, copy)\u001b[0m\n\u001b[0;32m 165\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(layers, \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m 166\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[0;32m 167\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m`layers` needs to be a list of strings or \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mall\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m, not \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mlayers\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 168\u001b[0m )\n\u001b[1;32m--> 170\u001b[0m \u001b[43mview_to_actual\u001b[49m\u001b[43m(\u001b[49m\u001b[43madata\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 172\u001b[0m X \u001b[38;5;241m=\u001b[39m _get_obs_rep(adata, layer\u001b[38;5;241m=\u001b[39mlayer)\n\u001b[0;32m 174\u001b[0m gene_subset \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[1;32mc:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\_utils\\__init__.py:415\u001b[0m, in \u001b[0;36mview_to_actual\u001b[1;34m(adata)\u001b[0m\n\u001b[0;32m 410\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m adata\u001b[38;5;241m.\u001b[39mis_view:\n\u001b[0;32m 411\u001b[0m warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[0;32m 412\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mReceived a view of an AnnData. Making a copy.\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m 413\u001b[0m stacklevel\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m,\n\u001b[0;32m 414\u001b[0m )\n\u001b[1;32m--> 415\u001b[0m adata\u001b[38;5;241m.\u001b[39m_init_as_actual(\u001b[43madata\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m)\n", + "File \u001b[1;32mc:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\anndata\\_core\\anndata.py:1503\u001b[0m, in \u001b[0;36mAnnData.copy\u001b[1;34m(self, filename)\u001b[0m\n\u001b[0;32m 1497\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39misbacked:\n\u001b[0;32m 1498\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mis_view \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_has_X():\n\u001b[0;32m 1499\u001b[0m \u001b[38;5;66;03m# TODO: How do I unambiguously check if this is a copy?\u001b[39;00m\n\u001b[0;32m 1500\u001b[0m \u001b[38;5;66;03m# Subsetting this way means we don’t have to have a view type\u001b[39;00m\n\u001b[0;32m 1501\u001b[0m \u001b[38;5;66;03m# defined for the matrix, which is needed for some of the\u001b[39;00m\n\u001b[0;32m 1502\u001b[0m \u001b[38;5;66;03m# current distributed backend. Specifically Dask.\u001b[39;00m\n\u001b[1;32m-> 1503\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_mutated_copy\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 1504\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m_subset\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_adata_ref\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_oidx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_vidx\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1505\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1506\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 1507\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_mutated_copy()\n", + "File \u001b[1;32mc:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\anndata\\_core\\anndata.py:1435\u001b[0m, in \u001b[0;36mAnnData._mutated_copy\u001b[1;34m(self, **kwargs)\u001b[0m\n\u001b[0;32m 1433\u001b[0m new[key] \u001b[38;5;241m=\u001b[39m kwargs[key]\n\u001b[0;32m 1434\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1435\u001b[0m new[key] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mgetattr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1436\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mX\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m kwargs:\n\u001b[0;32m 1437\u001b[0m new[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mX\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mX\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n", + "File \u001b[1;32mc:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\anndata\\_core\\aligned_mapping.py:322\u001b[0m, in \u001b[0;36mLayersBase.copy\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 320\u001b[0m d \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_actual_class(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparent)\n\u001b[0;32m 321\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mitems():\n\u001b[1;32m--> 322\u001b[0m d[k] \u001b[38;5;241m=\u001b[39m \u001b[43mv\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 323\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m d\n", + "File \u001b[1;32mc:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\anndata\\_core\\views.py:210\u001b[0m, in \u001b[0;36mSparseCSRView.copy\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 209\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcopy\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m sparse\u001b[38;5;241m.\u001b[39mcsr_matrix:\n\u001b[1;32m--> 210\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43msparse\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcsr_matrix\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32mc:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scipy\\sparse\\_data.py:94\u001b[0m, in \u001b[0;36m_data_matrix.copy\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 93\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcopy\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m---> 94\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_with_data\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcopy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32mc:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scipy\\sparse\\_compressed.py:1229\u001b[0m, in \u001b[0;36m_cs_matrix._with_data\u001b[1;34m(self, data, copy)\u001b[0m\n\u001b[0;32m 1224\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Returns a matrix with the same sparsity structure as self,\u001b[39;00m\n\u001b[0;32m 1225\u001b[0m \u001b[38;5;124;03mbut with different data. By default the structure arrays\u001b[39;00m\n\u001b[0;32m 1226\u001b[0m \u001b[38;5;124;03m(i.e. .indptr and .indices) are copied.\u001b[39;00m\n\u001b[0;32m 1227\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 1228\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copy:\n\u001b[1;32m-> 1229\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m((data, \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindices\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m,\n\u001b[0;32m 1230\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindptr\u001b[38;5;241m.\u001b[39mcopy()),\n\u001b[0;32m 1231\u001b[0m shape\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mshape,\n\u001b[0;32m 1232\u001b[0m dtype\u001b[38;5;241m=\u001b[39mdata\u001b[38;5;241m.\u001b[39mdtype)\n\u001b[0;32m 1233\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 1234\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m((data, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindices, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindptr),\n\u001b[0;32m 1235\u001b[0m shape\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mshape, dtype\u001b[38;5;241m=\u001b[39mdata\u001b[38;5;241m.\u001b[39mdtype)\n", + "\u001b[1;31mMemoryError\u001b[0m: Unable to allocate 38.7 MiB for an array with shape (10141612,) and data type int32" + ] + } + ], + "source": [ + "ADT_mask = PBMC_train.var[\"feature_types\"] == \"ADT\"\n", + "GEX_mask = PBMC_train.var[\"feature_types\"] == \"GEX\"\n", + "\n", + "ADT_anndata = PBMC_train[:, ADT_mask]\n", + "\n", + "sc.pp.normalize_total(ADT_anndata)\n", + "# ADT_data = PBMC_train.X[:, ADT_mask]\n", + "# GEX_data = PBMC_train.X[:, GEX_mask]" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "sc.tl.pca(ADT_anndata, svd_solver='arpack')" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:1217: FutureWarning: The default value of 'ignore' for the `na_action` parameter in pandas.Categorical.map is deprecated and will be changed to 'None' in a future version. Please set na_action to the desired value to avoid seeing this warning\n", + " color_vector = pd.Categorical(values.map(color_map))\n", + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:392: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n", + " cax = scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pl.pca(ADT_anndata, color='level1')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.hist(ADT_anndata.X.A[:, 100])" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "def normalize_data(data):\n", + " data = np.log1p(data)\n", + " \n", + " # std = np.std(data, axis=0)\n", + " # mean = np.mean(data, axis=0)\n", + " \n", + " # data = (data - mean) / std\n", + " \n", + " return data" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: False, used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------\n", + "0 | encoder | Encoder | 13.9 K\n", + "1 | decoder | Decoder | 10.4 K\n", + "------------------------------------\n", + "24.3 K Trainable params\n", + "0 Non-trainable params\n", + "24.3 K Total params\n", + "0.097 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "22fd243761e7493e9a116e6bb9efae1f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | | 0/? [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pp.neighbors(ADT_anndata, use_rep='latent_embedding', n_neighbors=15) # use_rep specifies that the calculation is based on the latent embedding\n", + "sc.tl.umap(ADT_anndata, random_state=1) #set random state to ensure reproducibility\n", + "sc.pl.umap(ADT_anndata, color=[\"cell_type\"], size=10, ncols = 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "hierarchy = {'level1': ['Hematopoietic Stem Cells and Progenitors', 'Hematopoietic Stem Cells and Progenitors', 'Hematopoietic Stem Cells and Progenitors', 'Hematopoietic Stem Cells and Progenitors', 'Monocytes and Dendritic Cells', 'Monocytes and Dendritic Cells', 'Monocytes and Dendritic Cells', 'Monocytes and Dendritic Cells', 'Monocytes and Dendritic Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'B Cells and Plasma Cells', 'B Cells and Plasma Cells', 'B Cells and Plasma Cells', 'B Cells and Plasma Cells', 'B Cells and Plasma Cells', 'B Cells and Plasma Cells', 'B Cells and Plasma Cells', 'B Cells and Plasma Cells', 'B Cells and Plasma Cells', 'Natural Killer Cells', 'Natural Killer Cells', 'Erythroid Lineage', 'Erythroid Lineage', 'Erythroid Lineage', 'Erythroid Lineage', 'Innate Lymphoid Cells (ILCs)', 'Innate Lymphoid Cells (ILCs)'], 'level2': ['HSC', 'Progenitors', 'Progenitors', 'Progenitors', 'Monocytes', 'Monocytes', 'Dendritic Cells', 'Dendritic Cells', 'Dendritic Cells', 'CD4+ T Cells', 'CD4+ T Cells', 'CD4+ T Cells', 'CD4+ T Cells', 'CD8+ T Cells', 'CD8+ T Cells', 'CD8+ T Cells', 'CD8+ T Cells', 'CD8+ T Cells', 'CD8+ T Cells', 'CD8+ T Cells', 'CD8+ T Cells', 'CD8+ T Cells', 'Special T Cell Types', 'Special T Cell Types', 'Special T Cell Types', 'Special T Cell Types', 'Special T Cell Types', 'Special T Cell Types', 'Naive B Cells', 'Naive B Cells', 'Transitional B Cells', 'B1 B Cells', 'B1 B Cells', 'Plasma Cells', 'Plasma Cells', 'Plasmablasts', 'Plasmablasts', 'NK', 'NK CD158e1+', 'Erythroblasts and Precursors', 'Erythroblasts and Precursors', 'Erythroblasts and Precursors', 'Reticulocytes', 'ILC', 'ILC1'], 'level3': ['HSC', 'Lymph prog', 'G/M prog', 'MK/E prog', 'CD14+ Mono', 'CD16+ Mono', 'cDC1', 'cDC2', 'pDC', 'CD4+ T naive', 'CD4+ T activated', 'CD4+ T activated integrinB7+', 'CD4+ T CD314+ CD45RA+', 'CD8+ T naive', 'CD8+ T CD57+ CD45RO+', 'CD8+ T CD57+ CD45RA+', 'CD8+ T TIGIT+ CD45RO+', 'CD8+ T TIGIT+ CD45RA+', 'CD8+ T CD49f+', 'CD8+ T CD69+ CD45RO+', 'CD8+ T CD69+ CD45RA+', 'CD8+ T naive CD127+ CD26- CD101-', 'MAIT', 'gdT CD158b+', 'gdT TCRVD2+', 'dnT', 'T reg', 'T prog cycling', 'Naive CD20+ B IGKC+', 'Naive CD20+ B IGKC-', 'Transitional B', 'B1 B IGKC+', 'B1 B IGKC-', 'Plasma cell IGKC+', 'Plasma cell IGKC-', 'Plasmablast IGKC+', 'Plasmablast IGKC-', 'NK', 'NK CD158e1+', 'Proerythroblast', 'Erythroblast', 'Normoblast', 'Reticulocyte', 'ILC', 'ILC1'], 'description': ['Hematopoietic Stem Cells', 'Lymphoid progenitors', 'Granulocyte-Macrophage progenitors', 'Megakaryocyte-Erythroid progenitors', 'CD14+ Monocytes', 'CD16+ Monocytes', 'Conventional Dendritic Cells, subtype 1', 'Conventional Dendritic Cells, subtype 2', 'Plasmacytoid Dendritic Cells', 'Naive CD4+ T Cells', 'Activated CD4+ T Cells', 'Activated CD4+ T Cells expressing integrin β7', 'CD4+ T Cells expressing CD314 and CD45RA', 'Naive CD8+ T Cells', 'CD8+ T Cells expressing CD57 and CD45RO', 'CD8+ T Cells expressing CD57 and CD45RA', 'CD8+ T Cells expressing TIGIT and CD45RO', 'CD8+ T Cells expressing TIGIT and CD45RA', 'CD8+ T Cells expressing CD49f', 'CD8+ T Cells expressing CD69 and CD45RO', 'CD8+ T Cells expressing CD69 and CD45RA', 'Naive CD8+ T Cells expressing CD127, not CD26 or CD101', 'Mucosal-Associated Invariant T Cells', 'Gamma Delta T Cells expressing CD158b', 'Gamma Delta T Cells expressing TCRVδ2', 'Double-Negative T Cells', 'Regulatory T Cells', 'Cycling Progenitor T Cells', 'Naive B Cells expressing CD20 and IGKC', 'Naive B Cells expressing CD20, not IGKC', 'Transitional B Cells', 'B1 B Cells expressing IGKC', 'B1 B Cells not expressing IGKC', 'Plasma Cells expressing IGKC', 'Plasma Cells not expressing IGKC', 'Plasmablasts expressing IGKC', 'Plasmablasts not expressing IGKC', 'Natural Killer Cells', 'Natural Killer Cells expressing CD158e1', 'Proerythroblast', 'Erythroblast', 'Normoblast', 'Reticulocyte', 'Innate Lymphoid Cells', 'ILC1']}\n", + "hierarchy_df = pd.DataFrame(data = hierarchy)\n", + "ADT_anndata.obs = pd.merge(ADT_anndata.obs, hierarchy_df, left_on=\"cell_type\", right_on=\"level3\", how=\"left\")" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['GEX_n_genes_by_counts', 'GEX_pct_counts_mt', 'GEX_size_factors',\n", + " 'GEX_phase', 'ADT_n_antibodies_by_counts', 'ADT_total_counts',\n", + " 'ADT_iso_count', 'cell_type', 'batch', 'ADT_pseudotime_order',\n", + " 'GEX_pseudotime_order', 'Samplename', 'Site', 'DonorNumber', 'Modality',\n", + " 'VendorLot', 'DonorID', 'DonorAge', 'DonorBMI', 'DonorBloodType',\n", + " 'DonorRace', 'Ethnicity', 'DonorGender', 'QCMeds', 'DonorSmoker',\n", + " 'is_train', 'level1_x', 'level2_x', 'level3_x', 'description_x',\n", + " 'level1_y', 'level2_y', 'level3_y', 'description_y'],\n", + " dtype='object')" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ADT_anndata.obs.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "level1\n", + "Monocytes and Dendritic Cells 27806\n", + "T Cells 26985\n", + "Erythroid Lineage 11258\n", + "B Cells and Plasma Cells 9866\n", + "Natural Killer Cells 7601\n", + "Hematopoietic Stem Cells and Progenitors 5955\n", + "Innate Lymphoid Cells (ILCs) 790\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ADT_anndata.obs[\"level1\"].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:1217: FutureWarning: The default value of 'ignore' for the `na_action` parameter in pandas.Categorical.map is deprecated and will be changed to 'None' in a future version. Please set na_action to the desired value to avoid seeing this warning\n", + " color_vector = pd.Categorical(values.map(color_map))\n", + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:392: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n", + " cax = scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pp.neighbors(ADT_anndata, use_rep='latent_embedding', n_neighbors=15) # use_rep specifies that the calculation is based on the latent embedding\n", + "sc.tl.umap(ADT_anndata, random_state=1) #set random state to ensure reproducibility\n", + "sc.pl.umap(ADT_anndata, color=[\"level1_x\"], size=10, ncols = 1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "pd" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(90261, 2)" + ] + }, + "execution_count": 115, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ADT_anndata.obsm['X_pca_latent'].shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import scanpy as sc\n", + "from sklearn.decomposition import PCA\n", + "\n", + "# Extract the latent embedding\n", + "latent_embedding = ADT_anndata.obsm['latent_embedding']\n", + "\n", + "# Perform PCA on the latent embedding\n", + "pca = PCA(n_components=2)\n", + "latent_pca = pca.fit_transform(latent_embedding)\n", + "\n", + "# Store the PCA results back in the AnnData object\n", + "ADT_anndata.obsm['X_pca_latent'] = latent_pca\n", + "ADT_anndata.uns['pca_latent_variance_ratio'] = pca.explained_variance_ratio_\n", + "\n", + "# Create a new AnnData object for visualization purposes\n", + "pca_anndata = sc.AnnData(X=latent_pca)\n", + "pca_anndata.obs = ADT_anndata.obs\n", + "pca_anndata.var_names = [f\"PC{i+1}\" for i in range(latent_pca.shape[1])]\n", + "\n", + "# Visualize the PCA results\n", + "sc.pl.scatter(pca_anndata, x=\"PC1\", y=\"PC2\", color='level1')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "import scanpy as sc\n", + "import numpy as np\n", + "import torch\n", + "import torch.nn as nn\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import LabelEncoder\n", + "from torch.utils.data import DataLoader, TensorDataset\n", + "import pytorch_lightning as pl\n", + "from pytorch_lightning.callbacks import ModelCheckpoint\n", + "\n", + "# Define the MLP model using PyTorch Lightning\n", + "class MLPClassifier(pl.LightningModule):\n", + " def __init__(self, input_dim, hidden_dim, output_dim):\n", + " super(MLPClassifier, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", + " self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n", + " self.fc3 = nn.Linear(hidden_dim, output_dim)\n", + " self.relu = nn.ReLU()\n", + " self.criterion = nn.CrossEntropyLoss()\n", + " \n", + " def forward(self, x):\n", + " x = self.fc1(x)\n", + " x = self.relu(x)\n", + " x = self.fc2(x)\n", + " x = self.relu(x)\n", + " x = self.fc3(x)\n", + " return x\n", + " \n", + " def training_step(self, batch, batch_idx):\n", + " data, target = batch\n", + " output = self(data)\n", + " loss = self.criterion(output, target)\n", + " self.log('train_loss', loss)\n", + " return loss\n", + " \n", + " def validation_step(self, batch, batch_idx):\n", + " data, target = batch\n", + " output = self(data)\n", + " loss = self.criterion(output, target)\n", + " self.log('val_loss', loss)\n", + " return loss\n", + " \n", + " def configure_optimizers(self):\n", + " return torch.optim.Adam(self.parameters(), lr=0.001)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "data = normalize_data(ADT_anndata.X.A)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data = ADT_anndata.obsm['latent_embedding']" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "# Extract the labels (cell types)\n", + "labels = ADT_anndata.obs['level1'].values\n", + "\n", + "# Encode labels to integers\n", + "label_encoder = LabelEncoder()\n", + "labels_encoded = label_encoder.fit_transform(labels)\n", + "\n", + "# Convert to PyTorch tensors\n", + "X = torch.tensor(data, dtype=torch.float32)\n", + "y = torch.tensor(labels_encoded, dtype=torch.long)\n", + "\n", + "# Split the data into training and testing sets\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", + "\n", + "# Create DataLoader for training and testing sets\n", + "train_dataset = TensorDataset(X_train, y_train)\n", + "test_dataset = TensorDataset(X_test, y_test)\n", + "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n", + "test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: False, used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\pytorch_lightning\\callbacks\\model_checkpoint.py:653: Checkpoint directory C:\\Users\\adamb\\Documents\\Projects\\D4L-Hackaton\\notebooks\\my_model exists and is not empty.\n", + "\n", + " | Name | Type | Params\n", + "-----------------------------------------------\n", + "0 | fc1 | Linear | 8.6 K \n", + "1 | fc2 | Linear | 4.2 K \n", + "2 | fc3 | Linear | 455 \n", + "3 | relu | ReLU | 0 \n", + "4 | criterion | CrossEntropyLoss | 0 \n", + "-----------------------------------------------\n", + "13.3 K Trainable params\n", + "0 Non-trainable params\n", + "13.3 K Total params\n", + "0.053 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3b64844efe884cc299e27f026e2ec66e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | | 0/? [00:00 1\u001b[0m GEX_anndata\u001b[38;5;241m.\u001b[39mobsm[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlatent_embedding\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[43mto_latent\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mGEX_anndata\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[1;32mIn[20], line 3\u001b[0m, in \u001b[0;36mto_latent\u001b[1;34m(vae, adata)\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mto_latent\u001b[39m(vae, adata):\n\u001b[0;32m 2\u001b[0m latent \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m----> 3\u001b[0m data \u001b[38;5;241m=\u001b[39m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43madata\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mX\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mA\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mto(device)\n\u001b[0;32m 4\u001b[0m vae\u001b[38;5;241m.\u001b[39meval() \u001b[38;5;66;03m# we need to set the model to evaluation mode, so that the dropout is no longer considered\u001b[39;00m\n\u001b[0;32m 5\u001b[0m z \u001b[38;5;241m=\u001b[39m vae\u001b[38;5;241m.\u001b[39mencoder(data)\n", + "\u001b[1;31mRuntimeError\u001b[0m: [enforce fail at alloc_cpu.cpp:80] data. DefaultCPUAllocator: not enough memory: you tried to allocate 5037646932 bytes." + ] + } + ], + "source": [ + "GEX_anndata.obsm[\"latent_embedding\"] = to_latent(model, GEX_anndata)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/old_code/old_notebooks/analyse_pbmc5k.ipynb b/old_code/old_notebooks/analyse_pbmc5k.ipynb new file mode 100644 index 0000000..2122563 --- /dev/null +++ b/old_code/old_notebooks/analyse_pbmc5k.ipynb @@ -0,0 +1,1507 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Analyzing CITE-seq data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Author:** Isaac Virshup" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting scanpy\n", + " Using cached scanpy-1.10.1-py3-none-any.whl.metadata (8.6 kB)\n", + "Collecting anndata>=0.8 (from scanpy)\n", + " Using cached anndata-0.10.7-py3-none-any.whl.metadata (6.6 kB)\n", + "Collecting h5py>=3.1 (from scanpy)\n", + " Downloading h5py-3.11.0-cp312-cp312-win_amd64.whl.metadata (2.5 kB)\n", + "Collecting joblib (from scanpy)\n", + " Using cached joblib-1.4.2-py3-none-any.whl.metadata (5.4 kB)\n", + "Collecting legacy-api-wrap>=1.4 (from scanpy)\n", + " Using cached legacy_api_wrap-1.4-py3-none-any.whl.metadata (1.8 kB)\n", + "Collecting matplotlib>=3.6 (from scanpy)\n", + " Using cached matplotlib-3.9.0-cp312-cp312-win_amd64.whl.metadata (11 kB)\n", + "Collecting natsort (from scanpy)\n", + " Using cached natsort-8.4.0-py3-none-any.whl.metadata (21 kB)\n", + "Collecting networkx>=2.7 (from scanpy)\n", + " Using cached networkx-3.3-py3-none-any.whl.metadata (5.1 kB)\n", + "Collecting numba>=0.56 (from scanpy)\n", + " Downloading numba-0.59.1-cp312-cp312-win_amd64.whl.metadata (2.8 kB)\n", + "Collecting numpy>=1.23 (from scanpy)\n", + " Using cached numpy-1.26.4-cp312-cp312-win_amd64.whl.metadata (61 kB)\n", + "Requirement already satisfied: packaging>=21.3 in d:\\dlls-hack\\.venv\\lib\\site-packages (from scanpy) (24.0)\n", + "Collecting pandas>=1.5 (from scanpy)\n", + " Using cached pandas-2.2.2-cp312-cp312-win_amd64.whl.metadata (19 kB)\n", + "Collecting patsy (from scanpy)\n", + " Using cached patsy-0.5.6-py2.py3-none-any.whl.metadata (3.5 kB)\n", + "Collecting pynndescent>=0.5 (from scanpy)\n", + " Using cached pynndescent-0.5.12-py3-none-any.whl.metadata (6.8 kB)\n", + "Collecting scikit-learn>=0.24 (from scanpy)\n", + " Downloading scikit_learn-1.5.0-cp312-cp312-win_amd64.whl.metadata (11 kB)\n", + "Collecting scipy>=1.8 (from scanpy)\n", + " Downloading scipy-1.13.1-cp312-cp312-win_amd64.whl.metadata (60 kB)\n", + " ---------------------------------------- 0.0/60.6 kB ? eta -:--:--\n", + " -------------------- ------------------- 30.7/60.6 kB 1.3 MB/s eta 0:00:01\n", + " -------------------------------------- 60.6/60.6 kB 799.0 kB/s eta 0:00:00\n", + "Collecting seaborn>=0.13 (from scanpy)\n", + " Using cached seaborn-0.13.2-py3-none-any.whl.metadata (5.4 kB)\n", + "Collecting session-info (from scanpy)\n", + " Using cached session_info-1.0.0.tar.gz (24 kB)\n", + " Installing build dependencies: started\n", + " Installing build dependencies: finished with status 'done'\n", + " Getting requirements to build wheel: started\n", + " Getting requirements to build wheel: finished with status 'done'\n", + " Installing backend dependencies: started\n", + " Installing backend dependencies: finished with status 'done'\n", + " Preparing metadata (pyproject.toml): started\n", + " Preparing metadata (pyproject.toml): finished with status 'done'\n", + "Collecting statsmodels>=0.13 (from scanpy)\n", + " Downloading statsmodels-0.14.2-cp312-cp312-win_amd64.whl.metadata (9.5 kB)\n", + "Collecting tqdm (from scanpy)\n", + " Using cached tqdm-4.66.4-py3-none-any.whl.metadata (57 kB)\n", + "Collecting umap-learn!=0.5.0,>=0.5 (from scanpy)\n", + " Using cached umap_learn-0.5.6-py3-none-any.whl.metadata (21 kB)\n", + "Collecting array-api-compat!=1.5,>1.4 (from anndata>=0.8->scanpy)\n", + " Using cached array_api_compat-1.6-py3-none-any.whl.metadata (1.4 kB)\n", + "Collecting contourpy>=1.0.1 (from matplotlib>=3.6->scanpy)\n", + " Using cached contourpy-1.2.1-cp312-cp312-win_amd64.whl.metadata (5.8 kB)\n", + "Collecting cycler>=0.10 (from matplotlib>=3.6->scanpy)\n", + " Using cached cycler-0.12.1-py3-none-any.whl.metadata (3.8 kB)\n", + "Collecting fonttools>=4.22.0 (from matplotlib>=3.6->scanpy)\n", + " Using cached fonttools-4.51.0-cp312-cp312-win_amd64.whl.metadata (162 kB)\n", + "Collecting kiwisolver>=1.3.1 (from matplotlib>=3.6->scanpy)\n", + " Using cached kiwisolver-1.4.5-cp312-cp312-win_amd64.whl.metadata (6.5 kB)\n", + "Collecting pillow>=8 (from matplotlib>=3.6->scanpy)\n", + " Using cached pillow-10.3.0-cp312-cp312-win_amd64.whl.metadata (9.4 kB)\n", + "Collecting pyparsing>=2.3.1 (from matplotlib>=3.6->scanpy)\n", + " Using cached pyparsing-3.1.2-py3-none-any.whl.metadata (5.1 kB)\n", + "Requirement already satisfied: python-dateutil>=2.7 in d:\\dlls-hack\\.venv\\lib\\site-packages (from matplotlib>=3.6->scanpy) (2.9.0.post0)\n", + "Collecting llvmlite<0.43,>=0.42.0dev0 (from numba>=0.56->scanpy)\n", + " Downloading llvmlite-0.42.0-cp312-cp312-win_amd64.whl.metadata (4.9 kB)\n", + "Collecting pytz>=2020.1 (from pandas>=1.5->scanpy)\n", + " Using cached pytz-2024.1-py2.py3-none-any.whl.metadata (22 kB)\n", + "Collecting tzdata>=2022.7 (from pandas>=1.5->scanpy)\n", + " Using cached tzdata-2024.1-py2.py3-none-any.whl.metadata (1.4 kB)\n", + "Collecting threadpoolctl>=3.1.0 (from scikit-learn>=0.24->scanpy)\n", + " Using cached threadpoolctl-3.5.0-py3-none-any.whl.metadata (13 kB)\n", + "Requirement already satisfied: six in d:\\dlls-hack\\.venv\\lib\\site-packages (from patsy->scanpy) (1.16.0)\n", + "Collecting stdlib-list (from session-info->scanpy)\n", + " Using cached stdlib_list-0.10.0-py3-none-any.whl.metadata (3.3 kB)\n", + "Requirement already satisfied: colorama in d:\\dlls-hack\\.venv\\lib\\site-packages (from tqdm->scanpy) (0.4.6)\n", + "Using cached scanpy-1.10.1-py3-none-any.whl (2.1 MB)\n", + "Using cached anndata-0.10.7-py3-none-any.whl (122 kB)\n", + "Downloading h5py-3.11.0-cp312-cp312-win_amd64.whl (3.0 MB)\n", + " ---------------------------------------- 0.0/3.0 MB ? eta -:--:--\n", + " -- ------------------------------------- 0.2/3.0 MB 4.6 MB/s eta 0:00:01\n", + " ---- ----------------------------------- 0.3/3.0 MB 3.9 MB/s eta 0:00:01\n", + " ------- -------------------------------- 0.6/3.0 MB 5.3 MB/s eta 0:00:01\n", + " ------------------- -------------------- 1.4/3.0 MB 9.1 MB/s eta 0:00:01\n", + " --------------------------------- ------ 2.5/3.0 MB 12.3 MB/s eta 0:00:01\n", + " --------------------------------------- 3.0/3.0 MB 13.6 MB/s eta 0:00:01\n", + " ---------------------------------------- 3.0/3.0 MB 11.8 MB/s eta 0:00:00\n", + "Using cached legacy_api_wrap-1.4-py3-none-any.whl (15 kB)\n", + "Using cached matplotlib-3.9.0-cp312-cp312-win_amd64.whl (8.0 MB)\n", + "Using cached networkx-3.3-py3-none-any.whl (1.7 MB)\n", + "Downloading numba-0.59.1-cp312-cp312-win_amd64.whl (2.7 MB)\n", + " ---------------------------------------- 0.0/2.7 MB ? eta -:--:--\n", + " --------------------------- ------------ 1.9/2.7 MB 57.9 MB/s eta 0:00:01\n", + " ---------------------------------------- 2.7/2.7 MB 34.1 MB/s eta 0:00:00\n", + "Using cached numpy-1.26.4-cp312-cp312-win_amd64.whl (15.5 MB)\n", + "Using cached pandas-2.2.2-cp312-cp312-win_amd64.whl (11.5 MB)\n", + "Using cached pynndescent-0.5.12-py3-none-any.whl (56 kB)\n", + "Using cached joblib-1.4.2-py3-none-any.whl (301 kB)\n", + "Downloading scikit_learn-1.5.0-cp312-cp312-win_amd64.whl (10.9 MB)\n", + " ---------------------------------------- 0.0/10.9 MB ? eta -:--:--\n", + " ------ --------------------------------- 1.8/10.9 MB 38.6 MB/s eta 0:00:01\n", + " ------------- -------------------------- 3.6/10.9 MB 38.7 MB/s eta 0:00:01\n", + " --------------- ------------------------ 4.1/10.9 MB 29.3 MB/s eta 0:00:01\n", + " --------------------- ------------------ 5.9/10.9 MB 31.3 MB/s eta 0:00:01\n", + " --------------------------- ------------ 7.5/10.9 MB 34.1 MB/s eta 0:00:01\n", + " ----------------------------- ---------- 8.0/10.9 MB 30.2 MB/s eta 0:00:01\n", + " ----------------------------------- ---- 9.6/10.9 MB 30.7 MB/s eta 0:00:01\n", + " --------------------------------------- 10.9/10.9 MB 31.2 MB/s eta 0:00:01\n", + " --------------------------------------- 10.9/10.9 MB 31.2 MB/s eta 0:00:01\n", + " ---------------------------------------- 10.9/10.9 MB 26.2 MB/s eta 0:00:00\n", + "Downloading scipy-1.13.1-cp312-cp312-win_amd64.whl (45.9 MB)\n", + " ---------------------------------------- 0.0/45.9 MB ? eta -:--:--\n", + " - -------------------------------------- 1.9/45.9 MB 39.4 MB/s eta 0:00:02\n", + " --- ------------------------------------ 3.5/45.9 MB 44.1 MB/s eta 0:00:01\n", + " ---- ----------------------------------- 5.4/45.9 MB 43.2 MB/s eta 0:00:01\n", + " ------ --------------------------------- 7.0/45.9 MB 40.4 MB/s eta 0:00:01\n", + " ------- -------------------------------- 8.6/45.9 MB 42.3 MB/s eta 0:00:01\n", + " -------- ------------------------------- 10.2/45.9 MB 40.6 MB/s eta 0:00:01\n", + " ---------- ----------------------------- 11.9/45.9 MB 38.5 MB/s eta 0:00:01\n", + " ----------- ---------------------------- 13.3/45.9 MB 40.9 MB/s eta 0:00:01\n", + " ------------ --------------------------- 14.8/45.9 MB 38.5 MB/s eta 0:00:01\n", + " ------------- -------------------------- 15.6/45.9 MB 34.4 MB/s eta 0:00:01\n", + " --------------- ------------------------ 17.4/45.9 MB 36.4 MB/s eta 0:00:01\n", + " ---------------- ----------------------- 19.2/45.9 MB 36.3 MB/s eta 0:00:01\n", + " ------------------ --------------------- 20.8/45.9 MB 36.3 MB/s eta 0:00:01\n", + " ------------------- -------------------- 22.6/45.9 MB 36.4 MB/s eta 0:00:01\n", + " --------------------- ------------------ 24.1/45.9 MB 36.3 MB/s eta 0:00:01\n", + " --------------------- ------------------ 24.8/45.9 MB 40.9 MB/s eta 0:00:01\n", + " ---------------------- ----------------- 26.3/45.9 MB 36.4 MB/s eta 0:00:01\n", + " ------------------------ --------------- 27.8/45.9 MB 36.3 MB/s eta 0:00:01\n", + " ------------------------- -------------- 29.3/45.9 MB 36.4 MB/s eta 0:00:01\n", + " -------------------------- ------------- 30.4/45.9 MB 38.5 MB/s eta 0:00:01\n", + " --------------------------- ------------ 31.5/45.9 MB 32.7 MB/s eta 0:00:01\n", + " ---------------------------- ----------- 33.1/45.9 MB 32.7 MB/s eta 0:00:01\n", + " ------------------------------ --------- 34.7/45.9 MB 31.2 MB/s eta 0:00:01\n", + " ------------------------------- -------- 35.7/45.9 MB 36.4 MB/s eta 0:00:01\n", + " ------------------------------- -------- 35.7/45.9 MB 36.4 MB/s eta 0:00:01\n", + " --------------------------------- ------ 38.2/45.9 MB 31.2 MB/s eta 0:00:01\n", + " --------------------------------- ------ 38.2/45.9 MB 31.2 MB/s eta 0:00:01\n", + " --------------------------------- ------ 38.2/45.9 MB 31.2 MB/s eta 0:00:01\n", + " ------------------------------------ --- 42.2/45.9 MB 31.2 MB/s eta 0:00:01\n", + " ------------------------------------- -- 43.6/45.9 MB 31.2 MB/s eta 0:00:01\n", + " --------------------------------------- 45.4/45.9 MB 29.7 MB/s eta 0:00:01\n", + " --------------------------------------- 45.9/45.9 MB 31.1 MB/s eta 0:00:01\n", + " --------------------------------------- 45.9/45.9 MB 31.1 MB/s eta 0:00:01\n", + " --------------------------------------- 45.9/45.9 MB 31.1 MB/s eta 0:00:01\n", + " --------------------------------------- 45.9/45.9 MB 31.1 MB/s eta 0:00:01\n", + " --------------------------------------- 45.9/45.9 MB 31.1 MB/s eta 0:00:01\n", + " --------------------------------------- 45.9/45.9 MB 31.1 MB/s eta 0:00:01\n", + " --------------------------------------- 45.9/45.9 MB 31.1 MB/s eta 0:00:01\n", + " --------------------------------------- 45.9/45.9 MB 31.1 MB/s eta 0:00:01\n", + " --------------------------------------- 45.9/45.9 MB 31.1 MB/s eta 0:00:01\n", + " ---------------------------------------- 45.9/45.9 MB 15.6 MB/s eta 0:00:00\n", + "Using cached seaborn-0.13.2-py3-none-any.whl (294 kB)\n", + "Downloading statsmodels-0.14.2-cp312-cp312-win_amd64.whl (9.8 MB)\n", + " ---------------------------------------- 0.0/9.8 MB ? eta -:--:--\n", + " ----- ---------------------------------- 1.4/9.8 MB 45.9 MB/s eta 0:00:01\n", + " ------------- -------------------------- 3.2/9.8 MB 41.1 MB/s eta 0:00:01\n", + " ----------------- ---------------------- 4.4/9.8 MB 40.3 MB/s eta 0:00:01\n", + " ------------------------- -------------- 6.2/9.8 MB 39.8 MB/s eta 0:00:01\n", + " ------------------------------- -------- 7.6/9.8 MB 40.9 MB/s eta 0:00:01\n", + " ------------------------------------- -- 9.2/9.8 MB 39.2 MB/s eta 0:00:01\n", + " --------------------------------------- 9.8/9.8 MB 39.2 MB/s eta 0:00:01\n", + " --------------------------------------- 9.8/9.8 MB 39.2 MB/s eta 0:00:01\n", + " ---------------------------------------- 9.8/9.8 MB 27.3 MB/s eta 0:00:00\n", + "Using cached patsy-0.5.6-py2.py3-none-any.whl (233 kB)\n", + "Using cached umap_learn-0.5.6-py3-none-any.whl (85 kB)\n", + "Using cached natsort-8.4.0-py3-none-any.whl (38 kB)\n", + "Using cached tqdm-4.66.4-py3-none-any.whl (78 kB)\n", + "Using cached array_api_compat-1.6-py3-none-any.whl (36 kB)\n", + "Using cached contourpy-1.2.1-cp312-cp312-win_amd64.whl (189 kB)\n", + "Using cached cycler-0.12.1-py3-none-any.whl (8.3 kB)\n", + "Using cached fonttools-4.51.0-cp312-cp312-win_amd64.whl (2.2 MB)\n", + "Using cached kiwisolver-1.4.5-cp312-cp312-win_amd64.whl (56 kB)\n", + "Downloading llvmlite-0.42.0-cp312-cp312-win_amd64.whl (28.1 MB)\n", + " ---------------------------------------- 0.0/28.1 MB ? eta -:--:--\n", + " -- ------------------------------------- 1.8/28.1 MB 37.0 MB/s eta 0:00:01\n", + " ----- ---------------------------------- 3.7/28.1 MB 39.2 MB/s eta 0:00:01\n", + " ----- ---------------------------------- 4.1/28.1 MB 29.3 MB/s eta 0:00:01\n", + " -------- ------------------------------- 5.7/28.1 MB 33.2 MB/s eta 0:00:01\n", + " ---------- ----------------------------- 7.4/28.1 MB 33.6 MB/s eta 0:00:01\n", + " ------------ --------------------------- 9.0/28.1 MB 33.8 MB/s eta 0:00:01\n", + " -------------- ------------------------- 10.3/28.1 MB 34.4 MB/s eta 0:00:01\n", + " ---------------- ----------------------- 11.8/28.1 MB 34.4 MB/s eta 0:00:01\n", + " ------------------- -------------------- 13.5/28.1 MB 32.8 MB/s eta 0:00:01\n", + " --------------------- ------------------ 15.1/28.1 MB 38.5 MB/s eta 0:00:01\n", + " ----------------------- ---------------- 16.7/28.1 MB 38.5 MB/s eta 0:00:01\n", + " ------------------------- -------------- 18.1/28.1 MB 38.5 MB/s eta 0:00:01\n", + " ---------------------------- ----------- 19.8/28.1 MB 38.5 MB/s eta 0:00:01\n", + " ------------------------------ --------- 21.3/28.1 MB 38.5 MB/s eta 0:00:01\n", + " -------------------------------- ------- 23.0/28.1 MB 40.9 MB/s eta 0:00:01\n", + " ---------------------------------- ----- 24.6/28.1 MB 38.5 MB/s eta 0:00:01\n", + " ------------------------------------ --- 26.0/28.1 MB 43.7 MB/s eta 0:00:01\n", + " --------------------------------------- 27.6/28.1 MB 38.5 MB/s eta 0:00:01\n", + " --------------------------------------- 28.1/28.1 MB 38.6 MB/s eta 0:00:01\n", + " --------------------------------------- 28.1/28.1 MB 38.6 MB/s eta 0:00:01\n", + " --------------------------------------- 28.1/28.1 MB 38.6 MB/s eta 0:00:01\n", + " --------------------------------------- 28.1/28.1 MB 38.6 MB/s eta 0:00:01\n", + " ---------------------------------------- 28.1/28.1 MB 21.8 MB/s eta 0:00:00\n", + "Using cached pillow-10.3.0-cp312-cp312-win_amd64.whl (2.5 MB)\n", + "Using cached pyparsing-3.1.2-py3-none-any.whl (103 kB)\n", + "Using cached pytz-2024.1-py2.py3-none-any.whl (505 kB)\n", + "Using cached threadpoolctl-3.5.0-py3-none-any.whl (18 kB)\n", + "Using cached tzdata-2024.1-py2.py3-none-any.whl (345 kB)\n", + "Using cached stdlib_list-0.10.0-py3-none-any.whl (79 kB)\n", + "Building wheels for collected packages: session-info\n", + " Building wheel for session-info (pyproject.toml): started\n", + " Building wheel for session-info (pyproject.toml): finished with status 'done'\n", + " Created wheel for session-info: filename=session_info-1.0.0-py3-none-any.whl size=8072 sha256=20ab999016d13070d635dfcf136ba9278f8f37f5ac2192b4ae7502a6745d2730\n", + " Stored in directory: c:\\users\\przem\\appdata\\local\\pip\\cache\\wheels\\23\\da\\7c\\868424f4a5845ab58cd8686e0eb405e9e1e2d4152bf702c39d\n", + "Successfully built session-info\n", + "Installing collected packages: pytz, array-api-compat, tzdata, tqdm, threadpoolctl, stdlib-list, pyparsing, pillow, numpy, networkx, natsort, llvmlite, legacy-api-wrap, kiwisolver, joblib, fonttools, cycler, session-info, scipy, patsy, pandas, numba, h5py, contourpy, statsmodels, scikit-learn, matplotlib, anndata, seaborn, pynndescent, umap-learn, scanpy\n", + "Successfully installed anndata-0.10.7 array-api-compat-1.6 contourpy-1.2.1 cycler-0.12.1 fonttools-4.51.0 h5py-3.11.0 joblib-1.4.2 kiwisolver-1.4.5 legacy-api-wrap-1.4 llvmlite-0.42.0 matplotlib-3.9.0 natsort-8.4.0 networkx-3.3 numba-0.59.1 numpy-1.26.4 pandas-2.2.2 patsy-0.5.6 pillow-10.3.0 pynndescent-0.5.12 pyparsing-3.1.2 pytz-2024.1 scanpy-1.10.1 scikit-learn-1.5.0 scipy-1.13.1 seaborn-0.13.2 session-info-1.0.0 statsmodels-0.14.2 stdlib-list-0.10.0 threadpoolctl-3.5.0 tqdm-4.66.4 tzdata-2024.1 umap-learn-0.5.6\n" + ] + } + ], + "source": [ + "!pip install scanpy" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'scanpy'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[1], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mscanpy\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01msc\u001b[39;00m\n\u001b[0;32m 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mnumpy\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mnp\u001b[39;00m\n\u001b[0;32m 3\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mpandas\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mpd\u001b[39;00m\n", + "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'scanpy'" + ] + } + ], + "source": [ + "import scanpy as sc\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib as mpl" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "scanpy==1.4.5.2.dev45+g890bc1e.d20200319 anndata==0.7.2.dev24+g669dd44 umap==0.4.0rc1 numpy==1.18.1 scipy==1.4.1 pandas==1.0.1 scikit-learn==0.22.2.post1 statsmodels==0.11.1 python-igraph==0.8.0 louvain==0.6.1\n" + ] + } + ], + "source": [ + "sc.logging.print_versions()\n", + "sc.set_figure_params(frameon=False, figsize=(4, 4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reading" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# !mkdir -p data\n", + "# !wget http://cf.10xgenomics.com/samples/cell-exp/3.1.0/5k_pbmc_protein_v3_nextgem/5k_pbmc_protein_v3_nextgem_filtered_feature_bc_matrix.h5 -O data/5k_pbmc_protein_v3_nextgem_filtered_feature_bc_matrix.h5" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "datafile = \"data/5k_pbmc_protein_v3_nextgem_filtered_feature_bc_matrix.h5\"" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n" + ] + }, + { + "data": { + "text/plain": [ + "AnnData object with n_obs × n_vars = 5527 × 21453 \n", + " var: 'gene_ids', 'feature_types', 'genome', 'n_counts'\n", + " layers: 'counts'" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pbmc = sc.read_10x_h5(datafile, gex_only=False)\n", + "pbmc.var_names_make_unique()\n", + "pbmc.layers[\"counts\"] = pbmc.X.copy()\n", + "sc.pp.filter_genes(pbmc, min_counts=1)\n", + "pbmc" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Gene Expression 21421\n", + "Antibody Capture 32\n", + "Name: feature_types, dtype: int64" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pbmc.var[\"feature_types\"].value_counts()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preprocessing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For ease of preprocessing, we'll split the data into seperate protein and RNA `AnnData` objects:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "protein = pbmc[:, pbmc.var[\"feature_types\"] == \"Antibody Capture\"].copy()\n", + "rna = pbmc[:, pbmc.var[\"feature_types\"] == \"Gene Expression\"].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(5527, 21421)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rna.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(5527, 21453)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pbmc.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Protein" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we'll take a look at the antibody counts." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We still need to explain the function here. I'm happy if we add it to the first tutorial, too (I know you did it already at some point, but I didn't want to let go of the simpler naming scheme back then; now I'd be happy to transition.)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "protein.var[\"control\"] = protein.var_names.str.contains(\"control\")\n", + "sc.pp.calculate_qc_metrics(\n", + " protein,\n", + " percent_top=(5, 10, 15),\n", + " var_type=\"antibodies\",\n", + " qc_vars=(\"control\",),\n", + " inplace=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " We can look check out the qc metrics for our data:\n", + " \n", + " **TODO**: I would like to include some justification for the change in normalization. It definitley has a much different distribution than transcripts. I think this could be shown through the qc plots, but it's a huge pain to move around these matplotlib plots. This might be more appropriate for the in-depth guide though.\n", + " \n", + "Agreed! But, having an explanation of the two images below is also a good first step. Also nice to contrast it with the corresponding RNA distributions. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 461, + "width": 470 + }, + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 461, + "width": 448 + }, + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.jointplot(\n", + " \"log1p_total_counts\",\n", + " \"n_antibodies_by_counts\",\n", + " protein.obs,\n", + " kind=\"hex\",\n", + " norm=mpl.colors.LogNorm(),\n", + ")\n", + "sns.jointplot(\n", + " \"log1p_total_counts\",\n", + " \"log1p_total_counts_control\",\n", + " protein.obs,\n", + " kind=\"hex\",\n", + " norm=mpl.colors.LogNorm(),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "protein.layers[\"counts\"] = protein.X.copy()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Discuss that this here is a different normalization." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "sc.pp.normalize_geometric(protein)\n", + "sc.pp.log1p(protein)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/isaac/github/scanpy/scanpy/neighbors/__init__.py:121: FutureWarning: This location for 'distances' is deprecated. It has been moved to .obsp['distances'], and will not be accesible here in a future version of anndata.\n", + " adata.uns['neighbors']['distances'] = neighbors.distances\n", + "/Users/isaac/github/scanpy/scanpy/neighbors/__init__.py:122: FutureWarning: This location for 'connectivities' is deprecated. It has been moved to .obsp['connectivities'], and will not be accesible here in a future version of anndata.\n", + " adata.uns['neighbors']['connectivities'] = neighbors.connectivities\n" + ] + } + ], + "source": [ + "sc.pp.pca(protein, n_comps=20)\n", + "sc.pp.neighbors(\n", + " protein, n_neighbors=30\n", + ") # why can't we just work with the default neighbors?\n", + "sc.tl.leiden(protein, key_added=\"protein_leiden\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/isaac/github/scanpy/scanpy/tools/_umap.py:147: FutureWarning: This location for 'connectivities' is deprecated. It has been moved to .obsp['connectivities'], and will not be accesible here in a future version of anndata.\n", + " adata.uns['neighbors']['connectivities'].tocoo(),\n", + "... storing 'feature_types' as categorical\n", + "... storing 'genome' as categorical\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 277, + "width": 362 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "# TODO: remove\n", + "protein.obsp[\"protein_connectivities\"] = protein.obsp[\"connectivities\"].copy()\n", + "sc.tl.umap(protein)\n", + "sc.pl.umap(protein, color=\"protein_leiden\", size=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "AnnData object with n_obs × n_vars = 5527 × 32 \n", + " obs: 'n_antibodies_by_counts', 'log1p_n_antibodies_by_counts', 'total_counts', 'log1p_total_counts', 'pct_counts_in_top_5_antibodies', 'pct_counts_in_top_10_antibodies', 'pct_counts_in_top_15_antibodies', 'total_counts_control', 'log1p_total_counts_control', 'pct_counts_control', 'protein_leiden'\n", + " var: 'gene_ids', 'feature_types', 'genome', 'n_counts', 'control', 'n_cells_by_counts', 'mean_counts', 'log1p_mean_counts', 'pct_dropout_by_counts', 'total_counts', 'log1p_total_counts'\n", + " uns: 'log1p', 'pca', 'neighbors', 'leiden', 'umap', 'protein_leiden_colors'\n", + " obsm: 'X_pca', 'X_umap'\n", + " varm: 'PCs'\n", + " layers: 'counts'\n", + " obsp: 'distances', 'connectivities', 'protein_connectivities'" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "protein" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### RNA" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we'll process our RNA in the typical way:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# sc.pp.filter_genes(rna, min_counts=1)\n", + "\n", + "rna.var[\"mito\"] = rna.var_names.str.startswith(\"MT-\")\n", + "sc.pp.calculate_qc_metrics(rna, qc_vars=[\"mito\"], inplace=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Yes, would be great to the see the QC plots, here, too. Are cells with low counts etc. weird only on the RNA level or also on the protein level? It'd be nice to see the QC plots side-by-side between RNA and protein, I'd say." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "rna.layers[\"counts\"] = rna.X.copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "sc.pp.normalize_total(rna)\n", + "sc.pp.log1p(rna)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/isaac/github/scanpy/scanpy/neighbors/__init__.py:121: FutureWarning: This location for 'distances' is deprecated. It has been moved to .obsp['distances'], and will not be accesible here in a future version of anndata.\n", + " adata.uns['neighbors']['distances'] = neighbors.distances\n", + "/Users/isaac/github/scanpy/scanpy/neighbors/__init__.py:122: FutureWarning: This location for 'connectivities' is deprecated. It has been moved to .obsp['connectivities'], and will not be accesible here in a future version of anndata.\n", + " adata.uns['neighbors']['connectivities'] = neighbors.connectivities\n", + "/Users/isaac/github/scanpy/scanpy/tools/_umap.py:147: FutureWarning: This location for 'connectivities' is deprecated. It has been moved to .obsp['connectivities'], and will not be accesible here in a future version of anndata.\n", + " adata.uns['neighbors']['connectivities'].tocoo(),\n" + ] + } + ], + "source": [ + "sc.pp.pca(rna)\n", + "sc.pp.neighbors(\n", + " rna, n_neighbors=30\n", + ") # why can't we just work with the default neighbors?\n", + "sc.tl.umap(rna)\n", + "sc.tl.leiden(rna, key_added=\"rna_leiden\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An alternative would be to recombine the data into the `pbmc` object here." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "rna.obsm[\"protein\"] = protein.to_df()\n", + "rna.obsm[\"protein_umap\"] = protein.obsm[\"X_umap\"]\n", + "rna.obs[\"protein_leiden\"] = protein.obs[\"protein_leiden\"]\n", + "rna.obsp[\"rna_connectivities\"] = rna.obsp[\"connectivities\"].copy()\n", + "rna.obsp[\"protein_connectivities\"] = protein.obsp[\"protein_connectivities\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/isaac/github/scanpy/scanpy/tools/_umap.py:147: FutureWarning: This location for 'connectivities' is deprecated. It has been moved to .obsp['connectivities'], and will not be accesible here in a future version of anndata.\n", + " adata.uns['neighbors']['connectivities'].tocoo(),\n" + ] + } + ], + "source": [ + "sc.tl.umap(rna)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "... storing 'feature_types' as categorical\n", + "... storing 'genome' as categorical\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 297, + "width": 702 + } + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 297, + "width": 702 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "sc.pl.umap(rna, color=[\"rna_leiden\", \"protein_leiden\"], size=10)\n", + "sc.pl.embedding(\n", + " rna, basis=\"protein_umap\", color=[\"rna_leiden\", \"protein_leiden\"], size=10\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The clusterings disagree quite a bit. It looks like neither modality is giving a full accounting of the data, so now we'll see what we can learn by combining the modalities." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting values between modalities\n", + "\n", + "* TODO: Get selectors like this working in scanpy." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports and helper functions" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DataTransformerRegistry.enable('default')" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import altair as alt\n", + "from functools import partial\n", + "\n", + "alt.renderers.enable(\"png\")\n", + "alt.data_transformers.disable_max_rows()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def embedding_chart(df: pd.DataFrame, coord_pat: str, *, size=5) -> alt.Chart:\n", + " \"\"\"Make schema for coordinates, like sc.pl.embedding.\"\"\"\n", + " x, y = df.columns[df.columns.str.contains(coord_pat)]\n", + " return (\n", + " alt.Chart(plotdf, height=300, width=300)\n", + " .mark_circle(size=size)\n", + " .encode(\n", + " x=alt.X(x, axis=None),\n", + " y=alt.Y(y, axis=None),\n", + " )\n", + " )\n", + "\n", + "\n", + "def umap_chart(df: pd.DataFrame, **kwargs) -> alt.Chart:\n", + " \"\"\"Like sc.pl.umap, but just the coordinates.\"\"\"\n", + " return embedding_chart(df, \"umap\", **kwargs)\n", + "\n", + "\n", + "def encode_color(\n", + " c: alt.Chart, col: str, *, qdomain=(0, 1), scheme: str = \"lightgreyred\"\n", + ") -> alt.Chart:\n", + " \"\"\"Add colors to an embedding plot schema.\"\"\"\n", + " base = c.properties(title=col)\n", + " if pd.api.types.is_categorical(c.data[col]):\n", + " return base.encode(color=col)\n", + " else:\n", + " return base.encode(\n", + " color=alt.Color(\n", + " col,\n", + " scale=alt.Scale(\n", + " scheme=scheme,\n", + " clamp=True,\n", + " domain=list(c.data[col].quantile(qdomain)),\n", + " nice=True,\n", + " ),\n", + " )\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "alt.ConcatChart(...)" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plotdf = sc.get.obs_df(\n", + " rna,\n", + " obsm_keys=[(\"X_umap\", i) for i in range(2)]\n", + " + [(\"protein\", i) for i in rna.obsm[\"protein\"].columns],\n", + ")\n", + "(\n", + " alt.concat(\n", + " *map(\n", + " partial(encode_color, umap_chart(plotdf), qdomain=(0, 0.95)),\n", + " plotdf.columns[5:10],\n", + " ),\n", + " columns=2\n", + " )\n", + " .resolve_scale(color=\"independent\")\n", + " .configure_axis(grid=False)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clustering" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here, we have a few approaches for clustering. Both which take into account both modalities of the data. First, we can use both connectivity graphs generated from each assay." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "sc.tl.leiden_multiplex(\n", + " rna, [\"rna_connectivities\", \"protein_connectivities\"]\n", + ") # Adds key \"leiden_multiplex\" by default" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternativley, we can try and combine these representations into a joint graph." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def join_graphs_max(g1: \"sparse.spmatrix\", g2: \"sparse.spmatrix\"):\n", + " \"\"\"Take the maximum edge value from each graph.\"\"\"\n", + " out = g1.copy()\n", + " mask = g1 < g2\n", + " out[mask] = g2[mask]\n", + "\n", + " return out" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/site-packages/scipy/sparse/_index.py:126: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.\n", + " self._set_arrayXarray(i, j, x)\n" + ] + } + ], + "source": [ + "rna.obsp[\"connectivities\"] = join_graphs_max(\n", + " rna.obsp[\"rna_connectivities\"], rna.obsp[\"protein_connectivities\"]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "sc.tl.leiden(rna, key_added=\"joint_leiden\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/isaac/github/scanpy/scanpy/tools/_umap.py:147: FutureWarning: This location for 'connectivities' is deprecated. It has been moved to .obsp['connectivities'], and will not be accesible here in a future version of anndata.\n", + " adata.uns['neighbors']['connectivities'].tocoo(),\n" + ] + } + ], + "source": [ + "sc.tl.umap(rna)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we've got a clustering which better represents both modalities in the data:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 280, + "width": 644 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "sc.pl.umap(rna, color=[\"leiden_multiplex\", \"joint_leiden\"], size=5)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 300, + "width": 310 + }, + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.heatmap(\n", + " pd.crosstab(rna.obs[\"leiden_multiplex\"], rna.obs[\"rna_leiden\"], normalize=\"index\")\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 300, + "width": 310 + }, + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.heatmap(\n", + " pd.crosstab(\n", + " rna.obs[\"leiden_multiplex\"], rna.obs[\"protein_leiden\"], normalize=\"index\"\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Gather data" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "pbmc.X[:, (pbmc.var[\"feature_types\"] == \"Gene Expression\").values] = rna.X" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/site-packages/scipy/sparse/_index.py:126: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.\n", + " self._set_arrayXarray(i, j, x)\n" + ] + } + ], + "source": [ + "pbmc.X[:, (pbmc.var[\"feature_types\"] == \"Antibody Capture\").values] = protein.X" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "pbmc.obsm.update(rna.obsm)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "pbmc.obs[rna.obs.columns] = rna.obs" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "AnnData object with n_obs × n_vars = 5527 × 21453 \n", + " obs: 'n_genes_by_counts', 'log1p_n_genes_by_counts', 'total_counts', 'log1p_total_counts', 'pct_counts_in_top_50_genes', 'pct_counts_in_top_100_genes', 'pct_counts_in_top_200_genes', 'pct_counts_in_top_500_genes', 'total_counts_mito', 'log1p_total_counts_mito', 'pct_counts_mito', 'rna_leiden', 'protein_leiden', 'leiden_multiplex', 'joint_leiden'\n", + " var: 'gene_ids', 'feature_types', 'genome', 'n_counts'\n", + " obsm: 'X_pca', 'X_umap', 'protein', 'protein_umap'\n", + " layers: 'counts'" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pbmc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Labelling" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "... storing 'feature_types' as categorical\n", + "... storing 'genome' as categorical\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 277, + "width": 265 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "sc.pl.umap(pbmc, color=\"leiden_multiplex\", legend_loc=\"on data\")" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [], + "source": [ + "sc.tl.leiden(\n", + " pbmc, resolution=0.3, key_added=\"highlevel\"\n", + ") # I had to patch scanpy for this, but sergei's PR should make this work." + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [], + "source": [ + "highlevel_labels = {\n", + " \"0\": \"T-Cells\",\n", + " \"1\": \"Monocytes\",\n", + " \"2\": \"NK Cells\",\n", + " \"3\": \"B-Cells\",\n", + "}\n", + "pbmc.obs[\"highlevel\"] = pbmc.obs[\"highlevel\"].map(highlevel_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 277, + "width": 366 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "sc.pl.umap(pbmc, color=\"highlevel\")" + ] + }, + { + "cell_type": "code", + "execution_count": 203, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "... storing 'lowlevel' as categorical\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 277, + "width": 448 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "joint_mapping = {\n", + " \"1\": \"Classical monocyte\",\n", + " \"6\": \"Dendritic cells\",\n", + " \"7\": \"Non-classical monocyte\",\n", + " \"4\": \"NK-cells\",\n", + " \"5\": \"B-cells\",\n", + " \"3\": \"CD8+ Effector T-cells\", # \"CD8+, CCR7-, \"CCL5+\"\n", + " \"0\": \"CD4+ Naive T-Cells\", # CD4+, CCR7+, CCL5-,\n", + " \"2\": \"CD4+ Memory T-Cells\", # CD4+, CCR7-, CCL5+\n", + " # I think 8 may be doublets since it's all the monocyte markers and all the t cell markers\n", + "}\n", + "\n", + "pbmc.obs[\"lowlevel\"] = pbmc.obs[\"joint_leiden\"].map(joint_mapping)\n", + "\n", + "sc.pl.umap(pbmc, color=\"lowlevel\")" + ] + }, + { + "cell_type": "code", + "execution_count": 201, + "metadata": {}, + "outputs": [], + "source": [ + "markers = {\n", + " \"CD4\": [\"CD4_TotalSeqB\", \"CD4\"],\n", + " \"CD8\": [\"CD8a_TotalSeqB\", \"CD8A\", \"CD8B\"],\n", + " \"B-cell\": [\"CD19_TotalSeqB\"],\n", + " \"Monocytes\": [\n", + " \"CD86_TotalSeqB\",\n", + " \"CD11b_TotalSeqB\",\n", + " \"CD14\",\n", + " \"CD14_TotalSeqB\",\n", + " \"FCGR3A\",\n", + " \"CD14_TotalSeqB\",\n", + " ],\n", + " \"NK Cells\": [\"FCGR3A\", \"NKG7\"],\n", + " \"T-Cell Activation\": [\"CCL5\", \"CD45RO_TotalSeqB\", \"CCR7\", \"CD45RA_TotalSeqB\"],\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 202, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 480, + "width": 679 + }, + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "GridSpec(2, 5, height_ratios=[0.5, 10], width_ratios=[6.3, 0, 0.2, 0.5, 0.25])" + ] + }, + "execution_count": 202, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sc.pl.dotplot( # Should we use z-scores for the hue in these?\n", + " pbmc,\n", + " markers,\n", + " groupby=\"lowlevel\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + }, + "toc": { + "colors": { + "hover_highlight": "#DAA520", + "navigate_num": "#000000", + "navigate_text": "#333333", + "running_highlight": "#FF0000", + "selected_highlight": "#FFD700", + "sidebar_border": "#EEEEEE", + "wrapper_background": "#FFFFFF" + }, + "moveMenuLeft": true, + "nav_menu": { + "height": "12.352940559387207px", + "width": "252.35293579101562px" + }, + "navigate_menu": true, + "number_sections": false, + "sideBar": false, + "threshold": 4, + "toc_cell": false, + "toc_section_display": "block", + "toc_window_display": false, + "widenNotebook": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/old_code/old_notebooks/evaluation cls.ipynb b/old_code/old_notebooks/evaluation cls.ipynb new file mode 100644 index 0000000..c255ca5 --- /dev/null +++ b/old_code/old_notebooks/evaluation cls.ipynb @@ -0,0 +1,632 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "from utils.data_utils import load_anndata\n", + "from train import load_config, create_model\n", + "from models.babel import BabelModel\n", + "import json\n", + "import yaml\n", + "import scanpy as sc\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "from argparse import Namespace\n", + "from itertools import cycle\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pytorch_lightning as pl\n", + "import seaborn as sns\n", + "import sklearn\n", + "import torch\n", + "from pytorch_lightning import LightningModule\n", + "from sklearn.decomposition import PCA\n", + "from sklearn.metrics import (\n", + " adjusted_rand_score,\n", + " auc,\n", + " normalized_mutual_info_score,\n", + " roc_curve,\n", + " silhouette_score,\n", + ")\n", + "from sklearn.preprocessing import label_binarize\n", + "from torch import nn\n", + "from torch.nn import functional as F\n", + "\n", + "from models.building_blocks import Block\n", + "\n", + "from sklearn.preprocessing import LabelEncoder\n", + "from sklearn.model_selection import train_test_split\n", + "from torch.utils.data import DataLoader, TensorDataset\n", + "\n", + "import scanpy as sc\n", + "import numpy as np\n", + "import torch\n", + "import torch.nn as nn\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import LabelEncoder\n", + "from torch.utils.data import DataLoader, TensorDataset\n", + "import pytorch_lightning as pl\n", + "from pytorch_lightning.callbacks import ModelCheckpoint\n", + "\n", + "from lightning.pytorch.loggers import TensorBoardLogger\n", + "import gdown" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load data" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + } + ], + "source": [ + "test_data = load_anndata(\n", + " mode=\"test\",\n", + " normalize=True,\n", + " remove_batch_effect=False,\n", + " target_hierarchy_level=-1,\n", + " preload_subsample_frac=None,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + } + ], + "source": [ + "hierarchy = {'level1': ['Hematopoietic Stem Cells and Progenitors', 'Hematopoietic Stem Cells and Progenitors', 'Hematopoietic Stem Cells and Progenitors', 'Hematopoietic Stem Cells and Progenitors', 'Monocytes and Dendritic Cells', 'Monocytes and Dendritic Cells', 'Monocytes and Dendritic Cells', 'Monocytes and Dendritic Cells', 'Monocytes and Dendritic Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'T Cells', 'B Cells and Plasma Cells', 'B Cells and Plasma Cells', 'B Cells and Plasma Cells', 'B Cells and Plasma Cells', 'B Cells and Plasma Cells', 'B Cells and Plasma Cells', 'B Cells and Plasma Cells', 'B Cells and Plasma Cells', 'B Cells and Plasma Cells', 'Natural Killer Cells', 'Natural Killer Cells', 'Erythroid Lineage', 'Erythroid Lineage', 'Erythroid Lineage', 'Erythroid Lineage', 'Innate Lymphoid Cells (ILCs)', 'Innate Lymphoid Cells (ILCs)'], 'level2': ['HSC', 'Progenitors', 'Progenitors', 'Progenitors', 'Monocytes', 'Monocytes', 'Dendritic Cells', 'Dendritic Cells', 'Dendritic Cells', 'CD4+ T Cells', 'CD4+ T Cells', 'CD4+ T Cells', 'CD4+ T Cells', 'CD8+ T Cells', 'CD8+ T Cells', 'CD8+ T Cells', 'CD8+ T Cells', 'CD8+ T Cells', 'CD8+ T Cells', 'CD8+ T Cells', 'CD8+ T Cells', 'CD8+ T Cells', 'Special T Cell Types', 'Special T Cell Types', 'Special T Cell Types', 'Special T Cell Types', 'Special T Cell Types', 'Special T Cell Types', 'Naive B Cells', 'Naive B Cells', 'Transitional B Cells', 'B1 B Cells', 'B1 B Cells', 'Plasma Cells', 'Plasma Cells', 'Plasmablasts', 'Plasmablasts', 'NK', 'NK CD158e1+', 'Erythroblasts and Precursors', 'Erythroblasts and Precursors', 'Erythroblasts and Precursors', 'Reticulocytes', 'ILC', 'ILC1'], 'level3': ['HSC', 'Lymph prog', 'G/M prog', 'MK/E prog', 'CD14+ Mono', 'CD16+ Mono', 'cDC1', 'cDC2', 'pDC', 'CD4+ T naive', 'CD4+ T activated', 'CD4+ T activated integrinB7+', 'CD4+ T CD314+ CD45RA+', 'CD8+ T naive', 'CD8+ T CD57+ CD45RO+', 'CD8+ T CD57+ CD45RA+', 'CD8+ T TIGIT+ CD45RO+', 'CD8+ T TIGIT+ CD45RA+', 'CD8+ T CD49f+', 'CD8+ T CD69+ CD45RO+', 'CD8+ T CD69+ CD45RA+', 'CD8+ T naive CD127+ CD26- CD101-', 'MAIT', 'gdT CD158b+', 'gdT TCRVD2+', 'dnT', 'T reg', 'T prog cycling', 'Naive CD20+ B IGKC+', 'Naive CD20+ B IGKC-', 'Transitional B', 'B1 B IGKC+', 'B1 B IGKC-', 'Plasma cell IGKC+', 'Plasma cell IGKC-', 'Plasmablast IGKC+', 'Plasmablast IGKC-', 'NK', 'NK CD158e1+', 'Proerythroblast', 'Erythroblast', 'Normoblast', 'Reticulocyte', 'ILC', 'ILC1'], 'description': ['Hematopoietic Stem Cells', 'Lymphoid progenitors', 'Granulocyte-Macrophage progenitors', 'Megakaryocyte-Erythroid progenitors', 'CD14+ Monocytes', 'CD16+ Monocytes', 'Conventional Dendritic Cells, subtype 1', 'Conventional Dendritic Cells, subtype 2', 'Plasmacytoid Dendritic Cells', 'Naive CD4+ T Cells', 'Activated CD4+ T Cells', 'Activated CD4+ T Cells expressing integrin β7', 'CD4+ T Cells expressing CD314 and CD45RA', 'Naive CD8+ T Cells', 'CD8+ T Cells expressing CD57 and CD45RO', 'CD8+ T Cells expressing CD57 and CD45RA', 'CD8+ T Cells expressing TIGIT and CD45RO', 'CD8+ T Cells expressing TIGIT and CD45RA', 'CD8+ T Cells expressing CD49f', 'CD8+ T Cells expressing CD69 and CD45RO', 'CD8+ T Cells expressing CD69 and CD45RA', 'Naive CD8+ T Cells expressing CD127, not CD26 or CD101', 'Mucosal-Associated Invariant T Cells', 'Gamma Delta T Cells expressing CD158b', 'Gamma Delta T Cells expressing TCRVδ2', 'Double-Negative T Cells', 'Regulatory T Cells', 'Cycling Progenitor T Cells', 'Naive B Cells expressing CD20 and IGKC', 'Naive B Cells expressing CD20, not IGKC', 'Transitional B Cells', 'B1 B Cells expressing IGKC', 'B1 B Cells not expressing IGKC', 'Plasma Cells expressing IGKC', 'Plasma Cells not expressing IGKC', 'Plasmablasts expressing IGKC', 'Plasmablasts not expressing IGKC', 'Natural Killer Cells', 'Natural Killer Cells expressing CD158e1', 'Proerythroblast', 'Erythroblast', 'Normoblast', 'Reticulocyte', 'Innate Lymphoid Cells', 'ILC1']}\n", + "hierarchy_df = pd.DataFrame(data = hierarchy)\n", + "test_data.obs = pd.merge(test_data.obs, hierarchy_df, left_on=\"cell_type\", right_on=\"level3\", how=\"left\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load Latent" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "LATENT_NAME = \"latent_omiae\"\n", + "DATA_PATH = \"../data/latent/latent_omiae_test\"" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "LATENT_NAME = \"omivae_latent\"\n", + "DATA_PATH = \"../data/latent/omivae_2024-06-15_14-02-51/latent_test.zip\"" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "LATENT_NAME = \"babel_latent_adt\"\n", + "DATA_PATH = \"../data/latent/adam_babel/adam_babel_latent_test_adt\"" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "LATENT_NAME = \"babel_latent_gex\"\n", + "DATA_PATH = \"../data/latent/adam_babel/adam_babel_latent_test_gex\"" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "LATENT_NAME = \"latent_omiae\"\n", + "DATA_PATH = \"../data/latent/omiae_simple_2024-06-15_10-32-21/latent_omiae_test.zip\"" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "test_data.obsm[LATENT_NAME] = torch.load(DATA_PATH)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Downstream task" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "LATENT_DIM = 16\n", + "DATA = test_data\n", + "LEVEL = 'level3'\n", + "HIDDEN_DIM = 16 * 4" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\adamb\\AppData\\Local\\Temp\\ipykernel_26028\\2057320055.py:9: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " X = torch.tensor(DATA.obsm[LATENT_NAME], dtype=torch.float32)\n" + ] + } + ], + "source": [ + "# Extract the labels (cell types)\n", + "labels = DATA.obs[LEVEL].values\n", + "\n", + "# Encode labels to integers\n", + "label_encoder = LabelEncoder()\n", + "labels_encoded = label_encoder.fit_transform(labels)\n", + "\n", + "# Convert to PyTorch tensors\n", + "X = torch.tensor(DATA.obsm[LATENT_NAME], dtype=torch.float32)\n", + "y = torch.tensor(labels_encoded, dtype=torch.long)\n", + "\n", + "# Split the data into training and testing sets\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", + "\n", + "# Create DataLoader for training and testing sets\n", + "train_dataset = TensorDataset(X_train, y_train)\n", + "test_dataset = TensorDataset(X_test, y_test)\n", + "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n", + "test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "from models.building_blocks import Block\n", + "\n", + "\n", + "class ClassificationModel(pl.LightningModule):\n", + " def __init__(self, latent_dim, num_classes, hidden_dim, do_batch_norm=False):\n", + " super().__init__()\n", + " self.layers = nn.Sequential(\n", + " nn.Linear(latent_dim, hidden_dim),\n", + " nn.ReLU(),\n", + " nn.Linear(hidden_dim, num_classes),\n", + " )\n", + " self.loss = nn.CrossEntropyLoss() # Adjust\n", + "\n", + " def forward(self, z):\n", + " return self.layers(z)\n", + "\n", + " def training_step(self, batch, batch_idx):\n", + " x, y = batch\n", + " y_hat = self.forward(x)\n", + " loss = self.loss(y_hat, y)\n", + " self.log(\n", + " \"train_loss\", loss, on_step=True, on_epoch=True, prog_bar=True, logger=True\n", + " )\n", + " return loss\n", + "\n", + " def validation_step(self, batch, batch_idx):\n", + " x, y = batch\n", + " y_hat = self.forward(x)\n", + " loss = self.loss(y_hat, y)\n", + " self.log(\n", + " \"val_loss\", loss, on_step=False, on_epoch=True, prog_bar=True, logger=True\n", + " )\n", + " \n", + " return loss\n", + "\n", + " def configure_optimizers(self):\n", + " # Define optimizer here\n", + " optimizer = torch.optim.Adam(\n", + " self.parameters(), lr=0.001\n", + " ) # Adjust learning rate\n", + " return optimizer" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: False, used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "--------------------------------------------\n", + "0 | layers | Sequential | 3.7 K \n", + "1 | loss | CrossEntropyLoss | 0 \n", + "--------------------------------------------\n", + "3.7 K Trainable params\n", + "0 Non-trainable params\n", + "3.7 K Total params\n", + "0.015 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9f7e12dbd1724f568c2c17f7351c9fc1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | | 0/? [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Silhouette-Score: 0.0861324593424797\n", + "Davies-Bouldin-Index for: 3.8422040674302402\n" + ] + } + ], + "source": [ + "umap_and_scores(test_data, LATENT_NAME, 20)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.5055259270521708" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "davies_bouldin_score(test_data.obsm[LATENT_NAME], labels=test_data.obs['level1'])" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.0756075467199464" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "davies_bouldin_score(test_data.obsm[LATENT_NAME], labels=test_data.obs['level2'])" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3.0986936101361637" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "davies_bouldin_score(test_data.obsm[LATENT_NAME], labels=test_data.obs['level3'])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# PCA representation of latent embedding\n", + "# Clustering by all call_types\n", + "import scanpy as sc\n", + "from sklearn.decomposition import PCA\n", + "from sklearn.metrics import silhouette_score, davies_bouldin_score\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Input: AnnData Object, 'embedding name', n_components\n", + "# Silhouttte Score: Ranges from -1 to 1, higher values indicate better cluster separation\n", + "# Davies-Bouldine-Index: A low index indicates that clusters are well separates\n", + "def pca_and_scores_for_embedding(adata, embedding_key, n_components=10):\n", + " embedding_data = adata.obsm[embedding_key]\n", + "\n", + " pca = PCA(n_components=n_components)\n", + " pca_result = pca.fit_transform(embedding_data)\n", + "\n", + " adata.obsm['X_pca'] = pca_result\n", + "\n", + " plt.figure(figsize=(8, 6))\n", + " sc.pl.pca(adata, color='cell_type', size=20, ncols=1)\n", + " plt.show()\n", + "\n", + " pca_coords = adata.obsm['X_pca']\n", + " labels = adata.obs['cell_type']\n", + "\n", + " # Calculate Silhouetten-Score\n", + " sil_score = silhouette_score(pca_coords, labels)\n", + " print(f'Silhouetten-Score: {sil_score}')\n", + "\n", + " # Calculate Davies-Bouldin-Index\n", + " db_score = davies_bouldin_score(pca_coords, labels)\n", + " print(f'Davies-Bouldin-Index for {embedding_key}: {db_score}')\n", + "\n", + "# Example\n", + "# pca_and_scores_for_embedding(adata, 'latent_embedding_adt_3', n_components=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Silhouetten-Score: 0.24392212392088705\n", + "Davies-Bouldin-Index for latent_omiiwae: 2.6496585439434286\n" + ] + } + ], + "source": [ + "pca_and_scores_for_embedding(test_data, LATENT_NAME, 10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compute metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "LABELS_COLUMN = \"level1\"\n", + "X = test_data.obsm[LATENT_NAME]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Silhouette score" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "silhouette_score1 = sklearn.metrics.silhouette_score(X, labels=test_data.obs[\"level1\"])\n", + "silhouette_score2 = sklearn.metrics.silhouette_score(X, labels=test_data.obs[\"level2\"])\n", + "silhouette_score3 = sklearn.metrics.silhouette_score(X, labels=test_data.obs[\"level3\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Silhouette score for level 1: 0.29312247037887573\n", + "Silhouette score for level 2: 0.1856389343738556\n", + "Silhouette score for level 3: 0.25174757838249207\n" + ] + } + ], + "source": [ + "print(f\"Silhouette score for level 1: {silhouette_score1}\")\n", + "print(f\"Silhouette score for level 2: {silhouette_score2}\")\n", + "print(f\"Silhouette score for level 3: {silhouette_score3}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'Series' object has no attribute 'codes'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_17272\\3608699213.py\u001b[0m in \u001b[0;36m?\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtest_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mobs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mLABELS_COLUMN\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcodes\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\pandas\\core\\generic.py\u001b[0m in \u001b[0;36m?\u001b[1;34m(self, name)\u001b[0m\n\u001b[0;32m 6295\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mname\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_accessors\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 6296\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_info_axis\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_can_hold_identifiers_and_holds_name\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 6297\u001b[0m \u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 6298\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 6299\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mobject\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__getattribute__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m: 'Series' object has no attribute 'codes'" + ] + } + ], + "source": [ + "test_data.obs[LABELS_COLUMN].codes" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For n_clusters = 7 The average silhouette_score is : 0.29312247\n", + "For n_clusters = 18 The average silhouette_score is : 0.18563893\n", + "For n_clusters = 40 The average silhouette_score is : 0.25174758\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.cm as cm\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from sklearn.cluster import KMeans\n", + "from sklearn.datasets import make_blobs\n", + "from sklearn.metrics import silhouette_samples, silhouette_score\n", + "\n", + "\n", + "for label_name in [\"level1\", \"level2\", \"level3\"]:\n", + " y = test_data.obs[label_name]\n", + " n_clusters = y.nunique()\n", + " # Create a subplot with 1 row and 2 columns\n", + " fig, (ax1, ax2) = plt.subplots(1, 2)\n", + " fig.set_size_inches(18, 7)\n", + "\n", + " # The 1st subplot is the silhouette plot\n", + " # The silhouette coefficient can range from -1, 1 but in this example all\n", + " # lie within [-0.1, 1]\n", + " ax1.set_xlim([-0.1, 1])\n", + " # The (n_clusters+1)*10 is for inserting blank space between silhouette\n", + " # plots of individual clusters, to demarcate them clearly.\n", + " ax1.set_ylim([0, len(X) + (n_clusters + 1) * 10])\n", + "\n", + " # # Initialize the clusterer with n_clusters value and a random generator\n", + " # # seed of 10 for reproducibility.\n", + " # clusterer = KMeans(n_clusters=n_clusters, random_state=10)\n", + " label_encoder = LabelEncoder()\n", + " cluster_labels = label_encoder.fit_transform(y)\n", + "\n", + " # The silhouette_score gives the average value for all the samples.\n", + " # This gives a perspective into the density and separation of the formed\n", + " # clusters\n", + " silhouette_avg = silhouette_score(X, cluster_labels)\n", + " print(\n", + " \"For n_clusters =\",\n", + " n_clusters,\n", + " \"The average silhouette_score is :\",\n", + " silhouette_avg,\n", + " )\n", + "\n", + " # Compute the silhouette scores for each sample\n", + " sample_silhouette_values = silhouette_samples(X, cluster_labels)\n", + "\n", + " y_lower = 10\n", + " for i in range(n_clusters):\n", + " # Aggregate the silhouette scores for samples belonging to\n", + " # cluster i, and sort them\n", + " ith_cluster_silhouette_values = sample_silhouette_values[cluster_labels == i]\n", + "\n", + " ith_cluster_silhouette_values.sort()\n", + "\n", + " size_cluster_i = ith_cluster_silhouette_values.shape[0]\n", + " y_upper = y_lower + size_cluster_i\n", + "\n", + " color = cm.nipy_spectral(float(i) / n_clusters)\n", + " ax1.fill_betweenx(\n", + " np.arange(y_lower, y_upper),\n", + " 0,\n", + " ith_cluster_silhouette_values,\n", + " facecolor=color,\n", + " edgecolor=color,\n", + " alpha=0.7,\n", + " )\n", + "\n", + " # Label the silhouette plots with their cluster numbers at the middle\n", + " ax1.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))\n", + "\n", + " # Compute the new y_lower for next plot\n", + " y_lower = y_upper + 10 # 10 for the 0 samples\n", + "\n", + " ax1.set_title(\"The silhouette plot for the various clusters.\")\n", + " ax1.set_xlabel(\"The silhouette coefficient values\")\n", + " ax1.set_ylabel(\"Cluster label\")\n", + "\n", + " # The vertical line for average silhouette score of all the values\n", + " ax1.axvline(x=silhouette_avg, color=\"red\", linestyle=\"--\")\n", + "\n", + " ax1.set_yticks([]) # Clear the yaxis labels / ticks\n", + " ax1.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])\n", + "\n", + " # 2nd Plot showing the actual clusters formed\n", + " colors = cm.nipy_spectral(cluster_labels.astype(float) / n_clusters)\n", + " ax2.scatter(\n", + " X[:, 0], X[:, 1], marker=\".\", s=30, lw=0, alpha=0.7, c=colors, edgecolor=\"k\"\n", + " )\n", + "\n", + " # # Labeling the clusters\n", + " # centers = clusterer.cluster_centers_\n", + " # # Draw white circles at cluster centers\n", + " # ax2.scatter(\n", + " # centers[:, 0],\n", + " # centers[:, 1],\n", + " # marker=\"o\",\n", + " # c=\"white\",\n", + " # alpha=1,\n", + " # s=200,\n", + " # edgecolor=\"k\",\n", + " # )\n", + "\n", + " # for i, c in enumerate(centers):\n", + " # ax2.scatter(c[0], c[1], marker=\"$%d$\" % i, alpha=1, s=50, edgecolor=\"k\")\n", + "\n", + " ax2.set_title(\"The visualization of the clustered data.\")\n", + " ax2.set_xlabel(\"Feature space for the 1st feature\")\n", + " ax2.set_ylabel(\"Feature space for the 2nd feature\")\n", + "\n", + " plt.suptitle(\n", + " \"Silhouette analysis for KMeans clustering on sample data with n_clusters = %d\"\n", + " % n_clusters,\n", + " fontsize=14,\n", + " fontweight=\"bold\",\n", + " )\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Clustering" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "AnnData object with n_obs × n_vars = 15066 × 14087\n", + " obs: 'GEX_n_genes_by_counts', 'GEX_pct_counts_mt', 'GEX_size_factors', 'GEX_phase', 'ADT_n_antibodies_by_counts', 'ADT_total_counts', 'ADT_iso_count', 'cell_type', 'batch', 'ADT_pseudotime_order', 'GEX_pseudotime_order', 'Samplename', 'Site', 'DonorNumber', 'Modality', 'VendorLot', 'DonorID', 'DonorAge', 'DonorBMI', 'DonorBloodType', 'DonorRace', 'Ethnicity', 'DonorGender', 'QCMeds', 'DonorSmoker', 'is_train', 'level1', 'level2', 'level3', 'description'\n", + " var: 'feature_types', 'gene_id'\n", + " uns: 'dataset_id', 'genome', 'organism', 'log1p', 'neighbors', 'umap', 'cell_type_colors'\n", + " obsm: 'ADT_X_pca', 'ADT_X_umap', 'ADT_isotype_controls', 'GEX_X_pca', 'GEX_X_umap', 'omivae_latent', 'X_umap'\n", + " layers: 'counts'\n", + " obsp: 'distances', 'connectivities'" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_data" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.stats import entropy\n", + "\n", + "def calculate_entropy_metric_for_leiden_custering(adata, use_rep, target_name):\n", + " sc.pp.neighbors(adata, n_neighbors=30, use_rep=use_rep)\n", + " sc.tl.leiden(adata, resolution=1.0)\n", + " cluster_labels = adata.obs['leiden']\n", + " num_clusters = len(cluster_labels.unique())\n", + " print(f'Target name: {target_name}')\n", + " print(f\"Rep: {use_rep}\")\n", + " print(f\"Number of clusters: {num_clusters}\")\n", + " crosstab = pd.crosstab(test_data.obs['leiden'], test_data.obs[target_name])\n", + " cluster_entropies = np.apply_along_axis(entropy, axis=1, arr=crosstab.values)\n", + " num_samples_per_cluster = crosstab.sum(axis=1)\n", + " total_num_samples = num_samples_per_cluster.sum()\n", + " cluster_weights = num_samples_per_cluster / total_num_samples\n", + " weighted_entropy = np.sum(cluster_entropies * cluster_weights)\n", + " print(f\"Weighted entropy: {weighted_entropy}\")\n", + " return weighted_entropy " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Entropy metric for leiden clustering: level1" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Target name: level1\n", + "Rep: omivae_latent\n", + "Number of clusters: 29\n", + "Weighted entropy: 0.14120317590647122\n" + ] + }, + { + "data": { + "text/plain": [ + "0.14120317590647122" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculate_entropy_metric_for_leiden_custering(test_data, use_rep=LATENT_NAME, target_name='level1')" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Target name: level2\n", + "Rep: omivae_latent\n", + "Number of clusters: 29\n", + "Weighted entropy: 0.4210108926351834\n" + ] + }, + { + "data": { + "text/plain": [ + "0.4210108926351834" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculate_entropy_metric_for_leiden_custering(test_data, use_rep=LATENT_NAME, target_name='level2')" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Target name: level3\n", + "Rep: omivae_latent\n", + "Number of clusters: 29\n", + "Weighted entropy: 0.7696762409727608\n" + ] + }, + { + "data": { + "text/plain": [ + "0.7696762409727608" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculate_entropy_metric_for_leiden_custering(test_data, use_rep=LATENT_NAME, target_name='level3')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Entropy metric for leiden clustering: batch" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Target name: batch\n", + "Rep: omivae_latent\n", + "Number of clusters: 35\n", + "Weighted entropy: 0.9544105521642919\n" + ] + }, + { + "data": { + "text/plain": [ + "0.9544105521642919" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculate_entropy_metric_for_leiden_custering(test_data, use_rep=LATENT_NAME, target_name='batch')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAJBCAYAAADbS7YwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACrcklEQVR4nOzdd1gU1/c/8De9g4IoVcAGKtbYGxobdmPDHmssMUaNxo+9axJ7YmLvvWOJgrH3khgVG1ZAbLFhpXN+f/Db+e7szsLOsguLe17Ps4+ye5mdHXZmztw591wzIiIwxhhjzGSZ5/UKMMYYYyxvcTDAGGOMmTgOBhhjjDETx8EAY4wxZuI4GGCMMcZMHAcDjDHGmInjYIAxxhgzcRwMMMYYYyaOgwHGGGPMxHEwwBhjjJk4DgYYY4wxE8fBAGOMMWbiOBhgjDHGTBwHA4wxxpiJ42CAMcYYM3EcDDDGGGMmjoMBxhhjzMRxMMAYY4yZOA4GGGOMMRPHwQBjjDFm4jgYYIwxxkwcBwOMMcaYieNggDHGGDNxHAwwxhhjJs4yr1eAaYeIkJycnNerwZhRsLGxgZmZWV6vBmOfDQ4G8gEiwsSJExEdHZ3Xq8KYUQgMDMTUqVM5IGBMT/g2QT6QnJzMgQBjSqKjo7mnjDE94p6BfGb58uWwsbHJ69VgLE8kJyejf//+eb0ajH12OBjIZ2xsbGBra5vXq8EYY+wzwrcJGGOMMRPHwQBjjDFm4jgYYIwxxkwcBwOMMcaYieNggDHGGDNxHAwwxhhjJo6DAcYYY8zEcTDAGGOMmTgOBhhjjDETx8EAY4wxZuI4GGCMMcZMHAcDjDHGmInjYIAxxhgzcRwMMMYYYyaOgwHGGGPMxHEwwBhjjJk4DgYYY4wxE8fBAGOMMWbiOBhgjDHGTBwHA4wxxpiJ42CAMcYYM3EcDDDGGGMmjoMBxhhjzMRxMMAYY4yZOA4GGGOMMRPHwQBjjDFm4jgYYIwxxkwcBwOMMcaYieNggDHGGDNxHAwwxhhjJo6DAcYYY8zEcTDAGGOMmTgOBhhjjDETx8EAY4wxZuI4GGCMMcZMHAcDjDHGmInjYIAxxhgzcRwMMMYYYyaOgwHGGGPMxHEwwBhjjJk4DgYYY4wxE8fBAGOMMWbiOBhgjDHGTBwHA4wxxpiJ42CAMcYYM3EcDDDGGGMmjoMBxhhjzMRxMMAYY4yZOA4GGGOMMRPHwQBjjDFm4jgYYIwxxkwcBwOMMcaYieNggDHGGDNxHAwwxhhjJo6DAcYYY8zEcTDAGGOMmTgOBhhjjDETx8EAY4wxZuIs83oFGGPyEBGSk5PzejXyhPLnNtVtAAA2NjYwMzPL69VgnxEOBhjLR4gIEydORHR0dF6vSp7r379/Xq9CngkMDMTUqVM5IGB6w7cJGMtHkpOTORBgiI6ONumeEaZ/3DPAWD61fPly2NjY5PVq5CoiQkpKCgDA2tra5K6Mk5OTTbpHhBkOBwOM5VM2NjawtbXN69XIdXZ2dnm9Cox9djgYYIyxLBhTwqYxJ1ByUmP+xsEAY4xpYMwJm8Z2u4CTGvM3TiBkjDENOGFTe5zUmL9xzwBjjGnBGBI2jTGBkpMaPw8cDDDGmBaMJWGTEyiZIfBtAsYYY8zEcTDAGGOMmTgOBhhjjDETx8EAY4wxZuI4GGCMMcZMHAcDjDHGmInjYIAxxhgzcRwMMMYYYyaOgwHGGGPMxHEFQsYY+0zlxoyLuT2TIs+OaBgcDDDG2GcoL2ZczI05Cnh2RMPg2wSMMfYZ+lxnXOTZEQ2DewYYY+wzZ8gZF3NrJkWeHdGwOBhgjLHPnKFnXOSZFPM/vk3AGGOMmTgOBhhjjDETx8EAY4wxZuI4GGCMMcZMHAcDjDHGmInjYIAxxhgzcTy0kDE94dKvjLH8ioMBxvSAS78yxvIzvk3AmB5w6VfGWH7GPQOM6RmXfmWM5TccDDCmZ1z6lTGW3/BtAsYYY8zEcTDAGGOMmTgOBhhjjDETx8EAY4wxZuI4GGCMMcZMHAcDjDHGmInjYIAxxhgzcRwMMMYYYyaOgwHGGGPMxHEwwBhjjJk4DgYYY4wxE8fBAGOMMWbiOBhgjDHGTBwHA4wxxpiJ42CAMcYYM3EcDDDGGGMmjoMBxhhjzMRxMMAYY4yZOA4GGGOMMRPHwQBjjDFm4jgYYIwxxkwcBwOMMcaYieNggDHGGDNxHAwwxhhjJo6DAcYYY8zEcTDAGGOMmTjLvF4BxhjTFyJCcnKy3panvCx9LtfGxgZmZmZ6Wx5jOcXBAGPss0BEmDhxIqKjow2y/P79++ttWYGBgZg6dSoHBMxo8G0CxthnITk52WCBgL5FR0frtaeBsZzingHG2Gdn+fLlsLGxyfFyiAgpKSkAAGtr6xxfyScnJ+u1h4ExfeFggDH22bGxsYGtra1elmVnZ6eX5TBmzPg2AWOMMWbiOBhgjDHGTBwHA4wxxpiJ42CAMcYYM3EcDDDGGGMmjoMBxhhjzMRxMMAYY4yZOA4GGGOMMRPHwQBjjDFm4jgYYIwxxkwcBwOMMcaYieNggDHGGDNxHAwwxhhjJo6DAcYYY8zEcTDAGGOMmTgOBhhjjDETZ5nXK8AYY+zzQ0RITk7W2/KUl6XP5drY2MDMzExvy8uvOBhgjDGmV0SEiRMnIjo62iDL79+/v96WFRgYiKlTp5p8QMC3CRhjjOlVcnKywQIBfYuOjtZrT0N+xT0DjDHGDGb58uWwsbHJ8XKICCkpKQAAa2vrHF/JJycn67WHIb/jYIAxxpjB2NjYwNbWVi/LsrOz08tymDq+TcAYY4yZOA4GGGOMMRPHwQBjjDFm4jgYYIwxxkzcZ5lAqO9iF3nNUMU28hoX+2CMMePw2QUDhi52kdc+p6EwXOyDMcaMw2d3myA/FbswdVzsgzHGjMNn1zOgTF/FLvKavott5DUu9sEYY8blsw4G9FnsIq9xsQ3GGGOG8tndJmCMMcaYPBwMMMYYYyaOgwHGGGPMxHEwwBhjjJk4DgYYY4wxE8fBAGOMMWbiOBhgjDHGTBwHA4wxxpiJ42CAMcYYM3EcDDDGGGMmjoMBxhhjzMRxMMAYY4yZOA4GGGOMMRPHwQBjjDFm4jgYYIwxxkwcBwOMMcaYieNggDHGGDNxHAwwxhhjJo6DAcYYY8zEcTDAGGOMmTgOBhhjjDETx8EAY4wxZuIs83oFGGPsc0VESE5OFn7W9H8FGxsbmJmZ5cq6MaaMgwHGGDMAIsLEiRMRHR0t+Xr//v3VngsMDMTUqVM5IGC5jm8TMMaYASQnJ2sMBDSJjo6W7DFgzNC4Z4Axxgxs+fLlsLGxAREhJSUFAGBtbS30ACQnJ0v2FDCWWzgYYIwxA7OxsYGtrS0AwM7OLo/XhjF1HAww9plRTVrTRXaJbnJwUhxjxo+DAcY+I9klrekip93XnBTHmPHjBELGPiO6JK0ZGifFMWb8uGeAsc+UImlNF5oS3eTgpDjG8g8OBhj7TCknremCE90YMx18m4AxxhgzcRwMMMYYYyaOgwHGGGPMxHEwwBhjjJk4DgYYY4wxE8fBAGOMMWbiOBhgjDHGTBwHA4wxxpiJ42CAMcYYM3FcgZAxxli+wjNz6h8HA4wxxvINnpnTMDgYYIyxfCi7q2Ntr3zz21WtMc/MmZO5QPIaBwOMMZbPyL06zurKNz9f1fLMnPrDwQBjjOUz+rw6zs9XtTwzp/5wMMAYY/mYpqvj7K58P6erWpZzHAwwxlg+ltXVMV/5Mm1xnQHGGGPMxHEwwBhjjJk4DgYYY4wxE8fBAGOMMWbiOBhgjDHGTBwHA4wxxpiJ42CAMcYYM3EcDDDGGGMmjosOMSaT1AQx2U0Kk98mg2GMmRYOBhiTQZsJYqRKvObnyWAYY58/vk3AmAy6ThCjmAyGMcaMEfcMMKYj5QliNE0Kw5PBMMbyAw4GGNOR6gQxPCkMYyy/4tsEjDHGmInjYIAxxhgzcXybgOmN1JA7KdkNw5PCQ/MYY8xwOBhgeqHNkDsp2ibX8dA8xhgzHL5NwPRC1yF32uKheYwxZjjcM8D0TnnInRRNw/Ck8NA8xhgzPA4GmN6pDrmTwsPwGGPMePBtAsYYY8zEcTDAGGOMmTgOBhhjjDETx8EAY4wxZuI4GGCMMcZMHAcDjDHGmInjYIAxxhgzcRwMMMYYYyaOgwHGGGPMxHEwwBhjjJk4DgYYY4wxE8fBAGOMMWbi8nyiIiLS69S0yssyxJS3NjY2Wc6yxxhjjOU3eRoMEBEmTpyI6OhogyzfEFPfBgYGYurUqRwQMMYY+2zk6W2C5ORkgwUChhIdHW2QHgfGGGMsr+T5bQKF5cuXw8bGJsfLISKkpKQAAKytrfV2BZ+cnGyQngbGGGMsrxlNMGBjYwNbW1u9LMvOzk4vy2GMMcZMAY8mYIwxxkwcBwOMMcaYieNggDHGGDNxHAwwxhhjJo6DAcYYY8zEcTDAGGOMmTgOBhhjjDETx8EAY4wxZuKMpugQY4yx/El1wrnsJozjCd+MDwcDjDHGdJbdhHNSZdx5wjfjw7cJGGOM6UyXCed4wjfjwz0DjDHG9EIx4ZymCeN4wjfjxcEAY4wxvVCecI4njMtf+DYBY4wxZuI4GGCMMcZMHAcDjDHGmInjYIAxxhgzcRwMMMYYYyaOgwHGGGPMxHEwwBhjjJk4DgYYY4wxE8fBAGOMMWbiOBhgjDHGTBwHA4wxxpiJ42CAMcYYM3EcDDDGGGMmjoMBxhhjzMRxMMAYY4yZOA4GGGOMMRPHwQBjjDFm4jgYYIwxxkwcBwOMMcaYieNggDHGGDNxlnm9Aoyx/I+IkJycLHpO+WfV1wDAxsYGZmZmBl83xlj2OBhgjOUIEWHixImIjo7W2KZ///5qzwUGBmLq1KkcEDBmBPg2AWMsR5KTk7MMBDSJjo6W7DFgjOU+7hlgjOnN8uXLYWNjAyCzxyAlJQUAYG1tLfQAJCcnS/YUMMbyDgcDjDG9sbGxga2trfCznZ1dHq4NY0xbfJuAMcYYM3EcDDDGGGMmjoMBxhhjzMRxMMAYY4yZOA4GGGOMMRP32Y0mkKqEpg/ZVVPLKa7GxhhjLK98VsGANpXQ9MEQY6S5GhtjjLG88lkFA7pWQjMGimpsymO0P3fa9OLI7ZHhHhbGGJPvswoGlClXQtMHTdXUcspUq7Hp0oujzXbiHhbGGJPvsw0GVCuh6QNXU9MfQ/XimGIPC2OM5dRnGwyw/COrXhxte2RMtYeFMcb0gYMBluey68XhHhnGGDMsDgYYywe0HTKr6xBYTrxkzLRxMMCYkdN1yKyc2yaceMmYaeMKhIwZudwYMqtIvGSMmSbuGWAsH8luyKzcIbCceMkYAzgYYCxf0WbILCdcMsbk4tsEjDHGmInjYIAxxhgzcRwMMMYYYyaOgwHGGGPMxHEwwBhjjJk4DgYYY4wxE8fBAGOMMWbiOBhgjDHGTBwXHWKMsc+c1ERX2U1qxZNXmRYOBhhj7DOmzURXUiWpefIq08LBgJ5pO9Wsgq5Tzipw9M4Yy4quE10pJq/Krvw1+zxwMKBHuk41q6DLhDEcvTPGtKU80ZWmSa148irTxMGAHuXGVLOqOHpnjGlLdaIrntSKKXAwYCDZTTWrIBWdKz+nSXJyMoYMGSL8Pzt8O4ExxpgmHAwYiDZTzSooR+e63GrQpkuPbycwxhjThOsMGBlD3WpQ3E5gjDHGVHHPgBHL6laDpuQfVZwMxBhjLDscDBix7G41cPIPY4zpn7ZDxHUdGm6MOVwcDDDGGGP/n65DxOX0wBpjDhfnDDDGGGP/X24METfGHC7uGWCMMcYkZDdEXNvcLQVjzuHiYIAxxhiToM0Q8c8ld4tvEzDGGGMmjoMBxhhjzMRxMMAYY4yZOA4GGGOMMRPHCYSMMcaMlmoBoOwK/RhjQZ/8gIMBxhhjRim7AkBSw/SMsaBPfsDBAGPMqBmqNCxfQRo/XQoAKQr6aDtrLMvEwQBjJkLqpGrsXa6GLA3LV5D5i6IAkKZCP8Zc0Cc/4GBAR3IPrHl9UGWmTZuTqjF2uRqyNCxfQeYvygWAPpdCP8YkXwUD2XUXattNmNMTsy4H1rw+qDLTputJ1ZhOmPoqDctXkIypyzfBgNzuwqx29pyemPk+FjOU3OjKVz6p5qcuV1MqDctYbss3wYA+uwv1eWLO7sBq6IOqvnpLAL6Vkddyqytf9aTKJ1DGWL4JBpRp6i7MrpvQECfmvDyw6rO3BOBbGXntc+jKZ4zlT/kyGMiqu1D5ZJzVVbMxZk7Lpe/kKj6pGI/82pVvDIwlt4iZtvyWZJ4vgwFtmFqxCm17SwAIPyskJydjyJAhwv9V5fWXFDC92yHcla8bffaWlSxZEuPHj1f7ruSH7w/TjqFO2PkxyfyzDQZMLclPm96S/Dq8TN+3Q/gg//nSZ2/Z3bt38fXXX6s9n9f7A9MPQ56w8+P557MNBpRxsYpM+fWetL5vh2g6yK9bty5fBoJMmja9ZUSEb775RtZy83p/YPqRWyfsvE4y15ZJBANcrEJdfr0nbagDPPv8aNNblpSUJDzHFw2my5An7Pxyy8+MiCiv3lz5fk12XbRy2vKyP691ycmyVZ/ParQJb0PTWrYxrUt+XbYxrYupLNtQ8jQYYIwxxljeM8/rFWCMMcZY3uJggDHGGDNxHAwwxhhjJo6DAcYYY8zEcTDAGGOMmTgOBhhjjDETx8EAY4wxZuI4GGCMMcZMHAcDjDHGmInjYIAxxhgzcRwMMMYYYyaOgwHGGGPMxHEwwBhjjJk4DgYYY4wxE8fBAGOMMWbiOBhgjDHGTBwHA4wxxpiJ42CAMcYYM3EcDDDGGGMmjoMBxhhjzMRxMMAYY4yZOA4GGGOMMRPHwQBjjDFm4jgYYIwxxkwcBwOMaSEjIwMXLlzA7t27ceHCBaSnpxvkfeLj4w2yXMb0Lbf2CWOxefPmvF4FgzIjIsqrN//ll1/w448/GmTZFStWxJUrVwyyLvHx8fDx8dFxzfRryJAhWLRokdbt5WwXbbZJRkYGlixZgu3bt+Ply5eIiorCyZMnER8fj65du4raJiYmYtKkSdi+fTtevXqFd+/eITIyErdu3cKwYcNkr8umTZu0+hyq6wEAJUuWhJmZmdrzNjY28Pb2Rtu2bdG/f39YWFjg9u3baN26NRITE+Hj44NHjx7B3t4e4eHhKFOmjFbroC1nZ2e8e/dO723l0uZ7omn7K7ZhlSpVYGlpif379+PWrVuoXr066tatix9//BGRkZEoU6YMFi5ciCJFimT5PnK/42fPnkWtWrW0bs/kk7tPWFlZZbu/TZgwAQ4ODrLXRc6+rKxcuXKIiorS+n3k7G+tW7fG3r17tV62UXxnKQ8VLFjQYO0LFChgsGXLXe/szJo1S+fflbsucraLNsseOXIkffnll7R//35h2TExMVS+fHm1tr169aJu3bpRVFSU0PbJkycUGBio07rUr19feNSrV48sLS3J19eXatasSb6+vmRlZUUhISGSy/v555+pUqVKtHLlSoqMjKQVK1ZQ5cqVacaMGbR06VIKDAykkSNHCu8ze/ZsysjIEH5/7ty5VK9evSzXOTk5mU6cOEGbN28mIqJ3797Ru3fvsvwdR0fHLF/XtS2R/vefkJAQsra2pqJFi1LNmjWpaNGiZG1tTbVr1yZvb2/y9fWlvn37UrFixahnz54UEBBAHTp0oEaNGtHvv/9OTZo0oY4dO+p1vbNr/+nTJ4qKipJ8LSoqihITE2W917Nnz0Q/b968mYYOHUpLly6lpKQk0WuDBg0S/Xzq1Cn63//+J7ncMWPG0JkzZ2Sti5TmzZtLPt+qVascLVfuPvHbb79R06ZN6ciRIxQdHU2HDx+mZs2a0fz58ykyMpJq165Nffr00Wld5OzLypycnGS9j5z9zZDnNkPJ02BA7glb3ycyXZctd72VZWRk0IkTJ0TPyf1SKsvrgMrDw4Pevn2r1t7FxUWtrbu7u3CAVF4PqbZy12XgwIH022+/iZ5btGgRDRw4ULJ96dKl1Q7kT58+paCgICIiunv3Lnl7ewvrmpaWJmqblpaW5Tr9/fffVLRoUapSpYpwEImIiKD27dtn+TnKli2b5evK5AYD+t5/Bg4cSH/88YfoucWLFwsnvVmzZpGVlRXFx8cTEdHDhw/J3NycXr16RUREb968oUKFCullXZRl9TknTJggeWIgIho9ejRNnDhR9Fzfvn01Luvhw4dUokQJ4eeffvqJgoKCaOzYsVSnTh0qW7YsxcbGCq+r7udNmzalQ4cOSS778OHD1LRpU7XnNR0rNG0jQ7WXu08EBASoBcJv374lf39/Isrc9woXLkxRUVH0yy+/SC5j9uzZdP36dbXn5ezLyuTuP5qOJVIMef4xFMvc7IVYt26dco8EUlNTRc/17Nkzy9+X6gpSaNCggej1Dx8+4MsvvxR+Pnr0qN7WJav1yE5KSgoaNGggur9GMu7UTJ06VfRzUlKS6LmJEyeKXpezXXTZJjY2NkhLSwPwf9vl2bNncHNzU2tboEABvHjxQnSL5cGDB/D09FRrK3ddNm/ejFevXomeGzBgAAoVKoTFixerLf+///6DpaX4629hYYH//vsPAFCsWDGhS9Df3x/79+9HmzZthLYHDhyAv7+/2nIVBg4ciN9++w2tW7dGwYIFAQD16tVDr169NP4OAFy/fj3L15W9f/9e67aAfvcfIHObq3bf9+/fH25ubvjjjz8wYsQIjBkzBt7e3gAyt6OTkxNcXV0BZH4fkpOT1ZYr9zseFxcn/J8yL3Dw6NEjYb8qWrSo8Pq2bdtw8uRJyW0wYsQI1K1bF1OmTBGeu3HjBvr374/ly5eL2kZHR6NRo0bo3Lmz8NySJUtw4sQJ4f3mzZuHunXrIjIyEkFBQWr7+dWrV9GoUSPJdfnyyy/RrVs3teeljhWfPn1S+9t+8803AIDk5GTh/wqxsbEICgqSfF9tly93n/j48SNevXoFJycn4blXr17h48ePAIBChQohKSkJkydPFm1TZcWLF8ekSZOwY8cO0fNy9mVlN2/elHwfIHM7vH//Hs7OzsJziuPIu3fv4OTkJNomvXv3Fv386dMn9OnTR/h51apVouXL+c7mllwNBo4dOyb6OTU1VXjOzMxM7QAfEBAg2sDv3r1DsWLFQEQwMzPDgwcPhNcmT54s/J+I0KpVK0yaNEkv62Jubq62M1hYWAjroZo4o3zSUpWSkiL5nOoBUJXiAKi6syq+SJrI2S5y/z4A8PXXX6NTp06YPn06iAhXrlzBuHHjRDuCwvfff48WLVpgzJgxSE9PR3h4OGbMmCGZLyB3Xfz8/LBy5UrRgW/NmjUad6rOnTujSZMmGD58OHx8fPD48WMsWLAAXbp0Ed6/ZMmSAICFCxeiTZs2qFChAooWLYrY2Fhcu3YN4eHhkssGgPv376NVq1bC+gKAtbW16O+/d+9eHDx4UDJYGTRoEFq2bIkWLVoAAE6fPo0///wTs2bNUms7duxYtGzZUu2eoyH3HyDzgLV+/XpRgLNhwwb4+voCyAxWVPcbc/Psc5blfsdDQkJgZmYmtHn//j1CQkIkP+eTJ09QuHBhyeW4u7vj6dOnouciIiIQGhoqCgiuXLmCJk2aYOjQoRg/frzQ9vXr10LgA2QGF0WKFMGXX36JvXv3qm2LDx8+qJ1wFN6/f49Pnz4JPyvuiycmJqJUqVKiti9evBCdlAGI1kP5/2ZmZqhcuTI6dOggai93+XL3iW+//Rb169dHv379hP1t5cqVGDJkCADgzz//ROXKlXH+/Hls2bJFchmtWrXCd999p/a8Nvuyj48PZs+ejVGjRgm/p/iezpkzB82aNUPZsmWF1+bNm4eoqCisWbNG7f2+//57lC9fHsOHDxeeq1+/vqjN1q1bERISIvk5AHnf2Vxj+M4HzbLrSomJiREeDx8+JGdnZ9FzOVl2Ttpn16Vjbm5OISEhFBoaqvZo0qQJmZubi9pbWVnRwIEDs3zoY73lttembXp6Ov3yyy8UFBRE9vb2VKpUKZo1a5ZaF6LCtm3bKDQ0lMqUKUNNmjQR7qfndF0uXrxIvr6+VKxYMapXrx4VK1aMfH196eLFi5Lt09LS6Ndff6X69etTUFAQ1a9fn3799VdKTU0lIqL3798Ltz+IiF69ekXr16+nn3/+mdavX08vX77Mcn3q1atHu3fvFq17eHg4NWzYUGhTt25dOn/+vOTvX7hwgerWrSv8rEuXsqH3n/Pnz5O3tzeVKFGCQkJCqHjx4uTt7S18puPHj5OZmRlZWVkJD+WfLS0t1fYFXddFWVb7p5+fn2RXM1FmzkDRokXVnk9ISKAaNWpQv3796OTJk1SwYEG1W1JERJUrV6Zz586pPR8eHk6FChUiKysr0fMNGjSgRYsWSa7L77//TvXr1xd+Pn78OB07dozs7Ozo+PHjwuPEiRN069YtjZ/3+PHjGl9TbSd3+XL3ib1791KvXr0oNDSUevXqRXv37lVr4+DgQJ8+fZL8/Y8fP0p27WuzL7du3Zq2b98uudxdu3ap3b4rV66cxn0kJiaGgoODs/ys+fE2Qb7KGTBkAqE+76eWLVtW44E7MTGRzMzMRM/lJGfAkJ9T319Q1YQqObRZl5SUFDpx4gRt2bKFTpw4QSkpKTq/X05du3aNvL29qWnTpmRjY0Nt2rShokWLipLXsrtfrvy6h4eHKFlLWUZGBhUpUiTbdTLE/pOcnEzHjx+nLVu20PHjxyk5OVn0unLwoemhr3VRyOpzjho1imrWrKl2j/n58+dUp04d+vHHHyV/7+3bt1SjRg2ysbGhdevWSbZZs2YNLV26VPK1w4cPU4MGDUTPnThxghwcHGjEiBF04sQJio6OphMnTtCIESPI0dGRTp48qbac9PR00c/JyclZfs+3bt0qnMxv375NDRo0oEaNGtHt27cl28tdvr5Vq1ZN4wXC5s2bqVq1ajot19vbWwgOVKWmpqrlFGSXx+Ts7Jzl64Y8txlKngYDLVu2lNVezgbetGmTwdYlu/WYPHkybdy4UfK11NRU6tWrl+g5uYksygYPHiyrvZztos02KVGiBE2YMEHj1ZYyZ2dn6t69O+3fv1/2AUabdZGTvZ+enk6///47NWjQQIjyT5w4Ifl3i4mJoV69elGlSpWoZMmSokdWPnz4QFu2bKFffvmFNm7cKOppIMr8Hmm6mnr58qXoe+bo6Kj2+wpv377VKqA0xP6Tnp5O58+fp127dtH58+c19gjlhNzveFafMzExkRo3bkwODg7UoEED6tKlCzVo0IAcHByoSZMmaqMJSpQoIfytvb29yd7eXvhZ8VpOHDt2jGrWrEnm5uZkZmZG5ubmVLNmTTp27Jhk+x9//JEuXbpERET79u0jOzs7cnBwoH379km2DwgIoOfPnxMRUbNmzWj06NE0bdo0jaNstF2+3H0iJSWFpkyZQkFBQeTs7ExBQUE0ZcoUteBx165d5OLiQr/++ivFxsZScnIyxcbG0q+//koFCxak8PBwyeWvXbuWQkNDqXz58hQaGkpr164VvS63x8HT05MePnwo2f7Bgwfk4eEh+ZrCTz/9lOXrqky+Z0Cu06dP6/R7r1+/1ut6xMXF6XV5crJU9Ukf2+X48eM0ePBgKlKkCJUpU4amTJmi8aojJiaGfvnlF6pSpQoVLFiQevfuTREREXo5gcjN3pcaEvnw4UPJIZE1atSgnj170oEDB0RdqFl1waoOI1P49ttvhf+3atVKLXtdYfLkyaIASE6Xsia67j+a3Lp1i0qWLEk+Pj5Uo0YN8vb2ppIlS9KNGzf0+j6GEBERQaNHj6Z+/frR6NGjKTIyUrKd6t9b6qFw+vRpnYcKfvz4keLj4+njx49ZrreHh4dwUqtcuTLt2bOHjh8/rnEUiiJI/PDhAxUoUIBSUlIoPT1d48lH2+XL3SeGDh1KtWvXpsjISLp9+zZFRkZS3bp1aejQoWpt161bR97e3mRubi4ESd7e3rR+/XrJZU+dOpVKlSpFS5cupYiICFq6dCkFBQXR1KlThTZyexy++eYbatWqlVqwkpSURG3btqUBAwZILis/y9OiQzlx/fp1BAcHa3w9JSUFe/fuxfr163Ho0CEkJiaqtXn//j3Onz+Ply9fwt3dHdWqVRMl81StWhWXLl0CAIwaNQqzZ8/Wat0SExNx//59yfW7fv06SpQoAVtbW+G5s2fPZrtM5eSwe/fu4dixY3j58iUKFSqE+vXrC8lu2cluu2S3TTTJyMjAsWPHsH37duzevRuenp5ZFq158OABtm3bhi1btuDJkydC5q+uqlatigkTJgjZ+2/evEFiYiKKFSumlhQGAJ6enoiOjoazs7PQHsjMcE9ISBC1dXZ2RkJCglbJb8q/I5XB7OrqitevXwMArl27hrp166Jhw4Zo27YtPDw88OzZM+zZswdHjhzB6dOnhe/QyZMn0bx5cwwYMABt2rQRtV22bBkOHDiAunXrar1+ynRJTgQyRyC0aNECP/zwg5AcN2/ePOzZswcnTpzQaV2UvX37FgcPHsTTp0/h6emJZs2awcXFJcfL1SQtLQ3NmzfHoUOHhOeyS+w1MzPDhAkTAAChoaH44Ycf0LhxY7V2R44cwezZsxERESF6noiwf/9+nDlzBm/evEHBggVRp04dtGjRQnL0h4uLC96+fYtnz56hYsWKePbsGQDN37egoCCsWbMGN2/exK5du7B//368f/8e/v7+aqNv5Cxf7j7h7e2N69evCyNrgMyEy+DgYDx58kStPREhOjoar169gpubGwIDAzWOhvH398epU6eEhEAAePToEWrXri1k7e/evRu9e/fGtGnT1PafSZMmYfXq1aIkydevXyMkJASvX79G06ZNhfaHDh2Cm5sbjh8/LnyW69ev4+DBg6LkRAWp5ESSGKmgIDVSIdfkVtTx/v17GjBgAJUvX566dOmidvWYXUIGEdHjx49p9uzZVL58eXJwcJBsc+zYMerbty+5uLiQubk5DR48WDIB5ueffyYHBweysrIiDw8PsrKyIgcHB5o5c6bQxtXVlRISEohI3n19uWOZ/f39s3wEBAQQUWaX7MCBA8nCwoICAgKoRo0aFBAQQBYWFvTNN9+o3e+Tu1202SZZefjwIf30009Uvnx5cnd319guIyODjh07RgMHDiR3d3eqWLGi6HVnZ2fq3bu3xq5SKQULFhTuqSvuv6WlpZGrq6tkez8/P2G8u6L906dPqVixYmptO3bsqFYbQpMZM2bQjBkzyNbWVvi/4tG/f38qV66cqP2tW7eoS5cuVKRIEbK0tKQiRYpQly5d6NatW2p/Tzldynv27NHY4zRw4EDav3+/8LMuyYlEutVf0NZff/1FBQoUoLp161KXLl2oTp06VLBgQfrrr7+0XkZqair17t1b6/ZJSUlqCY2aEnr79etHbm5uovZy8zo+ffpEtWvXJkdHR6pfvz517tyZQkJCyNHRkWrXri3ZrV2nTh366aefaNCgQUKRnidPnpCnp6fk++7bt488PDyoaNGiQjLtpk2bNP5NtV2+nH2CiMjX15eePHkieu7x48eS4/9VRUZG0ty5czX2bCnXOlF48+aN2vZW7XEwNzcnHx8fjT0OiYmJtGTJEgoLC6NGjRpRWFgYLV26lBITE0U5J+3bt5eVnDhnzhz6+uuvJdv36tWL5s2bJ/maoeVaMNCnTx/q0KEDHTp0iMaNG0dubm508OBB4XVN983fv39Pq1evpoYNG5KFhQWZm5vTzJkz6c2bN0KbqKgoGj16NPn6+pKTkxN1796d9u7dS4ULFxbulyn7448/yMfHh/bs2SMccNPT0yk8PJx8fX3p999/J6LM+2dOTk5UsmRJsrCwULs3pukeWWBgoOT7EmUmKpUqVUrr7aZs6tSpFBwcTFeuXBE9/++//1JwcLCoW0zudtF2m6iKi4ujOXPmUNWqVcnV1ZX69OlDkZGRkl3/J0+epCFDhpCHhweVLVuWpk6dStHR0WrtbG1tadCgQeTm5kZFixalMWPGZJkxTaRd9r6yiRMnUsOGDencuXNUoEAB+vfff6l58+Y0ffp0tbbdunUjBwcHat26NfXv31/0UNWrVy/q1asXWVlZCf/v1asX9e7dm0aPHi36vKtXr9b4eZKSkqhNmzbCz8rd2FJdysq3H4jkjVTQNTmxUqVKavdw9+7dqxbc6SIwMFBt2Xv27JG170id3HPaPi0tjVasWEHFihWjWrVqif4ucvM6Jk2aRNWrV6enT5+Knn/69CnVrFlT8hbSnTt3qHPnztSjRw/hhLRjxw6NiY9SUlJSNObsaLt8OfsEUeb+FhwcTGvWrKGjR4/SmjVrqFy5cmqfMSwsjFauXCn8PH36dLK2tqYqVaqQvb296DWFwYMHU4MGDejEiRP04MEDOn78ODVs2FCUa/Lvv/8SUeb3+datW3T69Gm6deuW8L1XLXSUVbGpmJgYUbEpucmJOR2pYCi5Fgx4eHjQhw8fhJ/Pnj1LHh4etGXLFiJSDwb27dtHYWFhZGdnRyVKlKBx48bRtWvXyMPDQ+1EZmZmRm5ubrR69WpRApBUW6LMilVSmbpEmScs5fK4cXFxdOrUKbUhN1ndI8uqFyEjI0PrXoaUlBTavXu3EFkGBATQtWvXJNtevXpVqOalIGe7yNkmyhRJgXv37s02KVD575gVxfZJSUmhXbt2Ubt27cjGxoaqVKlCv/76K7148ULtd7TJ3lcmZ0jk5MmTNT40UU1gkuLh4UFr1qxRe/7jx4/UsGFDUZKXm5ub5NV7eno6de/encqUKSN6Xs5IBV2TExXD7OrXr089e/akkJAQKliwoHDFqJx8l9VDSsGCBdUOsKmpqWpZ1w0aNND4qFevnt6CAeUgoG7dupI9FHLzOsqVK6cxYDt//rxaL5Kunj9/Tn/++SetW7eO1q5dKzxyQu4+kZGRQcuWLaOGDRtS6dKlqWHDhrRs2TK13i9vb29h/05NTSVXV1fauXMnEWUGxFInyqSkJBo7diwVL15cOF+MHTtWdMwrXLiw2kWUwtixY8nLy0v0nGIoqarbt2+Tj4+PqOdXbnJiTkcqGEquBQMFCxZUS465fv06+fj40OLFi9UOOIoTmSJYUJA6kc2YMYPKli1L9vb21KFDB9qxYwclJiaSp6enZDBgb2+vsUs9LS2N7Ozs1J4/deqUVp+TSLexzKrvNWDAAHJzc6MiRYrQmDFjdFpvOdtFl21CRLJruWtD6uTz+vVrWrx4MdWuXZtsbGwkfy+77H2FtLQ06tGjR46GOmanSZMmtG7dOnr//r3GNorgVjkgUIxpb9asmWjbHjlyRC0gSElJobZt29IXX3yhFiDJGamgS3JiRkYG3bt3j54/f65xrLk2yXeaEs4mTJhA48ePFxK4kpOTacKECWpXko6OjjR79mzasmWL2mPdunVqJ/d+/fqpXckqHr1791Zrn5aWRsuXLyd/f38KCQmhI0eOSK4vkfyhgs7OzmoJagrJyckae0v37NlDo0aNoj59+lDv3r2Fh5Tt27eTo6Mj1axZk6ytrYV/mzRpovFzyFm+NtLS0qhevXpa7W/K+/6FCxfIyclJdFxSPZFquy9v2LCBihQpohYQDBkyhAICAujevXui55VrSyhcvnyZ3N3dadq0aaK2cpMTczpSwVByLRho2LCh0I2r7N69exQQEKC2E27cuJGaN29OVlZWVKVKFZozZw7FxsZqPMETEf3zzz80YsQI8vLyIicnJ7K2thaiSmX+/v5ZXmH7+fmJnnv9+jWtXLmSRowYQQMGDKBp06ZpzD4m0m0s8+3bt2ncuHHk7+9P9vb21L59e3J2dqbHjx8LbYKCgjTeNzt58qTGLlRttoucbbJt2zbh/xs3btT4IMqsJ66geg9d+aEsu6GWDx48UHtOm+x9Zd7e3rKGN2Y3dEnV6tWrqUmTJuTk5EQdO3ak8PBwyfdTDgieP39O5cuXp06dOkl2OyoHBJ8+faJGjRpR3bp1JYMeOSMVdBnvTpR1AKkL5Z6EEiVKkKWlJdnZ2VHRokXJ3t6eLC0t1XoSQkJCNA6DTEpKUqvpkdUVrdSVrb+/P7m5udH06dPpzJkzkg9lcvI6srsClHp97Nix5OfnR2PGjCF7e3saM2YM+fr60vDhwyWXUapUKeF2rCIA3LFjh8ZseDnLl7NPBAQEiHqGNSlVqhTdvHmTiDJvEShPtPT27Vtyc3NT+x1t92XlgCAjI4N69uxJpUuXFubOUKVtsSm5wyGNdaRCrgUD58+fp4iICMnXHj16RFOmTJF87b///qOFCxdStWrVyNzcnCwsLGjBggVZfrHS09MpMjKSevToQU5OTlS8eHHR61OnTqVy5cqpdSFfu3aNypUrJ1qX48ePU6FChahx48bUqFEjsrKyoh49elCtWrWoZs2akoGJ3LHMX3zxBdnY2FDLli1p/fr1wtWkai/I77//Tr6+vrR//37hXldGRgbt27cvy/v62mwXOdukWbNmwv+VZw5UfigKrCgnsSnfQ1d9KNM2YVGZ3AlZlixZQoMGDdIYWCrTZuiSJs+ePaNFixZR7dq1yc3Njfr3709Hjx4VtYmKiiIPDw/y8fHReM9VQREQVKxYkZo3b67xiujq1avk7OxMX331Fa1du5YiIyNp7dq11K5dO3JxcVH7O8sd705E9OWXXwr3YrWR3RWnLj0JJ0+epL///lvy/TIyMtTaazqhazq5+/n5aZXcq0qboYJWVlYaeyn69etH1tbWar/j7e0tXMUqrpKjoqI05sYo7xeurq7CbTBN+4W2y5e7TyxatIjatm1LFy5coPj4eHr8+LHwULZkyRLy9vamLl26kIODgyjRdfv27fTll1+qLVvOvqwICEJDQ+mLL77ItmqiNsWmiOQlJ7569YqCg4PJy8uLevfuTWPGjKHevXuTt7c3lS9fXu9D4bWVr4YW3rlzBxs2bMCmTZvw4sULvH37NtvfSUxMRHh4uFCnGsgcBjdo0CCsWLEC/v7+wrCR2NhY9OnTB0uWLBGGzAQHB2PhwoVo2LAhgMxa5QsXLsTBgwcxe/ZsXLx4Edu3b5d878jISBw7dkwYHvPll1+iSZMmau0CAwPx9OlTtG3bFmFhYQgNDYWFhQU8PT1x9epVUS31WbNmYfr06UhLS0OhQoXw8uVLWFlZYcyYMRg3bpzW21J1u8jZJsZk5syZAIBp06YJQ7wUYmJicP78eVy7dk3t96ysrJCeng4zMzNh7gn6/3XBVeeP0GboUlbevn2LHTt2YP78+Xj+/Dk8PDyQmJiIkiVLCsu8ffs2rly5grCwMNGwomXLlok+JwCcOnUKZ8+exfDhw2FtbS08P3bsWNH73r59G1OnTsXRo0dF38GJEyeiVKlSwt/z0KFDwvfy06dPwhA3e3t7AMCQIUPUJiQCgO+++w5bt25F+/bt4ePjI1pv1XUZN24cNm7ciK5du2LhwoX4/vvvsWHDBnTo0AHz5s3Ldhvqi2K+Bk2HvZzWhScZQwWVJ0TSRHV+iIIFC+L169cwMzODp6cn7t27B3t7e7i4uEgOLSxfvjx27tyJkiVLok6dOujduzdcXV3x3XffIT4+Xq29tsuXu09oOnZIze1y4sQJXLp0CTVq1ECdOnWE5/fu3QtXV1fRc4B2+/KmTZuE9tu2bcOxY8fw008/iYaqdu3aVfi/Yq4G4P/2CeU5HoDM8xGQOVdFxYoVNQ6HVJ0TAcicfGvt2rVq54eePXvi7du3KFKkiOT2MqRcDQauXr2KqVOninaU2rVrY8KECahYsaLWy0lNTcXs2bNFB5w7d+7g2rVrKF68OCpVqgQg88szY8YMxMTE4Pnz52rLiY6OxvHjx/Hy5Uu4ubmhQYMGCAwMFLVxcXFBQkKC8MVIS0uDp6cnXrx4gU+fPsHLy0ttXHpWpMYyA8ClS5ewYcMGbN26FampqWjbti127tyJO3fuqE2s8u7dO5w9e1b4EtWsWVPj+Gu520WbbSLl06dPePXqleggKzVJUGpqKu7evavWtl69eqJ2r169woMHDxAUFAQnJyf8+eefiIyMRJkyZTBgwADh79G7d28AwMaNG0WzvJmZmaFw4cLo06eP2sQrQObMbZr4+fmJflauSaCQkJCAoKAgYRy2qsTEROzduxebNm3CyZMn0bRpU3Tr1g3NmjWDpaUl/vrrL7Rt2xY//vijxvUA/u9koPicmpiZmYlmRluzZo3GGRKTk5MRFhYmTCpTqFAhbN68WW18fEZGBr7++mtcvnwZN27cUFuOpnVSXRcA8PHxwYkTJ1C8eHGhlsP169cxbNgwHD58WGj37Nkz/PDDD7h58yaaNm2KCRMmoGfPnjh69CjKlSuHlStXaqypcf36dezatQvPnj3DH3/8gVu3biEpKUn43htaYmIiGjdujKtXr6JKlSrw8PDA06dP8c8//6BChQr466+/YGdnl6P3CAkJwfTp01G3bl20a9cOrq6ucHJywtGjR3H16lW19n/++SecnZ1Rt25dnD59Gj179sSHDx/w22+/ISwsTOfl67JPaEN1hkUpigBZQZt9uUGDBlku08zMTDQzpzZ1MhQTERUpUgSHDh1ChQoV1NqMGzcOa9aswePHj4Xn+vXrhxUrVkguMzY2Fo0aNcLdu3ezfX+9y60uiKioKLK3t6d27drRmjVrKCIiglavXk3t2rUje3t7unr1qtrv/PXXXzR79mzatWsXEWUmTC1cuJB8fX1FmbYrVqwgS0tLKly4MFlYWNDs2bOpWbNmFBgYSEuWLJGd5KbcjVuvXj1RctX8+fOFLO+kpCTZY6qzG76UlpZGf/75J3Xt2pUcHBzI19dX4y0UZampqbRq1SrRc/rcLqpd2wrXrl2jihUrirrHLCwsJBMOjx8/Th4eHuTp6UmWlpbk6elJVlZWVLp0aVG77du3k4ODAxUtWpTc3Nxo/vz55OXlRR07diQvLy8aNWqU2rJzmh2dFW2GLqlydnamhg0b0qpVqzSWRA4LCzPUKssaqSA3OVEXBQoUEG5tKUYWSY2sad26NfXq1YsOHDhAPXr0oC+++IKGDRtG169fp+HDh1Pjxo0ll7927Vry9vamkSNHCvfaL1++rLHsriHoMlRQ4ejRozRgwABq3bo1DRgwQOP+dv/+fbp//z4RZY7T7927N3Xo0CHbETra0nb5uuwT6enpdO7cOaF0tVS+iWr+hp2dndYjeJ4+fUqXL19W2/6GJjc5Uc5IhdyUa8FA586dsyzE07lzZ9Fz06dPJwcHB6pWrRo5ODjQ0KFDqWLFitSwYUO13APlJJk9e/aQubk5jRkzJsvkpujoaNq+fTtdvnxZeG7Pnj1UrVo1Kly4sPDcjRs3qESJElSoUCFyc3Oj4sWLC/dbr127pjFxRxM5Y58/fPhA69atExUIUQRIimRMRYDk4+OjNhRJ7nbRdpsoq1WrFk2aNIkSExOpQIEClJiYSKNGjaIlS5aota1QoQKtWLGCiP4vmWnBggU0adIkUbugoCBheNrhw4fJwsJCKFJ19+5d8vHxkVyXlJQUunHjBp08eZJOnDghPHJKdehS8eLF1YYuqdKUlKQsOTlZdKDYsGGDaOiX6v1m5SSpU6dOiT6jasKhnJEKRPKSE5VpexKrV6+ekIj41VdfUd++fWnYsGFq5Z9dXV2Fz/Lp0yeysrIS8iKSk5M1FpEqXry4UMNB8d1KTU2VTDgzFF2HCs6ePZs8PT1p/PjxtHTpUho/fjx5eXmpjX3XlvL9+KweOSF3n7hy5Yowk2jNmjWFGUaVjzVStLnYiomJoXr16pG1tTV5enqStbU11a1bN8tJsOLi4ig2NlZ4qHr8+LEoUfqbb74R5bk8evRI1F5OcqKckQq5KdeCAV9fX7UNqBAfH69WmMHPz4/++ecfIsrckczNzemPP/6Q/H3VqwtbW9ss693LvWJOTU2l69ev0/Xr1zUWl9CWVDAQEBCg8aGcpCQnQCKSt1107UVwcXERlqnYcZOTkyUrizk5OalVCUxPT1cLNFTXW7XapNRoA217HXLLb7/9pnag++eff0RJnrNmzaIRI0YIPzs4OAhTXZcrV0402cmiRYtEVcvs7e2pdOnSFBQURJ6enpKz5ckZqUCkfXKigpyTmLZXnJ6ensIB9OHDh2RmZiZUinz9+rXGAkiFCxcWPpfiu/Xp06dcHaal61BBT09PtYqst2/fFtY9qxE7qqN3iEhIADUzM9P4UD4GyV2+LipVqqSWib9o0aJsC1RpM5tfSEgI/fjjj8JY/0+fPtHo0aNFhbU2b94sOvna2dmRnZ0d2drakrW1NW3dulW0zG+//Va0rzo5OdFPP/1EP/30E/Xo0UNy9JKc5ERtRyrkplzLGXBycsL79++1fl21FraDgwM+fvwo+buqbZXrv0sJDAzEwoULERoair179+Krr77C6NGjMX36dK2T5A4dOoQGDRrAyspK7bX+/ftrrC2dlpaGtWvXipJmnJyc4OXlhe7du6NRo0aS61C9enX4+/tj165dqFy5Mi5cuIBatWph0aJFGDRokOR7ydkuum4Tf39/XL58Ga6urggODsb69etRqFAhlCtXTi2XIjAwEMeOHYOXlxe++OILzJo1C+7u7mjSpAlevHih9XpL1WGvWLEivvvuO/Tt21eYa2DhwoV48+YNJk+eLLSLj4+Hj4+Pxs+j7OTJk9m2Uc11UPD29kZ0dDQcHR2F596/f4+goCDh/mGFChUQHh6OgIAAABDNkRATE4O2bdsK8ztUq1YNq1evFmqcK7e9efMmevXqhYsXL6qtx/Xr19G4cWNYWlqiWbNmavdbAd2SEwHAy8sLx44dE+WUREdHo379+pLzQWhDkWhYt25d3LlzB1WrVsWtW7fQuXNnbNu2DX5+fpL3W7t16wYfHx/MnDkT7u7ueP36NcaPH4/4+HisWbNGp3WRS1HXX+7rfn5+uHnzJhwcHITn3r9/j+DgYMTGxmZ7vxtQv+cth5zl67pPuLi44PXr17CwsBCeS0tLg6urq2Tio0J2x3Ig83jw+vVrWFpaCs+lpqbC1dVVOKeEhIRg9uzZqFatGgDx/nPp0iWMGDECp06dEn6/ZMmSuHjxojD/gHL7hIQEVKtWTUgglJucqPDu3Ts0bdoU//77L5YvX44ePXpk+TkNLdeCAU0TaWh63cnJCXfu3BGSzMqWLYubN2+Kks68vLwAZGaqKn8R0tLShJ9JIkNc9b3s7Ozw4cMH0RdVQWoSDQCoXLkyDh06hEKFCgnroSA3SzgxMRF79uzBhg0bEBUVhfbt26Nbt2744osvRL8jJ0AC5G0XOdtE2axZs1C6dGm0bdsWy5cvx/Dhw2FhYYEBAwbgl19+EbVdvXo1PD09ERoaivDwcHTt2lVIBh02bJjQzsrKSnSAOn78OOrXry+s94kTJ9Qy/p2dnfH27VuYmZkJB5CMjAx4enqKkiSz+x4qMzc3h4+PDxwdHSWzz83MzHDz5k3J3y1UqBCePHkiOqEmJyfD09NTOLipHuh++OEHzJ07V/hZ+XV3d3dRwNSxY0fRKBbV15UTsbIbqSA3OVEhu5OYqhMnTuDq1av48OGD6HnVQGPnzp2IjY1Fhw4d4OHhgcmTJ+PatWuoUqUKRo8eLZmE9+bNG/To0QPHjx9HUlISnJycULNmTWzcuFE0OY4hWVtba0zaJCKsW7cOycnJaq8tWrQIf/75J8aOHQsfHx88evQIP//8M5o3b46vvvpKaKd6nJHj2bNnePr0Kby8vHKUqa7rPvHNN9+gSpUqou/lihUrcOnSJSxdulR4TnXStmbNmiEiIkL0XqqTZn311Vf45ptv0KxZM+G5iIgILFu2DLt27QKQmfCoHKBWr14dFy5cAJD5t/Hy8hK9rnqc2L17t+hvofy63OREOSMVclOuBQOqJyZlRISMjAzR1bLyEBEpykNSssomVVDOEJdzxSxnPRTkzkKo7OXLl9i6dSs2bdqEhIQE7Ny5E0FBQQDkBUiAvO0it3dFk9jYWHz48EE0S5cmKSkpSE5OhpOTk+j5tWvXZvu7X3/9tehnbXsdsuuhUtanTx9ERkYiJCQEPXr0QNOmTbXuOWrZsiWqV68uGu44ffp0nDlzBgcPHgSQuY1v376tNloEAP777z8EBQUJfwNnZ2fExcWhQIECam3fvHkDPz8/0d9Pl2Frcsk5iX333XfYtm0b6tevLwxZBDQHGrp6/vw54uLi4O3tnaOTpy503ebafKeUjzNyZnOMjY1Fz549cf78ebi5ueHVq1eoXr061q9frzZqRiGr5eu6TzRs2BAnT55E0aJF4ePjg/j4eDx69Aj16tUT/X52WfRSQz+7du2KXbt2oVatWvD19cWjR49w9uxZtG/fXghUV69ejYSEBFHgqvDhwwd4eHiIglTl0S+q7t27h5CQENEIATnkjFTITbkWDMg9YRuSnCvmgQMH4tatW1iwYIFoiJJiil6pKDsnY5lfvXqFLVu2YNOmTXj9+jV2794tBAO6BCbaktu7khPv3r1TuzrM6YFb214HJycntQBKlfKQyOTkZOzbtw8bN27E33//jbZt26JHjx5Cd6MmMTExaNGiBT58+AA/Pz/ExMTA2dkZ+/fvh7+/P4DMK5py5cpJTpM7efJk/Pvvv9izZw8AoHHjxmjdujW+++47tba///47du3ahSNHjmS5TllJTU0VbnmdPn0aGRkZwmu1atWSDOTlnMRcXV0RFRWldgWUnUePHuHQoUMgIjRq1EjYdsrevn2LmJgYlC5dGtbW1nj69CkuXryIsmXLokSJErLeTx8WLVqE2rVri44Xly9fxvnz5zF48OAcLfvw4cPo2LEjgoODhRPfjRs3sG3bNjRq1Eitff369VG9enVMnjwZdnZ2SExMxJQpU3D27FnJLn9tlq/LPqFNgA+oB/na0CYIW7FiBX7++WfJ7vpNmzbht99+w7lz54TnBg8ejPj4eOzYsUPUu5eSkoKwsDB4eHhg8eLFku/16NGjbIdYG6XcSEwgykyoyq7ak65UExN37dpF3bt3p27duokyQhViYmKyfSi7fPky1alTh/r37y98Bk2TIOni06dPtGnTJmrevDkVLVqURowYobGqmhxytovcbaLw77//ChPUWFlZkZWVFVlaWpKVlZVa28jISPLz81NLbspqdMXx48dp4cKFWZYvlpKcnCw5pM/MzExIHJJ6aJqDgSgzgW3EiBFkYWGhMWteWVpaGp05c4a2bt1KZ8+eVUvevHbtGjk7O1P79u1p3bp1dOjQIVq3bh116NCBnJ2dRcl1J0+eJAcHBxo5ciSdPHmS7ty5QydPnqSRI0dKlgyWM1JBl+REuUqXLq1VZTXliWhOnDhBLi4uFBoaSs2bNydnZ2e1ioh79+4lBwcHKly4MPn7+9Phw4epcOHCVKVKFXJycsqyapyheHl5qc1J8e7dO7XJcHQhdzZHJycntYTRlJQUjcmMcpcvd5/IK+Hh4VSgQAFatGgRxcXFUUpKCsXFxdGiRYvI1dVVrVS+okqgj48P9enTh8aOHUt9+vQhX19fCg4OFpJaieQnJ8odqZBbci0YqFevHtnY2FCLFi1o8+bN2Y5xV67Bn56eTvPmzaM6depQ7dq16ZdffhENj1POPl+yZAl5eXnRTz/9RL/88gv5+PhkW6ZXW6tXr6bAwECaN2+exumRdeHo6EiBgYE0efJkOnnyZLYlUrWVG9ulbNmyNH78eLp582a2wUNAQAAtW7ZM4wxfqoYMGUKFCxemTp06qU0HrKp///505MgRjVPxKmQ374GUZ8+e0YIFC6hKlSoUHBysNoW2Junp6XT+/HlhXLXUSI6bN29S586dqUiRIsJojrCwMLpx44Za26NHj1KNGjVEJYOrV68uOXmOnJEKVatWFU2spTyc68aNG1S1atVsP2t25s6dS/Xq1aNdu3Zl+d1W/vvUrl1blMW+ZcsWqlGjhqh92bJlhZE0+/btIwcHB6EE8alTp3SeLjwn3NzcJOvOa5MZnx1tZ3NUaNu2LR04cED03MGDB+mrr77K0fJ13Sfy0rp168jLy0tUE8XLy0uyHgdRZln5xYsXU1hYGDVq1Ig6depEixcvVjt+1atXjy5cuCD8rLz/XLx4kerUqSNqr8tIhdyQa8EAEVFsbCz99NNPVK5cOXJ2dqavv/6a/vrrL8kDuPKJbOrUqRQcHExbtmyhrVu3Uvny5UXFJ5QPIGXLlhX9Yf755x+16Xfl9iQoS0hIoGHDhlHFihX1VkNauf65YjihVP1zOQESkbztous2cXZ2zvYErODq6iprYpuCBQtqNV6fiGjKlClUtmxZKlKkCA0ePFhjfQFtp48mIlqzZg01adKEAgICaPTo0bIKu9y6dYtKlixJPj4+VKNGDfL29qaSJUtKnuTl0qbuffny5UUTOikfoB4+fEgVKlQQflad7rhDhw6in7ObDlkb2tb2V/77FCpUSHRiSktLUxt3rjyZT3p6OllaWmp8Pbe0aNFCrUb/tGnTKDQ0NMfL1mY2R+U5Drp06UI2NjbUoEED6tmzJzVo0IBsbGyoa9euOi0/J/uEMcjIyKCbN2/S6dOn6ebNm1ofu7KiOnxVeZbCjIwMtddLlCghOncof6ffvHmjcVpvQ8uzuQmuXr2KTZs2YfPmzcjIyECXLl0we/Zs4XXlRK/AwEDs2bNHuHd+9+5dhIaG4v79+wDEyW+qWdWqy1Jtv3TpUkydOhVDhw6Fubk5fv31V4wZMybH9/YMQXm9p02bhm3btmH8+PEwMzPDjBkz0K5dO1GCkpztous2GTx4MOrXr49OnTplu/7Tpk2DnZ0dRo4cqdXnLVOmDM6cOSMrG/z69evYtm0btm3bhg8fPqBDhw5YsGCB8LqcBEJzc3OUKlUKderU0Xh/XGqoHpCZYdyiRQv88MMPQubwvHnzsGfPHiGBSE6iqaZRLcqU8y7kjFSQm5xoSLa2tpg4cSKICAsWLMC9e/eE5LVPnz7B29tbGOIFAJUqVcIPP/yAzp07Y926dRg9ejT27NmDWrVq4fz58+jVqxdu376dK+uuoJovEhsbCycnJ1G+iBzK2edEhJiYGFhZWcHd3R0vX75ESkoKAgIChAx0be6hA/+XzChn+TnZJ/IT5eG2mihGwTg6OuL58+daJyfKGamQm/J0oqLk5GSEh4dj9OjRePz4MVJTU4XXlDeIYtIcZcoHdcVQNCLChQsXcP36dSFp4+XLlyhbtqxoeJny7wYHB2PVqlVC8svly5fRtWtX0QFEak6FOnXqYPz48bLmVMgpOQESIG+7yN0mCg0bNsTp06cRFBSklkypOv9CyZIlERMTA0dHR7i7u4tekxpKozh5Dhs2TG3ZmkZjKFy4cAHjxo3DsWPHdE6qnDx5ssZ6EQqaMvJdXV3x4sUL0dDM9PR0FCpUSDiZKeoLaKKcaCo3eVTOSAVDJycqvH37FhEREXjy5Am8vLzQrFkzUW17QH2Y47Bhw4Sa77t27cL8+fNF48GPHDmCjh074u3bt+jSpQs6duyIHj16oFy5crhx4wb++OMPyaQxQ0tPT8eFCxcQHx8PX19fVKtWLdthuppok30O6J6BLmf5OdkncltiYqIwDNXKykrjepNEgrSc4ba1atXCkCFDtE5ONORIhZzI9WCAiHD48GFs3LgR4eHh8Pf3R7du3dC1a1dRprGFhQWKFy8OIkJ8fDyuXr0qTDgTHx+PGjVqCLNuqWaq1q9fXxiZEBkZib/++gtz5swRXpdzxXz9+nVUr14doaGhaN26tTD5yL59+xAREYHz58+jXLlyet5K0uQESIC87SK3d0XTeyhTzQzO6qAjdSDTdLLUNBrjn3/+wbZt27B9+3aYm5ujU6dOCAsLk5xAxNAqV66MSZMmoU2bNsJz+/btw8SJE/Hvv/8a/P3ljFQ4deoUmjVrhkGDBgnf8WfPnmHv3r1YsmQJDhw4gLp160q+z8ePH3H//n210SGqwdrZs2fRqlUrBAYGws/PD3Fxcbh9+zb27duXbWCXnYyMDCQkJMDV1RUAcOvWLdy4cQMVK1bMk9EEuUVxYZKddevWYfPmzUIQ1qVLF/Ts2VNvy8/Kl19+mW0bXYslFS1aVDRDYosWLfDnn38KPysf0ww5mm3Pnj3o1asXpk+frrb/TJw4EStXrkTbtm2F9jkZqWBQuXU/4vz58zR06FDy8PCgokWL0o8//pjl/SbVOcyVk/WOHz9Oc+fO1XldLC0tqXHjxtSoUSNycnIS1aZ+8eKFqDyu3DkVDMnc3JxKlixJJUqUIFtbW6EWO1HmPX+pEsDakrNNjFGxYsWEkRgXL17M69URSozWr1+fevbsKYy40MdcCdqQM1KBSF5yosLatWvJ0dFRyOTXlAdARFSlShW1rOpt27bRF198oZ8PbCLevXtHvXr1Int7ezI3Nyd7e3vq3bs3JSQkSLafOnUqlSpVipYuXUoRERG0dOlSCgoKUstp0HX52TEzM6PAwECaOnUqbd26lbZs2aL20JVqMrBqkqMuycK6kpOcKGekQm7KtWDAxcWF+vTpQ0ePHtVL0oY2+vTpIznRypo1a0QP5cz3iIgI+uGHH4Sf5c6pYEj6CpCktoucbWKMlJMrjcWrV69o/fr19PPPP9P69esNNrRWEzkjFRS0SU5U8PT0FM10mJUCBQqojaaQSgjMitS8Hsp/94yMjGyTavO7Hj16UPv27Sk6OpqSkpIoOjqaOnbsSN27d5ds7+fnR3FxcaLn4uLiyNfXVy/Lz05sbCzNmjWLgoODqVq1arRw4UK9jcJSTQZWDQbkJAvrg5zkRG1HKuSmXLtNkJycDBsbG8nXIiIiMGvWLK3uXTVp0gRbt24VdV9pSvb4+eef8e2338LR0VGytro25M6pYEwMuV0MRTmxTeo+Hynd33v27Bk8PDwAZJ1gl9uV6PIbucmJys/FxcVprCyqrF69eggLC8O3334rPPfHH39g06ZNOH36tPCccrevqqSkJAQFBYkKIslNqs3vihQpgpiYGFFJ5o8fPyIgIAD//fefWntPT09ER0eLcjMSEhIQFBSkdptRl+XLcfXqVWzYsAE7duxA6dKl8ccff+iUUKmgyxwmTLPs92I9efPmDUaOHIkrV66gRIkS+PXXXxEXF4ehQ4fi1atXaslLyjWslZ09exZDhw6FnZ2dkLU6YcIEVKtWDaVLlxYlWKWmpuLBgwei8qdZ6du3L+bPny/acbJLlsnu9dwgFSAB+tkuUtvEkK5evSr8/969e1m2LVmypBCI+fj4SCbY5aQqo1yNGzfW6vugmlhpCHJGKmjadgqatuHUqVMxatQoTJo0SXIkgrIlS5agVatWmDt3rlDZDgD27t0raufv7w9bW9ss10WZcrsNGzaIkmorVaqE0NDQzyoYcHR0RFxcnGhyqPj4eNGEWMratWuHtm3bYvLkyfD19UVcXBymTZuG9u3b62X5cgQHB6N+/fqIj49HREQE3rx5k6NgIDExEU2aNBF+/vDhg/AzESEpKSmnq4wzZ86gdu3aas+fPXtW2H/kJifKGamQm3ItGBg4cCASExPx7bffYteuXWjRogU+ffqEKVOmoEuXLmqZths2bMAXX3yBxo0bi3Z4MzMzeHh4iL6cp0+fxogRI+Di4oIpU6YIJ66IiAj8+uuvahnVmv4YO3bsQJEiRURXzB8+fBAleSij/z+nQm6REyAB8raLnG0CAOXKlUNUVJRW6y0nQvf19QWQmY3ds2dPHDp0SGOPknKPTG79HbZs2YLOnTtLvta9e/ccL//Zs2c4e/YsAgMDs53fITk5GTdu3EBAQIBaINitW7csf1c5CVPOtlM+8BER0tPT8euvvwr7r9TBD8gcJnr79m2cP39emDCnevXqarN++vj4YPv27ahevbraeyclJakN31I+CL99+1YIBIDMYDGnV7PG5ocffsCXX36Jb775RkigW758OcaMGSPZft68eZg6dSr69OmDJ0+ewNvbG506dRLNmZGT5QNZ7xMAcO7cOSFQq169Orp27Yo1a9Zo3K+1pTp7pep3Xh/7Y7NmzSSPXS1bthR6IbK7aFGlzfwLeSHXbhO4u7vjwYMHcHJywps3b+Dm5obbt28LIwRUxcTEYMSIEQCAuXPnCpnlnp6euHr1qtoJnoiwbNkyLFy4EMOHD0e/fv3g7e2NK1euqLW1sLCQvGLeunUrWrduDXt7e2HYiDHNqWBvby8ZIM2ZMwcDBw6Eo6Oj2lWQtttFzjYB5N0e0fVWSrFixXDt2jWtrkoGDx6MP/74Q+35IUOGYNGiRbLfWxNdJ3CScu3aNfTu3Ru3b99G9erVMXXqVLRs2RLW1tZ48+YNVq1aJUxr+ujRIwwbNgy3b99GjRo18OOPP6Jx48aIj4+HnZ0ddu7cidDQUL2sV1a02R8A3feJjh07ol69epLDHFNSUhAYGIiHDx8Kz8kZdfS5+Ouvv7B161ZhdEBYWBgaN26s1i49PR29e/fG8uXLZZ14tV2+Qlb7RPHixWFlZYUuXbqgQ4cOkqMTdL2Nt2zZMoSGhmZb+1+5jkJWlIc3K26dlSpVCnfv3hUdE2NiYtCuXTvJ2yz5WZ5NYaw8P3RWIiMj8eOPP6Jly5YYN24cSpQoIXmCV3j16hXGjx+PS5cu4c6dO7h3755a23PnzmHEiBGoUaOG6IpZKtAgIrx//16ym/zdu3dwcnLKtUhOboCkLLvtImebAPKu9nW9d/f777/j8OHDGDNmDLy9vUXbWfUAouk99HnyBrT/3mbVFajoYalbty5atGiBsLAwbNy4EXPnzsW6devQqlUr/Pnnnxg1apQwHWzz5s1RrFgxtG/fHtu2bcO+ffswduxY9OrVC+vWrcOyZctw+fJl/XxImRTT43p6ego5HEBmN71iGGVWB2Tlg7DidoS2Y/JV84xKly4tfFdPnDiBf/75R9hnTJGPjw8ePnyo1gMjJT09HSVLlsStW7dkBQ9Z7RPKhYmUe5SUn9P1Nt7w4cMRGRkJMzMzNG3aFKGhoQgJCVFbd13qNGRV16NIkSKYOHEiBg0apNN6G6tcCwYUlcUUpk+fjvHjx4vaaLpPkpqainnz5mHVqlWIj4/Hw4cPszzxAcCVK1dw4sQJDBgwALa2tmqva3vFPHfuXERFRWHNmjVqy+jduzfKly+P4cOHZ7ku+iY3QFKW1XaR27uS3dWfasEcKYpuZakDgqYKZ8rtFSfdadOmqXV9xsTE4Pz587h27VqW65kV5ZndiEg4USt2m3r16kn+nmrRkufPn+P48eNo27YtNm3aBAAoUKAAEhISAGTOEuno6Ci6z6kc4Li6uuK///6DpaUlkpKS4OzsjKSkJJibm4OIUKBAAbx9+1bnz6mL7KbHPX36NOrUqQNAfo0JJi01NRWbNm3C1atX1Wo7SFX+W7p0Ka5evYrJkydrdXwoU6YMTp48iUKFCmlso+s+YSixsbGIiIhAREQEzp07h8qVKyM0NBShoaEae5611bRpU0RGRuppTY1brgUDvXr1yvIKWpt5zZ88eYJLly6hefPmkpHuq1evcOnSJaFYRtWqVeHm5pblMrO7Yi5fvjz27dsneeKLjY1Fy5Yttb53rk9yAiS520Wb3hUHB4dsi4Uo7vs6OjqKKiNKkZoKWhuKk+7GjRtF9wzNzMxQuHBh9OnTJ0cHhAYNGoh+Pn36NOrWrSsEMXIKphw+fBirV6/Gxo0bAcjLhjbGzGk50+Nu3rwZXbp0UVuG1P1mqYqftWvXxoQJE2RV/MzIyMCGDRu0KrCTX3Ts2BHR0dFo3ry5KOMfkK78Z2VlhfT0dJiZmYmudjVNST579mzs3r0bw4YNU+uNUyTMydknatasiWbNmqFZs2aoWrVqjj67NtLS0nDmzBkhOHj//j2qVauG4ODgbH9Xm6S9kydPwtLSMseFsoxRnpYj1kZUVJTaQUGq4t/YsWMxd+5cZGRkoFChQnj58iUsLCwwbNgw/PTTT9m+j6YrZuWrNykuLi65fkWmLLsAKSfbJatehNy4TSDHunXrcuWgn5PbDhkZGShYsKDwfcmqt4yIMH36dCQmJgIA7OzssGrVKuHqa8CAAVi6dKnQtn///vj06ZPOn0tVVsmJCs7Oznj9+rVoaGFqaipcXV3VckS0vY2jz4qfycnJsLe3z7XRJLmhQIECePz4sWQdfClZ5XhIXeDIrfoJZL1PXL16VTgx37lzByEhIQgNDUXTpk11vgBQiIuLyzJfYOvWrahfvz4GDx6s1Wio1atXqz0XEhKCmTNnonbt2vjpp5+wcOFCWFlZYeDAgTnO+NdmpEJuyrVg4Pr16zh48CBGjRql9tqcOXPQrFkzUfZ0eno6unfvjm3btqFo0aLCQSE+Ph4dOnTAxo0bhfuKa9euxdixY7FkyRI0b94cFhYWSE9Px4EDBzBo0CBMnz4dvXr1Untfba6Yvby8cPbsWckhMA8fPkStWrXw9OnTnG0cmbQNkHTZLtr2IuRGAqGmITs2Njbw9vZG27ZtMWHCBDg4OGDnzp0oXbo0ypQpI7S7ceMG7ty5I5oEJKe0DQZUh/YlJiZi27ZtuHz5Mi5dugQg+/rnwP8doOrXr59tbsqxY8eyfF3TSAVdkxO/+uorfPPNN2jWrJnwXEREBJYtW4Zdu3YB+L/t0LhxYxw+fFgtEWv06NHCMEMA6NKlC3x8fESTlin873//Q2xsLDZv3iw8J1VuWSE1NRUzZ878rIKBhg0b4vfffxeNmshr2u4THz58wJEjRxAREYFDhw7BxcVF6M6vXbu27LkbihcvjuPHjwsjkJStWLECo0aN0iq/Jytubm548eIFzM3NERAQgMjISDg6OqJ69ep49OiRTsmJCrmV56Q1/dYw0qx9+/a0fft2ydd27dpF7du3Fz03b948CgwMpCtXroiev3LlCpUuXZrmzZsnPFe3bl3auXOn5LJ37typNp80EdGYMWPI2tqaLC0tycPDgywtLcnGxoZGjx4tavfNN99Qq1atJOcnb9u2LQ0YMEDzh9aztLQ06ty5M5mbm5O/vz/VqFGD/Pz8yMLCgsLCwtQqvMndLtpuE6LMueK1pVoBTVu//fYbNW3alI4cOULR0dF0+PBhatasGc2fP58iIyOpdu3a1KdPHyLKrLSmWuHvxYsX5O/vr9N7a1K+fHmt2qlO1Vu2bFnq2rUr3b17V6/ro8nVq1epcuXKZG9vTw0aNKBTp06Ri4sLubu7k6WlJa1bt05o26xZM/r222/p6NGjNHDgQPL29qbff/+dPn78SIsXL6ZKlSpJvkdW0+MqptB1dHQkf39/4TurXLK4Ro0atGvXLtEy5Vb8tLKyoi5dutDAgQPVHv3791erWJjfPX36lKpVq0bff/89zZgxQ/SQEhMTQ7169aJKlSpRyZIlRY+svH37lh4/fix6aKLtPqHq9u3btGDBAgoNDaXZs2fL/v1Zs2ZRsWLF1I4vs2fPJjc3Nzp//rzk70VFRdGUKVNo8ODBRJQ53fjly5cl27q6ulJycjLduHGDSpUqRUSZlQYV1Q1Vq8JqeihTbE8HBwd68uSJaBufOXOGihQpIntb6EOuBQPe3t6iucmVpaamqu3kVatWpb/++kuy/V9//UVVqlQRfi5YsCC9e/dOsu27d+/USp6uWbOGvLy8aO/evcIJNC0tjfbu3Uve3t60evVqoa2ijrSXlxf17t2bxowZQ7179yZvb28qX768aF5qQ5MTIBHJ2y5ytkluCQgIUFv/t2/fCif4p0+fCnMmSJW7TU1NJRcXl1xZV2NTp04dmjVrFj148ICmTZtGBQoUoL179xIR0f79+6l06dJC24IFCwr7ZmJiIllZWQllfDMyMsjZ2VnyPSZPnqzVg4ioX79+Wq13dvXkVV+vXLky7du3T7JtYmIimZmZafW++UW/fv3Iw8ODwsLCqFevXsKjd+/eku1r1KhBPXv2pAMHDmR5glKIjIwkPz8/MjMzEz2MNahSDQjGjx9PHh4eGue9Wbt2LXl7e9PIkSOF7/Xly5cpJCREsn2XLl2oTZs2VKdOHZo0aRIREd24cSPbYCoriu2puo3NzMzIw8OD/vjjD52XnRO5Fgw4ODhorLv88eNHtZ3cxcVFY330jx8/iupOazpYKajWqJZ7xZyYmEhLliwR6kiHhYXR0qVLKTExMcv31Tc5ARKRvO2iS++KoRUuXJgePnwoeu7Bgwfk7u5ORJkne8VnDAkJoVWrVonarlmzRu/rnZSURElJSdm2O336NN2/f1/03IMHD+jMmTN6XR9NlIOg1NRUsrGxEb2u/Lc3phrv2b2X6uuLFy+mPXv2SLZNS0sTgpHPhZOTk6za/k5OTrLmZwgICKBly5bJrpF/8+ZNyfeJjIykESNGCD/b2tqKJsOKjIyU9T5SFAFBv379KCAggO7du6exbfHixYUJ3hQXQ6mpqeTm5ibZXnHsX7lyJaWkpBAR0bFjx2jTpk1ERGq9M5oeUpo0aaLzZzaEXKtAWLZsWezZs0eyUtXevXtF93r//+0LjeVy7e3tRfdpUlJSsHnzZo0lTNPS0kQ/X79+XWMRjcaNG6Nv376i52xtbTFgwAAMGDBA8ndyy507dzQmltSqVQvR0dGi5+RsF7nbJDd8++23qF+/Pvr16wcfHx88fvwYK1euxJAhQwAAf/75JypXrgwAWLBgAZo2bYpVq1YhICAADx8+xN27dxEREaHz+//xxx9o1KgRSpUqhSdPnqBnz544duwYzM3N0aBBA6xduxaenp6Sv9unTx8cOXJE9JyVlRX69OmD27dv67xO2lKuKmhpaZll6enU1FTR90QxfA3I3A9V9x9lJ06ckBzmNnbsWJ3qDMit+Dlw4ECN62ZhYfFZlSIGMovgZPX3UBUaGorTp09rPdzv7du36Nu3r8ZhvZo0bNgQV69ehbu7u+j5efPm4ccffxR+trW1RUxMDADg/PnzmDNnjqiksByKfJR69erh0qVL2LZtG5YtW4bnz5/j+fPnANSn0n7//j2KFSsG4P/qHqSmpmqsw6A49iurX7++8P/sqglmRXXIYl6PVMi1BMLdu3ejd+/emDZtGtq0aSPM+bxnzx5MmjQJq1evFs39rppprYxUMq3lJldlNwLAWCe4yG69VV+Xs12MdZvs27cPu3btEiYlateuHVq1aiXZ9t27d9i/fz/i4+Ph6+uLFi1a5GhOBU9PT9y9exeOjo5o164dfH19hZPLtGnTcP/+fbXa+gouLi5ISEgQbX8igouLS65sRzkjFXRNThw0aBDCw8MREhIiGuamGCasS50BXSt+6jKsOD+aNGkSdu3ahb59+6oN9+3atSsAcdnyT58+ITw8HA0bNlTL3peqSzBt2jTY2dlh5MiRku+vKak3LS0NFhYWakMWvb298ejRIyG48PT0FBKuMzIyULRoUZ0rRGoa+aAgNQKiW7du8PHxwcyZM+Hu7o7Xr19j/PjxiI+Pl6wlk5CQgKlTp+L06dN49eqV6MJK0+gKbRlypIIucnVo4fr16zFmzBhR9r2XlxdmzZqlVkc6u7oEgPRQEG2oDtNS1a9fP70O09IXOQGSXPrYJq1bt9Z4clRVsWJFXLlyRe5q5ionJyckJCTAwsICRYoUwaNHj4Sr1tTUVBQpUkRj1m/VqlUxdepUtUz7sWPHalUpUJsx8vHx8fDx8ZF8Tc5IBV0VLFgQ0dHRWhWzUZWSkgIzMzO1KzLSoeJnTocV5yeqY/wVlMf3T5kyRatlKQJb5V4bIkJMTAwcHR3VrvLv3LmDZs2a4cOHD/j555/h7e0t/E61atVw4MABuLu7i4I1R0dHvHz5UrLwW1JSEgoVKqTWq2RIb968QY8ePXD8+HEkJSXByckJNWvWxMaNGyWH0Hbq1AkfPnzAsGHD0KFDB+zYsUMY/SZVbO769evYtWsXnj9/jt9//x23b99GYmIiKlWqpNY2u5EKuS637kc0b96ciDITkm7dukWnT5+mW7duZTnns7ZiY2M1JritXr1aLds0JCSE6tevn+XDGH399deipCGphzI520Uf20T1XnNWtJnH/tOnTzRq1Cjy9/cX7hVHRETQ/Pnz1dq+efOGhg8fTlWrVqVixYpRQECA8NBVkyZNaPPmzUREVLNmTfrnn3+E165evZrlSIUjR46Qs7Mzde/enSZMmEDdu3enAgUK0JEjR7R676SkpGyTtuRsb0OoUqVKllnmyn788Ue6dOkSERHt27eP7OzsyMHBQS35b86cOfT1119LLqNXr15qSbLGmPhqKGlpaTR+/HhZuUqnT5+WfF45d0VuRnx4eDgFBwfTzJkzhfvoHh4ekrkMFStWpAMHDkiuw4EDB6hChQpafxZ9evbsGV28eDHb76+bm5uQxKzIw3nx4gWVKVNGra3c5MTsRirktlwLBuR+wKioKPrll18kX5s9ezZdv35d+LlXr160fPlyybarVq1SO0nKERwcrPPv5jVDbhcpck5O2rTt1asXdevWjaKiooTg4cmTJxQYGKjWtmPHjtSsWTOKjIwkJycnioyMpMaNG6udPOSIjo6m4sWLU8+ePen777+nggULUp8+fahv377k7u5O27Zty/L379+/TzNmzKBBgwbRzJkz1ZIhp0yZovExfvz4bIMBbQIqQ4qOjqamTZvS/PnzaePGjaKHKg8PDyEprXLlyrRnzx46fvw4lS1bVtSuXLlyFBMTI/l+MTExavujMSa+GpK7u7ushEBNx11N+9+sWbMkn//5559FPyclJdHkyZOpbNmytGvXLvL09JQMBlasWEHe3t60f/9+4cIvIyOD9u/fT76+vhqPT9pQDvg1PVTJTewtXLiwEHz5+fnR06dP6dOnT5LbVW5yoiFGKuREnk1UlJ0OHTqgc+fO6NChg9pru3fvxsaNG7Fjxw4AmXOg37p1S608J5BZ7CUoKEh0LzIuLg5Hjx6VLES0Zs0aNGzYUChkoWvBHEOQW7hJznaRs00UevfuLeqy3bRpk3DfEoCovHSDBg1EbZXvJwOQLOtbuHBhPHr0CDY2NqJCHFJVIQsVKoSHDx/CyclJeP3ly5cICQnBjRs31JatreTkZKxevRoXL17E48ePYWdnh+DgYHTv3j3HhV+sra3RoUMHuLi4qL2Wnp6OlStXZlkwJ8+Kk/x/kyZNwi+//IIKFSqo5Qyo/j0VOSnPnj1DxYoVhRnfVI8Lcit+urq6IjY2Fk5OTmpt379/j6JFi+a48IwxmTx5MqysrDBmzJgsk/yymnXv4cOHaN++veSse3IL4SgmTzt+/Dju3LkjOafBtGnTMGvWLKSnpwu3cSwtLfHjjz/mKMHTyckJXl5e6N69Oxo1aiS5PVSnwg4MDMSRI0dEt9fi4+PRqFEjycTe9u3bo3379ujatSuGDRuGkydPwtbWFgUKFMCBAwdEbYsUKYLHjx/D0tJS2F6JiYkoVqyYZGG6pKQkrF27FlZWVujRowesrKxw/PhxPH36VLJ0t6HlWjBgaWmZbUar8gHEx8cHMTExolKnCmlpafD39xcSTxwdHfH69WvJLOSUlBS4urqK7kv17t0btWvXRr9+/dTar169GidPnhTupxpTMqGcAAmQt13kbBOFtWvXin5WnUb466+/Fv6vnEBG/39yk/379wvPSU1WU6pUKRw9ehQ+Pj7CzvXgwQO0aNECt27dErUtUqQIYmNjYWtrC39/f5w/fx4uLi4oUqRIrv39hg4dil9//RUA0L9/f405L4rErS+++AJTpkxBy5Yt1dokJSXB3t5elD2vacInymKyJ0NycXHBpUuXtJr7oW7dumjZsiViY2ORnJyMlStX4unTp/jiiy+EExcgv+KnsSa+GkrJkiURExMDW1tbeHh4iL4PyqMy5M66pxg90q9fP6xcuVKtUuTq1atzlDmfkJCA8+fP49WrV3B1dUXNmjVRoEABnZcHZF7Q7NmzBxs2bEBUVBTat2+Pbt264YsvvtD4OzlJ7E1PT8eGDRvw4cMH9OzZUy0AlZucaGxybWihlZWVrKF5CQkJSE1NlQwGUlJSRAeAYsWK4dixY2jatKla22PHjglDSZSfUz5pKevcuTMmT54s/Pzx40e131eV06xSbZ0/fx5btmyRfK1Vq1Zqc8DL2S5ytomC8skeyJxSVPU5BdWTvZWVVbaz1X3//fdo0aIFxowZg/T0dISHh2PGjBkYNmyYWts6depg165d6Nq1K9q2bYvmzZvD1tZW1PugT1IJfsrDDDUl9inr37+/2lA5BSsrK7WrJtW22k6nrIuskhMVvL29ta4vv2rVKkycOBFWVlZCqeGzZ8+iR48eonatWrXC0KFDsWPHDlEQm5ycjBEjRohGHAHyhxXndytWrNCqneK7ou2se8uXLweQuT2VRxkoJvzS5mSWVdJrgQIFJEta54SdnR06d+6Mzp074+XLl9i6dSuGDh2KhIQE7Ny5U7LnrlSpUoiIiBAl9kZGRqJEiRLZvp+FhYXG4xsALFq0CD169ICLiwuSkpJQsGBBITlRiiFHKujCaG8TVK9eHcOHD5esS7BlyxbMnz8fFy5cAJD5RZ48eTKWLFmCFi1awNzcHBkZGfjzzz8xePBgTJo0SXTFK+eKWc7sfIbm6OiIFy9eSHb7f/r0CUWKFBHd0pCzXeT2rkiRc3LStu327duxatUqxMXFwcfHB71795b8TihLT0/Hxo0b8f79e8kIXh+ymwRH08lUm5OstnS9TaDNSAVtlj1nzhwcOHAAQ4cOVRtRoOtY6devXyMkJASvX79G06ZNhSHIhw4dgpubG44fPy7K+tbHnA35lWIYZVa2bNmCtm3bSmbzS5GaWl5beTkx1KtXr7BlyxZs2rQJr1+/xu7duyWDgaNHj+Krr75C69athXok+/fvx86dO/Hll18CEA/NzIrU0Ewgc7ryuLg4eHt7w8vLS+Pvyx2pYGi51jMgN+b43//+h969e+PFixca6xIo9O/fH8+fP0fnzp2Rmpoq3JeysrLC2LFj1bq+5VwxW1hY5NrJPjtyCzfJ2S5ye1ek/O9//9P6s2jqhVB25swZdOzYER07dhQ9n92sXhYWFnqZwTC7SXCyUqZMGcngt3z58tmeZF+/fg1XV9ds10/XOD41NRW9e/fOchtps+zff/8dANQOXFLjuxWFjKQKFCkfVF1dXXHp0iWsXbsWx44dw6VLl+Dm5oaJEyeiZ8+eaie148ePZ7uen5P3799j6NCh2LZtG5KSkmBra4uwsDDMnz9fMvdkyZIlGDhwIFq2bImuXbuiadOmWU4I9OjRI5w6dQp169aVfD0n+4S+JSYmIjw8HBs2bMD169fRoUMH/Prrr1neJvjyyy9x5coVbN68GfHx8ShTpgymTZsmui2lGDIp15kzZ+Dp6YlixYoJPWYPHz7E06dPJY9XR48eFfKczM3N0aRJE1SuXBkhISF5EgzkWs+AanKZNuTUJQAyq2edO3cOr169gpubG2rWrCm5g8i5YjamBEK5hZsUtNkucntXckNez+qVkwQ/qe/N48ePUbFiRbx48QJA5t9l2rRpuHXrFmrUqIGBAweiefPmuHz5MgoXLozw8PAsA9FHjx5JztgG5Hw2P31v4y5duiAqKgotWrRQq4aYkyQyXRJf87OePXvi06dPmDlzJvz8/BAbG4vx48fDxsYG69evl/ydx48fY+vWrdi8eTNiY2PRsWNHdOvWTfIENXnyZGzevBmJiYno3LkzunXrhgoVKgiv5zTpVZ+cnJzg7e2NLl264Msvv5QMcnKzmp/c5ERjyHMSyeXRC7IZoi4BEdG0adPI3t6erKysyNPTk6ysrMje3p6mT58uaidndr7csG7dOvL29iZzc3Ph4ePjQ+vXr8/xsrXdJgq3b9+m8PBwevbsGRER/fvvv7RgwQKtx9L36dOH3r59q/Z8VrN6nT59Otdm9dJlEhxLS0uysrIic3NzsrKyEj0sLCxo3LhxQtuwsDBq27YtrVq1ilq3bk2lS5em//3vf3Tjxg0aO3Ys1a5dW+d1lzubn6JWvOojq0lqBgwYQCdPntRqfZydnSX/1jmV28Nn81rhwoXV5g348OGDMF9Hdv755x8KDg4WZpGcMmWK5N/l77//ppEjR5Kvry+VKVOGZsyYQQ8ePDCqiaH8/PxEs2CqzhSakxojyo4ePUoDBgyg1q1b04ABA+jo0aOS7ZydndXOT1nVDWjXrp0wDPf777+nSpUqUc2aNalZs2Z6WW+5jD4YMKSEhAQ6ePAgbdiwgQ4ePEgJCQl5vUpaMVSARKT9NlmxYgU5OTlRtWrVyNPTk9atW0deXl7UoUMHKlKkiGhKUk2Tdzg7O9OYMWPUJvIwllm9dJkEJyYmhh4+fEilSpWimJgY4REbG6s28VahQoWEA/vbt2/JwsJCKOKSkpKiVkfg6NGj1KtXL6patSqVLl2aqlatSr169aJjx46prUdOD9ra1DCYOHEilSpVinx9fWnUqFFqs2kqq1KlisapiXPCz89P46Q6nz59oqJFi+r9PfNSsWLF6Pbt26Lnbt++neWJLzk5mXbv3k2dOnUiV1dXateuHe3atYv+/vtv+vrrr6l69eqSv5eRkUGHDh2i4OBgsrKyIjc3NypVqpTG2h2f48RQs2fPJk9PTxo/fjwtXbqUxo8fT15eXpI1cKpUqaJWYOngwYMapwBXlpaWRmvWrKFFixZpnGnW0Ew6GGC6K168uDAH+IULF8jKykqYNvTGjRui6nzm5uZUo0YN6t27t6haop2dHYWFhWmcflWbWb3yqlqXttLT0zVWOZMzW+D8+fPJ29ubJk+eTDt37qS//vqLdu7cSVOmTCEfHx9asGCB6HdzOpufnAJSmq4ilU2aNInKlClD8+bNy7ZAkRwODg6UnJws+VpycjI5ODjkaPnG5vfffycvLy+aPHkyrVq1iiZNmkTe3t60aNEiyfa9evUiV1dXCgkJoWXLltGbN29Er6elpanNGHv+/HkaOnQoeXl5UfXq1enXX3+l//77j1JTU2n58uXk6+trqI9ndDw9PSWDLw8PD7W2Oa06mtdyLWegXLlyiIqKyo23YrlAeXx3eno6bG1thXrzqq+fO3cOI0aMQI0aNTBlyhSh7rynpyeuXr2qU217hdzI6dBlEpyXL19i0KBB2LNnD6ytrfHhwwfs3bsXZ8+eFerlOzg44PDhw0KyXrNmzRARESH83KRJEyHZztPTE6dOnZIcAnXv3j3UqVNHsoiMruQOWyQiHD58GCNGjEB0dDScnZ1Rvnx5zJkzB5UrV9aqpj4g/zhRvnx5zJ49WzLxNTIyEqNGjcK1a9e0Xl5+cPjwYWzZsgVPnjyBt7c3OnXqpHHG0WnTpuHrr79G0aJFNS5PeVRCsWLFYGFhga5du6J79+4oWbKkWvuaNWti//79JjExlJ+fH27evAkHBwfhuffv3yM4OFhyUq2HDx8KyYm+vr7o0qWLKDkxpyMVDCnXRhMopq1kn4dy5cphxowZ6Ny5M9avXw9fX1+Eh4fjq6++wr59+0SjD2rWrImzZ89i2bJlqFGjBoYPH45+/fplOyQsNjYWkydPlsxAVxRYyW4ZOaXrJDj9+vVDUFAQXr16JRyI69SpI/o9d3d3UVKtq6ur6GfliWIU45alFChQAMnJyVp9Hm1HKmh7Ar1w4QI2bdqEHTt2wNfXF9988w06d+6MggULYs2aNWjbti3i4uK0Ht4n9zjx3XffoU+fPlkmvn4OVBNCixYtKiRGnjt3DufPn8eECRNEbdLT0zFz5kyMHj06y2UrvlcZGRno1asXRo8eDRsbG43tGzRoAC8vr3w5MVR8fDyGDh0qjO1Xpkh8VC6CNWrUKHTo0AFjx46Fj48PHj16hJ9//lk0LbOygICALGcc1HWkQq7IrS4IfXTnyrnnaMhJXFq1amWwZRuavrbLlStXqFy5cuTs7Ezjxo2jU6dOkbOzM3l5eVGBAgXo0KFDkr/38uVLGjhwIH3xxRfk5OQkWc9coUaNGtSzZ086cOCAxklTNCW+ZZf8po2cTILj5uYm/I7yNldMdiKXIsFo48aNFBUVRbGxsRQVFUWbNm2iypUr0/Dhw0XtExIS6IcffqDmzZvT1KlT6b///qMqVaqQubk5eXh40Pnz53VaD2UBAQFUokQJmjhxIt25c4eIMu8zK3f916hRQ/h/SkoK3bhxg06ePEknTpwQHsp0OU7ITXzNj6QSQQcOHEj9+vUjNzc3jd/zKlWqqN2yyUp22z+/TwzVtGlT6tu3L92+fZtcXFwoOjqaunfvTkuWLBHaZJWzpHjk5LhirHLtNoGFhYXkPOTKsqu6JGe4kyGrs+V1TXhlcovYGHK7vHnzBvfv30epUqUkp6BVduXKFZw4cQIDBgzQWBDF2dkZCQkJWdZgd3R0xP3797N8L22r5KmqV68ehg0bhnbt2qm9tmvXLsyfPx+nTp2S/N3g4GBs27YNZcqUEb4v165dQ8+ePXWaupmIsHjxYmzYsAE3b97Ehw8f4OjoiDJlyqB79+4YNGiQqJekc+fOSE5ORuvWrREeHo67d++iTZs26NGjBzZu3IgTJ07g9OnTQvtjx45h3bp1uHHjhrDssmXL4uuvv0b9+vUl1+ncuXOoWbOm6DlNhWdOnDiBzp07w8zMDC9evIC7uztevnyJEiVK4ObNm0I7XY8T2g4r/lykp6djzZo1mDlzJjw8PDBp0iQ0adJErd3EiROxZcsW9O3bFz4+PqLviNRQ7w4dOmDQoEFo2LCh5PvmZJ8wBq6urnj69ClsbGyEeTA+fPiAChUqZHscMYRjx45h69atePr0KTw9PREWFqbxlpqh5VowoI9KfnJOZHJP2HLaG1MwkNefU/l+uqurK6pUqaLx3qHce++dOnXCkCFDspzTwpC153MyCc6OHTswYsQIDB48GDNmzMC0adPw22+/Ye7cuWjbtq1B1leZu7s74uLiYGdnh3fv3sHV1RWJiYmwsrJCamoqChcuLKz7ggULMGfOHPTv3x/lypUTtun169exfPlyjBw5Et9//71W75ucnAw7Ozu10skVK1bEd999h759+wr78cKFC/HmzRtRqWtjqvhpjJSDAG9vb0ycOBGNGjXS2F7bXA2Frl27Ijw8HCEhIWrBw7Jly/L9xFDe3t6Ijo6Go6MjSpYsiYiICLi6usLPzy/Xx/bPmTMH8+bNQ9++feHr64tHjx5h1apVGDZsmORkdIZmtOWIpWR1cgoICBB9cePi4lC0aFFhEpfseh2yCjTkzM6X27ILkHKyXbJbtpz76brce+/evTvCw8PRsGFDtat7RYKNIRMIczoJzqVLl0SllLt3747Dhw9jypQpOq+TphK0qj1Equumuu8ov67P5ERNPQPOzs54+/YtzMzMhHXJyMiAp6cnnj9/rnG9Wab09HSsXr0aM2bMgJ+fHyZOnCiUz5WiqDyooFpVcMKECZg2bZra72X13Zw0aVK+nxhq6NChqFOnDjp16oQZM2Zg8eLFsLa2Rq1atbBhwwa19o8ePRJyDFTPPTktruTl5YVjx44hMDBQeC46Ohr169eXnOXQ0Iy2HDEgPUubhYWF5CxtymVJiQgVKlSQVZM8q0Q01W7SrVu3ZjvJTm7JLoEuJ9slq2WvXbsWa9euxY4dO9C8eXNYWFggPT0dBw4cwKBBgxAUFCRUhZPTVlnJkiWzjZCVu5j1TZdJcIgIK1euxJUrV1CiRAksXLgQ79+/x/Tp09G8eXONXe7ZuX37Ntq0aYN79+7Bw8MDP//8s6gKp2r54/T0dJw7d05Yd9Wfla/c5SYnnj17VuN6akpk9PT0xNOnT+Hl5YWAgAAcOnQI7u7uaj0IuXRtku+UKFEC79+/x/Dhw4WrfdW/g3K1vR9//FEUDLRp00Z0Mlu4cKFkMJBdwmV+nxhKMasoAIwbNw516tTBhw8fNE6i1L9/f/j4+OD06dOoXr06Ll68iGnTpklOgKZNcqIyKysrtVu8Xl5ekvPD5IZc6xlQnb9eF/q8TZCTK+a8vE2Q02ls9dW7IufeYX69z6jLJDjff/89du7cidq1a+PUqVOoXbs2/v77bzRq1Ag//PCD5OQp2mjSpAmaNGmCoUOH4uTJkxg4cCC6dOkiHNBVe0j8/f2zXfeHDx8CgDBP+8iRI1G+fHnh6i4qKgpz5sxBSEgI5s2bJ/xeQEBAtuurWLbC6tWr4enpidDQUISHh6Nr165ITU3F7NmzRbNQ6uM4oez58+c654wYk+z+nqr7p+r3QfXYqalHLSMjA0uWLMH27dvx8uVLREVF4eTJk4iPj0fXrl1NbmIoOTkGoaGh8PHxwahRo9QCB8WMvcojFXbt2oU///xTbaRC8+bN8e233+bq5wRyKRho3LixVkPADh06lOXr+kwgVB4jqrhiVh5OlVUSkyGT8OSSuy5ZtZezTeTcO5TTdvv27cLERIo51qXInecit/j4+ODkyZMoVqwY7ty5g6CgIISHh6N169Y5Wq6rqytevXol7EcvX75E8+bNUbVqVSxatAjOzs463y6Rm5yoy/IfPHgAPz8/YUrylJQUJCcni74Tuhwn+vXrp3Fa35iYGDRu3Bh3797Ved3zKzm3iZSNHDkS//77L0aMGIHu3bvjzZs3iImJQZs2bXD16tVcWXdDiomJwZQpU7IcrqxMTo6BNoGD4mIuq9OuNhd1hpArtwmUuzPv3r2LdevW4euvvxaSJtatW6fVLHNy4pb9+/dn+brqyV6bLGYFObPzGZrcg3RW20XONklPT9c4NbCTk5Poyyyn7erVq4VgQDHHuiozM7NcCQZ0mQTn3bt3Qo2FUqVKwcHBIceBAADY2tri1atXKFSoEACgUKFCOHLkCFq1aoXu3bvnqHvdzMwMgwcPxuDBg3O8npqWX758eVGwYm1trdYdqstx4saNG+jfv7/adyU6OhqNGjXKdrrrz5Wc20TKNm7cKBSNUvD39xcuFPL7xFAdOnRAxYoVMXPmTMmp4FW1b98eBw4cQKdOndCrVy+EhITA2tpacp+2s7NDamoqbGxs4O7ujvv378PV1VWYmAzQvN2NQa7dJlCoUqUKNm7cqJY00a1bN/z9999Z/m5Ws7TllDFd7cthyPXOatl2dnZYtWqVxpNQv3798OnTJ9ltjUnv3r1Ru3ZtydkaV69ejZMnT4qm0gayryoI6DaTWpcuXVCzZk0MHTpU9HxSUhLatWuHyMjIHF9NaJucqIuGDRti7ty5qFixolbttT1OvH37FqGhoQgODhYCgitXrgi3VMaPH5+j9c6v5NwmUv29y5cvw9XVVehNePbsGWrXro379+/rtE8YkwIFCuD169dZDlfOyokTJ4QcA9VZEuUmJxqbXA8GChYsiPj4eLXyjqpDUgYPHqzVnPcAMH/+fLRv3z7LkpvZOXPmDGrXri35WnR0NG7fvo0aNWqgSJEiwhj5cuXKZZnRmxuyC5DevHmD3bt348aNG/j48SN8fHxQrVo1yTHJqrLaJnLuHeb2fcaKFSvqNJZflb+/P27duiV5BZGYmIigoCC1kqRy7+1q68WLF/jw4YPk/fq0tDScPXs2yyGYWckuOTEnGeKKQOK7777D1q1b0b59e7Uha1IV27Q9TgDigKBnz55o06YNpk6diiFDhui0zqZs0qRJOHPmDKZPn45mzZrh2LFjGDduHGrVqoVx48bptE8Yk0GDBqFRo0Zo3769wd8rq8ABMOxIBZ0YqJiRRl27dqXGjRvTyZMn6cGDB3TixAlq2rQpdenSRdROTiUyxXSx9erVo5UrV+p1qlQ5s/MZ2qBBg2S1P378OBUqVIgaN25MjRo1IisrK+rRowfVqlWLatasmWX1v/xMmxn3tGGMk+AoZqw8e/as3masbNy4Mc2ePZuSk5Ppr7/+ouLFi9P48eOF11UnspFDsR8rT1Cl/NA0SZW2xwmFt2/fUo0aNcjGxobWrVun8/qauvT0dPrll18oKCiI7O3tqVSpUjRr1iyh2qAx7hNyPHv2jAICAqhChQrUuHFj0UPKw4cPqVevXlSpUiUqWbKk6JFT2lRDzE25Hgx8/PiRRo0aRQEBAWRra0sBAQE0atQo+vDhg6idnGDA0dGRnjx5QrNnz6YKFSqQvb09hYWF0Z9//knp6elq7efNm0exsbFaLVvO7HyGJrdUa9myZenw4cPCzwcPHqTQ0FAiIvrll1+oQ4cOovavX7+mlStX0ogRI2jAgAE0bdo0ioyMlFx2bGysxtKjq1evpri4OJ3a6oO+Si6XK1eOIiIiJF+LiIigcuXK6eV9tLV06VJyd3cXlUp1d3enxYsX52i5BQsWFAUVL168oKpVq9LgwYMpIyMjR8GArr+r7XGiRIkSwsHZ29ub7O3t9X7QZv/H2PYJuerUqUNNmjShxYsX05o1a0QPKV988QX17duXDh48qLEkuoLcwKFgwYKUlJRERP9Xpvz9+/dUrFgx/XxYmXL9NoG2rK2tRV2VUhTFflS7Ma9du4YNGzZg06ZNSEtLQ5cuXTB//nzhdQsLC1hYWKBmzZr4+uuv0aFDB43lc+XMzmdocrtrXVxckJCQIKxrWloaPD098eLFC3z69AleXl5ISEgAkNml1aFDB1SqVAlEJJSPvX//PogI4eHhotkF5dw7NPR9xgYNGoi6nVWHp2VX0U6T5cuXY/LkyVlOgiP1mQxh37596NGjB6ZNm4bWrVvDw8MDT58+xb59+zBp0iSsWbNG50RFLy8vXLt2TUhOBDK75Fu1agVvb2/s2bNHLfNaW05OTrh582aWCY45ub134sSJbNsYS02Q/OLUqVPYtGkTnjx5Ai8vL3Tp0kW4BWVM+4QunJyc8ObNG2FUS3bk5BhUqVIFFStWRIcOHdRuo0h9B42pGiKQBzkDmoaL2djYwNvbG1WqVIGlpSVsbW2zrdSmmI1L00mS/v+0qhs2bMDatWuF552cnHDnzh1s3LgRGzZswN27d9GqVSv07NkToaGhoj98nTp10KxZM2F2vnXr1mHu3LnC7HwTJ07Ev//+q8umkE1OgARkfgE7deokjFldsGABwsPDcfz4cSQnJ8PDw0O4/xocHIyFCxcKNckjIiKwcOFCHDx4ELNnz8bFixexfft2Ydly7h3KaZvVcEJlyqMJlE8IRIRWrVqJRk3k5GQwffp0zJo1C6mpqULlRCsrK4wdOxbjxo3TeblyNWnSBJ06dZI80K5cuRJbtmzBX3/9pdOyDZmcaG5uDltbW43BgJmZmWTyqLbHCaZfy5Ytw/jx49GvXz/4+fkhLi4OK1euxNSpU4Xpd41ln9BFhw4dMGLECK2TeOXkGMhNTjS2hMNcDwbq16+Pc+fOwcPDA97e3nj8+DGePXuGqlWrIiYmBubm5ti9ezcaNGigdXQktyStnJ6Eq1evokePHoiNjcV3332H0NBQtGjRAo6Ojvj06RO2bdumcS5xfZMTIAGZ1fnatGmDhIQEEBEKFCiA8PBwBAcHIyoqCqtXrxaKycjpRQAyJwh6/fq1ZLWslJQUuLq6CleTctoq11LPyMjA2bNn4enpCR8fH8THx+PZs2eoVauWqLKiKn0XhTKGSXDc3d1x+/ZtybkcXr9+jVKlSuHly5c6LduQyYm6lovW9jjx559/ZrkcMzMztal9mWYlS5bErl27UK5cOeG569evo23btrh3757wnDHsE7ro1q0b9u7di4YNG4p6OoH/K3Gu7Pnz56hZsyacnZ3V2qvWxclpcmJ2CYeGluvBwKBBg1C+fHkMGjRIeG7JkiW4du0a/vjjD/z0008IDw/HjRs3DFZzXm5Pgio5s/Ppky5Z3WlpaYiOjgYABAYGaryaktOLAADly5fH7Nmz0bRpU7VlRUZGYtSoUULBIjltlQ0aNAhly5YVZYX//vvvuH79OhYvXqzxM+fXYaJZye5vr4+a8ESE6OhoYYhhYGBgjooN5WS9tD1OVKpUSfL309LSsHv3brx58yZvMrPzKXd3d8THx8PGxkZ4LjExEb6+vjoHm8Yku7kXVNWtWxf29vb46quv1Ho2v/76a9HPcgIHo5TbSQouLi5CZqpCWlqakECRnJxMzs7ONHPmTIOtgy5JTS9fvqSDBw/Spk2bKCIigl6+fGmANctaThK5iDIz0e/cuUN37txRy0K/ceMGlShRggoVKkRubm5UvHhxioqKIiKia9eu0fDhw0Xtly1bJsxrrkjSTE9Pp71795KPjw8tX75cp7bKpL4rqampwndFk02bNmW/MfIZe3t7Onv2LJ05c0bykdMsbkMlJ+r6ndX2OKEqLS2NVqxYQcWKFaNatWppTIBl0jp37kxdu3al2NhYysjIoJiYGOrevTuFhYXl9arlCUdHR0pNTdWqrdzkREOOVNBFrgcD5cqVU8ssX7NmDQUHBxNR5km3cOHCtHHjxmwfCsoH/0+fPtHQoUPJx8eHvL29afDgwfTx48ccrfOYMWPI2tqaLC0tycPDgywtLcnGxoZGjx6do+XKJTdAGjt2LF2/fp2IiG7dukWBgYHk4uJCLi4uFBQURLdu3RK1T01NpevXr9P169e12gGmTZtG9vb2ZGVlRZ6enmRlZUX29vY0ffr0HLVVKF++PC1dulT03PLly40+Y9kQ/Pz8yN/fP8uHrvbu3UsuLi7066+/UkxMDCUlJdHDhw/p119/pYIFC9KePXv0+Em0o+1xQkE5CKhbty799ddfubm6n403b95Q165dydramszNzcnGxoa6detGr1+/zutV04sFCxbQlStXiIjo3Llz5O/vTyVKlKBz585Jtm/fvj2dOXNGq2XLCRyI5I1UyA25fpvgwoULaN++Pezs7IR7gYmJidi5cyeqV6+OEydOICoqCjt37sxyOcrzcSt3RQ4fPhxXrlzBTz/9BDMzM4wdOxbBwcFYsGCBTuu7du1ajB07FkuWLJGccW/69OmSpTkNQZvkOuXEOuUuv8aNG6Np06YYOXIkgMxCTXv27NF4752IhHuEJUqU0NhdLOfeodz7jJcuXUL79u2F2b3i4+ORmpqKnTt3omrVqlluh759+2L+/Pm5ehsnvzJkcqKutD1ODBo0SNbUvkyz9PR0TJ48GePGjYO1tTVevnyJQoUK6Vytzxj5+vri+vXrcHFxQb169RAWFgZHR0csWrQIly5dUmsvJ8dAbnJiTqsh6lueDC1MSUnBuXPn8OzZM3h4eKBmzZo5mrZROUkpICAAJ0+eFKryPXnyBDVq1EBcXJzQfvPmzejSpQuAzPth//vf/7Br1y4QEdq0aYPZs2fD3t4egHHNuKecXCdFOUACMr9sz58/F2plP336VMgZyMjIQMGCBYVhkePGjUPXrl1RtmxZ3L59G23bthXmsPf09MTu3bt1nnEvJ1JTU3Hu3Dk8ffoUnp6eqFmzJqysrITXZ86cKfl7P//8M7799ls4OjpKVrjLb16/fo2LFy9KTrUaERGBatWqwdXVVadlGzI5MSe0OU4EBASoTe2rSpfyz6bK3d0dz549y5MEttygGAr+5s0blChRAi9evIC5ubnGIeJycgzkJifmZjVEbRhtnQFVjx49Eg1PUh6brNwzoJgKUvlKVjWjWU5PgpwZ94xNx44dUadOHXz//fdo3rw5hg0bJpQhPnr0KIYMGYKbN28CyFkvgiGlpKTg/PnzePLkCTp37iz8HRV/DwsLC1SrVg2lS5cWfT+2bt2K1q1bw97eXjTcMr/6/vvv4e3tjR9//FHttTlz5iA+Pl7n3q/cSE40FEOVfzZVkydPhpWVFcaMGWM0V6z6VLlyZYwaNQr37t3D9evXsXXrVrx+/RqBgYGiCYV0ITc50dgSDo02GNiyZQuOHDkiTD6iuFInImRkZGD9+vXo1KkTgMyxzJaWlsJr//zzjzAhyr1799C4cWPRpBxyehKyKyqUlwfKrAIkIPPL1rp1a9ja2sLPzw9bt25FnTp1YGZmhqtXr2LHjh3CGHw5vQi55Z9//kG7du1QuHBh3L59G+/fv0dkZCSWL1+OHTt2AADOnTuHESNGoEaNGpgyZYpwW8DT0xNXr15V28nyq+LFi+Py5cuSt1Xevn2LypUrq82vri3VyZVUNWnSROeiQyx/KVmyJGJiYmBrawsPDw9RoCU1xW9+c+HCBQwbNgzW1tZYsWIFSpYsiU2bNuHAgQOSY/sXLlyI+vXro0KFCjh//jy6dOkCS0tLrF+/HjVq1MjRusgZqZAbjDYYCAkJwezZs1GtWjUA4uFily5dwogRI4TuedWJMQoVKiRMcHLp0iXcu3dPuC0AyOtJMKYZ9+QESMoiIiJw8eJFPH78GHZ2dggODka7du1E3cpyehFyS9WqVTFhwgS0bt1a+PsnJiaiWLFiePr0qdCOiLBs2TIsXLgQw4cPR79+/eDt7Y0rV658NsGAk5MTEhISJLtv09PTUaBAAZ2H4uo6wx37fGRkZGD58uVYtGgRhg8fjoCAALWeAVOs5Cgnx0Bu4CC3GqKhGW0w4OnpKTrgV69eHRcuXACQefD38vISvS6HnJ6E3J5xLytyAiS55PQi5BZXV1e8evUKZmZmQiGh9PR0FC5cGK9evVJr/+rVK4wfPx6XLl3CnTt3cO/evc8mGAgMDMTatWslDyrnz59Hz549P4srN5Y3hg0bhm3btqFu3bo4deoU+vTpg+nTp+f1ahnE1atXcebMGbx69Up0kTdx4kS1tnJyDOQmJ8pNODS43Bq2IJeDg4PapCQK79+/VxtXfeXKFWrXrh0VKVKErK2tqUiRItSuXTv6999/1X4/JiZG9FB+n4sXLxrtOHUPDw/Rz9WqVRP+n5GRofY6kbztQpQ5mdGUKVPom2++oe+//56WL19Or1690uvn0Fa9evVo9+7dRPR/kw+Fh4dTw4YNs/y9f//9lxYsWECJiYmGXsVcM3PmTAoKChKGRSlcvXqVypQpQz/99JPOy3716hUdPHhQ8rWDBw/m2d+f5R4vLy+6e/cuERHdvn2bihcvnsdrZBi//fYbubi4UJcuXcjW1pa6dOlCzs7O1KNHD8n2lSpVok2bNtHUqVOpU6dORJS5vxQqVEitraLuxevXr8nV1VWoqSJVD4Moc2ZOR0dHatOmDfXv31/0yAvG0T8hoXz58tizZ49oqJzC3r171cpl1qpVC6Ghofj5559Fk7jUrl0b586dQ/ny5YX2fn5+Gt+3atWqomFrcXFxOHr0qOTwwTVr1qBhw4ZCvoGhvX//Hh8/fhRugSh6SgDg48ePat3E2W2X8+fPi7YjAISGhkpmrOeFRYsWoVmzZliyZAk+ffqEtm3b4t9//5UsQfvq1StcunRJqJ7XvXt32Nra5sFaG8bo0aNx//59VK5cGX5+fvDw8MCzZ88QFxeHPn36SCYWamvKlCnw9vaW/Ltfv34dEREROicnsvzh/fv3KFGiBIDMXih9lvM2JnPnzsXRo0dRuXJlFChQAJs2bcKpU6fw66+/SrZfvHixKMcAyLztKlVNtXjx4ti8eTPu3buHRo0awdzcXGMZdgAoVaqUkKRtFPIkBNFCeHg4FShQgBYtWkRxcXGUkpJCcXFxtGjRInJ1dRWuGIkyq2aNHDlScjmjR4+mzp07qz2v7RVzr169NFbIW7VqFfXq1UvnzyhXzZo1RcWWlG3cuJFq1Kghek7udpHbi5AbPnz4QFu2bKFffvmFNm7cSG/fvlVrYyxFoXLDrVu3aPHixTR9+nRavHgx3b59O8fLLFasGCUkJEi+lpCQkGdTqrLco1rh0tnZWa3i5edA+Srd3d2dkpOT1Z7X1fnz56lGjRpUr149unPnDhFlHpe7deuW42XnBqMNBoiI1q1bR15eXmRubi48vLy81Mo7+vr60qNHjySXER8fT97e3qLnoqKiyN7entq1a0dr1qyhiIgIWr16NbVr147s7e3p6tWrQls/Pz/69OmT5LI/ffpERYsWzeGn1J6cAIlI3nbJbptcu3bNkB9N0qBBgySf//bbb4X/r1mzRih1rChfm5aWRnv37iVvb2+1KnZMnaOjo1rpX4W0tLQcl8Fmxi+7CpcBAQF5vYp6UbVqVeHipnHjxjRp0iSaP39+lrdFrly5Qr///jtNnTqVpkyZIjxySm41REMz6mCAKPNe+M2bN+n06dN08+ZNtZr6RNnXP1d9Xc4Vs4ODgxA9qkpOTs5xTXi5tA2QiORtF116VwzNyclJ8nlF/gARUd26dWnnzp2S7Xbu3El16tQxyLp9TkqVKqXxAHTu3Lk8q5XOmL5duHCBLl++TESZ87E0aNCAqlSpQkeOHJFsLzfHQE7g4OPjI/TI1a1blxYtWkRr1qyhKlWq6OGTymf0wYA2NJ00NL0u54q5XLlyFBERIdk2IiIiT+rkaxMgEcnbLnJ7VwxpxowZNGPGDLK1tRX+r3j0799ftM0LFixI7969k1zOu3fvqECBArm12vmWIZMTGcvP/P396Z9//iEiEibJOnnyJHXo0EGtrdzAQW7CoaEZbQKhlZWVxiF9RAQzMzOkpKQAAD58+KAxSYP+//BBZW/evIGPj49ke29vb9GQke+++w59+vTBkiVL0KJFC5ibmyMjIwN//vknBg8eLFlZytDMzMxQunTpbNvJ2S5ytomh3b17F0Dm+HnF/4HMz124cGGh4JCijVR1SCBzHC9PX5s9QyYnMpbXzp49q1U7qSF+r1+/RuXKlQEA1tbWSElJQd26ddGyZUu1tnKTE+UmHBqa0QYDiklytCG3IEp2dQOUX+/fvz+eP3+Ozp07IzU1FYUKFcLLly9hZWWFsWPHSk7uYihyAiRA3naRs00MbfXq1QAy52Lo2bNnlm1TUlKwefNmjUWh0tLS9L5+ee3Fixc4ePAgnj59itGjRyM+Ph4ZGRlqFSi1ZW5ujhUrVmDkyJE4fvy4MJFUgwYNEBgYqOe1Zyx3devWLds2mspWBwYG4sqVK6hYsSIqVqyImTNnokCBAnB3d1drKydwAOSNVMgNRlt0qEWLFpJDyKQQEd6/fy85Q927d+/g5OQkOpkpig5pWlZGRobaFaXcGfcMQbXSohTlYZNytosu2yQ3pKam4u7du2oFQurVqwfAuIpC5YbIyEj07NkT9erVQ2RkJN69e4fTp09j5syZOHDgQF6vHmOflYsXL8LKygqVKlXCzZs3MWTIELx//x4///yz2uyY1apVw7Jly1CxYkU0adIEtWrVQoECBbBo0SJZF7d5xWiDATk1/+fOnYuoqCisWbNG7bXevXujfPnyGD58uPCc3JOqsZATIAHytosxbpMTJ06gc+fOMDMzw4sXL+Du7o6XL1+iRIkSuV4a2ViULVsWq1atQvXq1YUKlCkpKfDx8cF///2X16vHmFFSlFu+ceMGKlWqhN69e+v9PeQEDgpyqiEaXB7kKWglu+Q3ZeXKlaOYmBjJ12JiYig4OFj0XEZGhuR4dSKit2/fakzIy2tytgmRvO1ijNukQoUKtGLFCiIiIRFwwYIFNGnSJKFNbGysxuGDq1evpri4OEOvZq5yc3MT/haKURUpKSnk7u6el6vFmFH7/vvvydPTkzp16kSenp40btw4jW2Vaytk9cgpuQmHhma0PQOWlpZCV7AmR48eBZA5415CQoLGdqp1pOX2JBgLuTMkytkuxrhNnJ2d8fbtW9HcBBkZGfD09MTz58+Fdatdu7Zk7sbq1atx8uRJIQfhc9CyZUs0a9YM3377rbBNlixZgsjISOzevTuvV48xo+Tt7Y0TJ06gRIkSiI6ORosWLTR23QcEBGS7PEWOQU6SEwMCArBz504h4TAhIUFIONy+fbtWy9Unow0G7OzsJE9MysLCwgAAXl5eOHv2LPz9/dXaPHz4ELVq1RJNalS+fHns27dPsts7NjYWLVu2RFRUVI7W3xDkBEiAvO1ijNskMDAQx44dg5eXF7744gvMmjUL7u7uaNKkiTD3uL+/P27duqU2BSgAJCYmIigoSKtbIPnFo0eP0KpVKyQlJeHBgwcoU6aMMLpFH2Wx9Z2cyJgxUL2QUgTSOSUncFClfDFWuHBhxMfHw9raWnISpNxgtKMJrKyshJN9dlq1aoWhQ4dix44domEZycnJGDFiBNq0aSNqHxcXp/H+t5+fH+Li4nRfcQOysrLCgAEDtG4vZ7sY4zb53//+h2vXrsHLywsTJkxA27ZtkZqaitmzZwttXr58KTmtLwBYWFhIzm6Yn/n6+uLff//FxYsXERcXB29vb1SvXl3jNpBDNTlx9OjRiImJ4eRElu+lp6fj3Llzwn151Z8B8dW7tjkGOZnaW85IhdxgtD0DTk5OWs/P/vr1a4SEhOD169do2rSpME760KFDcHNzw/Hjx1GwYEGhvdyeBGMh9zaBnO2SH7ZJSkoKkpOTRXUFypcvj9mzZ0sOx4mMjMSoUaNw7dq13FxNg5o5cyY6d+6MYsWK6X3ZnJzIPlf+/v5ZjjpSvXqXM6WzrsmJuiQcGlSeZCpoQdOEPJokJibSkiVLKCwsjBo1akRhYWG0dOlSyWlsv/nmG2rVqpVameGkpCRq27YtDRgwIEfrbii61IjXdrsY4zbp378/HTlyJMvkxWXLlglzEygqeKWnp9PevXvJx8dH4yRT+VXv3r2pYMGC9MUXX9Avv/yiMUFUF5ycyFgmOVM6y0lONGZG2zNgSHJ7EozFpk2bJKd01gdj3CZTp07Ftm3b8PLlS7Rv3x5hYWGSORPTp0/HrFmzJItCjRs3LlfXOTekpqYiMjIS27Ztw759+xAUFISwsDAMGzYsR8vl5ETGMsnJMZCTnJiThENDM8lgAACSkpKwdu1aHDt2TCgk9OWXX6Jnz56wtbXN69XLE8a6Ta5fv45t27Zh27Zt+PDhAzp06IAFCxaI2hhDUai88PDhQ/Tv3x/Hjh3LcVEoQycnMpZfODg44PDhw0JOQbNmzRARESGZYyAncMhJwqGhmWwwwPKfCxcuYNy4cXo58eVnL168wI4dO7B161ZcuXIFzZs3R1hYmFqirC6IyCDJiYzlJ3JyDOQEDsbMaIOBcuXKGeXwPpa7/vnnH2zbtg3bt2+Hubk5OnXqhLCwMFSoUCGvVy1PfPnll/j777/RpEkThIWFoWXLlpLDKnVhyORExj5XcpMTc6Maoi6MdmhhTEyM1m1NJXCQ+znz+3YpXrw40tLS0KFDB2zduhVVq1bN61XKc3379sXevXvh6Oio92Xfu3cPVapUQbFixRAWFoZOnToZZVluxoyJnHMVAIwYMUIYqTBu3Djcv39f40iF3GS0PQNyhtHJGYaYn8n9nPl9u5w5cwa1a9fO69UwKYZKTmSMZZKTcJibjDYYsLCwyPaqRNH1Inf8fX69Ypb7OeW0N5Zt8uzZM3h4eAAAnjx5orGdl5dXbq1SnlNOSJKaxpokpq/WB30mJzLGMhmqGmJOGe1tAltbW2zevFmrth8/fsz2PqfyPRu53TrGQu7nlNPeWLZJyZIlhd4MHx8fmJmZQTVeNTMzM6mT09WrV4X/G/oKQio5cdeuXQZ9T8ZMidxqiLnFaHsG5FzVOjg4iGryS6levbpOyzYmcj+nnPb5dZsw/TFkciJjLJPchMPcYrTBgJz73XJPZHJuQRgTQ94mMMZtMnjwYPzxxx9qzw8ZMgSLFi3K1XUxFqmpqVi8eDFOnz6tNgd6doFfdjZu3Ig2bdoYJDmRMWbcjDYYOH36NOrUqaNVW7mJcnKvsI2FIRMIjXGbaApmjOUeW14YMGAA/vnnH3zzzTf44YcfMHfuXPzxxx9o164dJk6cmNerxxjLp4w2GJBDTuAA5N8ucbmfU057Y9omM2fOBABMmzYNEyZMEL0WExOD8+fPf1aTD8lRpEgRXLt2DUWKFBGmOo2NjUXHjh1x8eL/a+9uY6os/ziAfxEwns4BDs4ToP6BXKEbEzdxkFSgNjOGy+YLskcJc2vD0F5UWGCGxKZGrVoPII8lK4EKamovJMWiZDl0MzUqQ9uMxaMwVDjnXP8XjjOPHNSLczj3dc75fjY2zn3/du7f9eMFv/u+rvu+j0t/n1aLE4lILcouIJQh8w8SwIQFae5Cdpwy8SrVpLOzE8D1hTXjvwPX59Jmz56N+vp6rVLTnMViQUREBIDrDVx/fz+io6Nx9uzZKX2fKxcnEpG6PKIZkHXgwAGtU1COSjWprKwEAKSnp+OZZ57ROBu1LFmyBIcOHUJGRgaWL1+Op556CkFBQUhISJjS9934zgE+YIjIe3nENAF5poaGBixYsAALFy60bjt9+jR+//13rF27VsPMtDMwMACLxQKDwYDh4WG88847GBoawksvvYQ5c+Y49N3TuTiRiNQ2Q+sEZKxZs0brFMiFXn75ZRiNRpttRqMRW7du1Sgj7YWFhcFgMAAAQkJCUFBQgF27djncCADX79KoqanBypUrcfz4cWRlZaGvrw9paWkOfzcRqc2trgzIrCJfs2YNmpqapjkj7cmO053qEh4ejp6eHpu35plMJsyaNQsDAwPaJaaBHTt23HK/j4/PhMWWspy9OJGI3IfHrhk4duyY1im4hOw43akuixYtQk1Njc1bvT7//PMpz4+7s0uXLtndbjKZ8NVXX6G/v9/hZsDZixOJyH0o3Qxs2LDB5lankZERZGdnWz9XVFQ47VjudMbsKlrX5N1338WqVatQUVGB2NhYnD9/Hp2dnTh48KBmOWnlo48+svlsNptRVVWF4uJi3HfffSgsLHT4GM5enEhE7kPpZuDmucovvvgCDz30kN1YRxsHdzljlh2nI3XRuiaJiYno7OzEt99+i3/++QerV69GRkYG9Hq9pnlp6cYmIDo6Gp988glWrlzplO+uq6uDxWIBAHz44YfWxYmlpaVO+X4iUpfSzcCzzz5r83nLli0Tto2TaRzcmew43b0uer0e69ev1zoNzZnNZlRWVmLnzp343//+h7KyMixfvtypxwgLC7P+Pr44kYi8g1stIAwPD0d/f/8dxd5useHNZ8z79u2z+afjzCmI6ST7aN5bxatWk4GBAezYscPurW4qvjtiOsXGxmJoaAhbtmxBenq63ZipvunMFYsTiUhtSl8ZuNmrr756x7G363Hc/Yx5nGwvd6t41WrywgsvYHh4GEVFRVi3bh3q6+uxe/durF69WrOctCKEgE6nQ3l5OcrLyyfsd+RNZ65YnEhEihMeqqSkRCo+PDx8mjKZXrLjlInXuiYRERHi8uXLQgghQkNDhRBC/Pfff2LhwoUaZuX5TCaTKC8vF3FxceL+++8Xhw4d0jolIppmSk8TnDt3DmfPnkVycjKMRiM6Ojpw5MgRJCQkOH2+VGYKwltoXROj0Yiuri4EBAQgJiYGP//8M0JDQ2E0GpV5qZInuXlxYkFBgdMWJxKR2pR9AuHevXuRlJSE4uJiLF68GLW1tcjIyMCxY8ewfv167N692yb+3Llz+Oabb9Dd3Q0A6OjowHvvvXfHj1GVmYLQkuw4HamL1jVJTU1FY2MjAOCxxx7Do48+ihUrVki/sIluzWw2o7y8HPPnz0dtbS3Kyspw9OhRNgJE3kTrSxOTueeee8SJEyeEEEL88ssvwt/fX5w6dUoIIcTp06dFTEyMNba8vFzodDqxdOlSERkZKWpqakRUVJRYt26dMBqNYteuXZqMwdlkx+lJdTGZTKK6ulp88MEH1qkDco6YmBgREREhioqKxI8//mj3h4g8m7LTBOOPQwWun7kEBARgdHTUutr9xv3z58/H/v37sXjxYhw/fhypqan49ddfkZCQgN9++w0ZGRk4f/68zfe7cgrCWWTHKRvvjjUhx8XExNjcRXIzRxYnEpGb0LobmcyyZctEUVGR+OOPP0RhYaGIjY0VjY2NQgghmpqaRGJiojVWr9dbfzeZTMLPz09YLBa7+4Vw3zNm2XHKxLtrTYiIyHHKNgMdHR0iISFB6PV6sW3bNtHa2ir0er2IiooSYWFh4vvvv7fGyjQOQshNQahEdpwy8e5aEyIicpyyzYA9fX19or29XQwODtpsl2kchJA/w1aF7Dhl4t21JkRE5DjlHzrU29uL9vZ29Pf3w2AwYMmSJROeTb9o0SKcOnXKZtvff/+NP//8E/fee++E+ISEBOzcuRNZWVmora3F3Llz8fXXX2Pt2rVobm5GXFzctI9rKmTHKROvUk30ej1vHSQiciFlFxACQH5+Pvbs2QOLxYJZs2ZZ322fl5eHkpKSCfH2GofxV7Le6OTJk3j66afR1dWF3NxcPPLII8jIyEBISAhGRkbw5Zdf4uGHH3bFEKfkTscpE69STXQ6HYaGhlxyLCIigroLCKuqqkRUVJRoamoSJpNJCHH98nVTU5OIjo4WlZWVNvGvvfaamDlzpvDz8xN333238PPzE3fddZd45ZVX7uh4k01BqEZ2nI7URaua6HQ6lx6PiMjbKdsMPPDAA6KhocHuvoaGBpGammr9LNs4jOvp6REHDhwQ+/btEwcPHhQ9PT1OH4czyY5zKnVRoSY+Pj5ixowZdn/G9xERkfMo2wyEh4dP+nCZy5cvi7CwMOtnmcZhnKNXErQgO07ZeFVqEhwcLP79999b/hARkfMo2wzcbvX6jZeSZRoHIaZ+JUFrsuOUiVepJpwmICJyLWXvJhgdHUVdXd2kr9w1mUzW381mM3Q6nd04nU4Hs9lss23v3r14//33kZmZad3m6+uLzMxMjI2NobS0FM8995zjg3Ay2XHKxKtUk8n+5kREND2UvZsgLS3tlo9IBYCWlhYAQGBgICoqKib9J5KTk4ORkRHrZ4PBgK6uLrv/KIeGhjBv3jwl32AoO06ZeJVqcvHiRcydO9clxyIiIoWbARkyjQNg+14De1S9z112nDLx7loTIiJynLLTBBcuXMDhw4ftXpquqqrCihUrrGePP/zwg9R3y0xBqER2nDLx7loTIiJynLJXBjZs2IBly5YhJydnwr7KykocPXoUlZWVAOQaB0D+DFsVsuOUiXfXmhARkeOUbQZiYmJw5swZBAYGTth35coVxMfHo6urC4Bc4+DOZMfpLXUhIiLHKNsMhISEoK+vDzNnzpywb3R0FAaDAcPDwwDkGgdA/gxbFbLjlIlXvSaJiYno6OjQ7PhERJ5shtYJTCYuLm7Sy9ItLS02L84Zf2eBPb6+vujt7bXZVlhYOOkcuBACBQUFU8x6esmOUyZe9Zrc2OQQEZFzKdsM5ObmIjs7G83NzbBYLAAAi8WC5uZm5OTkYPPmzdZYmcZhfNuTTz5pNz4rKwuHDx920iicS3acMvGq1+R26xmIiMgBLn7IkZS33npLBAUFCX9/fxEZGSn8/f1FUFCQKCoqson79NNPrU/PM5vNQgghzGazaGpqEnPmzBFlZWU28cHBweLatWt2j3nt2jURHBw8PQNykOw4ZeJVq0laWppIT0+3/vj7+9t8JiIi51H21kIAeP3115Gbm4u2tjb09vYiIiICKSkpCA0NtYnbuHEjuru7kZWVhbGxMevrjv39/ZGfnz9hAd34GfOqVasmHNPeGbYqZMcpE69aTbZv3279XQiBzMxMFBYWujQHIiJvoewCwqkYHBy8beMAAGVlZdi+fTs+/vhjZGRkYMaMGbBYLPjuu+/w4osvorCw0O4KfFXc6Thl4lWvicFgQF9fn2bHJyLyZB7VDMgoKirC22+/bfeMedu2bVqnpwmVaxIeHq7kI6KJiDyB1zYDgPwZtjdQtSZ1dXV44okntE6DiMgjeXUzQERERArfWkh0s+eff54vSyIimgZK301A3qm4uNju9vr6ehiNRoSEhCA/P9/FWREReS42A6ScN954A0uXLsWCBQts3qI4NjaGv/76C0FBQRpmR0TkebhmgJTT1taGrVu3Ijk5GW+++Sb0ej0AIDIyEidPnsTs2bM1zpCIyLNwzQApJyUlBT/99BPi4+ORnJyMsrIyCCH4SGIiomnCZoCU5OPjg02bNqG1tRUnTpxAUlKS9S2VRETkXJwmILfQ0dGBI0eOYNOmTQgICNA6HSIij8JmgJTV29uL9vZ29Pf3Izw8HElJSYiIiNA6LSIij8O7CUhJ+fn52LNnDywWi/XRyL6+vsjLy0NJSYnW6REReRSuGSDlVFdXo7q6GvX19bh69SouXbqEq1evYv/+/fjss89QVVWldYpERB6F0wSknAcffBB5eXl4/PHHJ+xrbGxEaWkpWltbNciMiMgzsRkg5RgMBnR1dUGn003YNzQ0hHnz5vENhkRETsRpAlKO2Wy22wgAgE6ng9lsdnFGRESejQsISTmjo6Ooq6vDZBetTCaTizMiIvJsnCYg5aSlpd32aYMtLS0uyoaIyPOxGSAiIvJyXDNAyrlw4cKktw9WVVXh4sWLrk2IiMjDsRkg5RQWFk66LkAIgYKCAhdnRETk2ThNQMqJiYnBmTNnEBgYOGHflStXEB8fj66uLg0yIyLyTLwyQMoZf/SwPb6+vujt7XVxRkREno3NACknLi5u0rsFWlpaEBcX5+KMiIg8G5sBUk5ubi6ys7PR3NwMi8UCALBYLGhubkZOTg42b96scYZERJ6FDx0i5WzcuBHd3d3IysrC2NiY9a2F/v7+yM/PR05OjtYpEhF5FC4gJGUNDg6ira0Nvb29iIiIQEpKCkJDQ7VOi4jI47AZICIi8nJcM0BEROTl2AwQERF5OTYDREREXo7NABERkZdjM0BEROTl2AwQERF5OTYDREREXo7NABERkZf7PwoOsXhp1HzXAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def create_dendroogram_plot(adata, use_rep, target_name):\n", + " sc.tl.dendrogram(adata, groupby=target_name, use_rep=use_rep)\n", + " sc.pl.dendrogram(adata, groupby=target_name)\n", + " plt.show()\n", + "\n", + "create_dendroogram_plot(test_data, use_rep='latent_omiiwae', target_name='level3')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/old_code/old_notebooks/evaluation.ipynb b/old_code/old_notebooks/evaluation.ipynb new file mode 100644 index 0000000..36fc8bb --- /dev/null +++ b/old_code/old_notebooks/evaluation.ipynb @@ -0,0 +1,1675 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [], + "source": [ + "from utils.data_utils import load_anndata\n", + "from train import load_config, create_model\n", + "from models.babel import BabelModel\n", + "import json\n", + "import yaml\n", + "import scanpy as sc\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "from argparse import Namespace\n", + "from itertools import cycle\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pytorch_lightning as pl\n", + "import seaborn as sns\n", + "import sklearn\n", + "import torch\n", + "from pytorch_lightning import LightningModule\n", + "from sklearn.decomposition import PCA\n", + "from sklearn.metrics import (\n", + " adjusted_rand_score,\n", + " auc,\n", + " normalized_mutual_info_score,\n", + " roc_curve,\n", + " silhouette_score,\n", + ")\n", + "from sklearn.preprocessing import label_binarize\n", + "from torch import nn\n", + "from torch.nn import functional as F\n", + "\n", + "from models.building_blocks import Block\n", + "\n", + "from sklearn.preprocessing import LabelEncoder\n", + "from sklearn.model_selection import train_test_split\n", + "from torch.utils.data import DataLoader, TensorDataset\n", + "\n", + "import scanpy as sc\n", + "import numpy as np\n", + "import torch\n", + "import torch.nn as nn\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import LabelEncoder\n", + "from torch.utils.data import DataLoader, TensorDataset\n", + "import pytorch_lightning as pl\n", + "from pytorch_lightning.callbacks import ModelCheckpoint\n", + "\n", + "from lightning.pytorch.loggers import TensorBoardLogger" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load data" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + } + ], + "source": [ + "test_data = load_anndata(\n", + " mode=\"test\",\n", + " normalize=True,\n", + " remove_batch_effect=False,\n", + " target_hierarchy_level=-1,\n", + " preload_subsample_frac=None,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + } + ], + "source": [ + "hierarchy = {\n", + " \"level1\": [\n", + " \"Hematopoietic Stem Cells and Progenitors\",\n", + " \"Hematopoietic Stem Cells and Progenitors\",\n", + " \"Hematopoietic Stem Cells and Progenitors\",\n", + " \"Hematopoietic Stem Cells and Progenitors\",\n", + " \"Monocytes and Dendritic Cells\",\n", + " \"Monocytes and Dendritic Cells\",\n", + " \"Monocytes and Dendritic Cells\",\n", + " \"Monocytes and Dendritic Cells\",\n", + " \"Monocytes and Dendritic Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"T Cells\",\n", + " \"B Cells and Plasma Cells\",\n", + " \"B Cells and Plasma Cells\",\n", + " \"B Cells and Plasma Cells\",\n", + " \"B Cells and Plasma Cells\",\n", + " \"B Cells and Plasma Cells\",\n", + " \"B Cells and Plasma Cells\",\n", + " \"B Cells and Plasma Cells\",\n", + " \"B Cells and Plasma Cells\",\n", + " \"B Cells and Plasma Cells\",\n", + " \"Natural Killer Cells\",\n", + " \"Natural Killer Cells\",\n", + " \"Erythroid Lineage\",\n", + " \"Erythroid Lineage\",\n", + " \"Erythroid Lineage\",\n", + " \"Erythroid Lineage\",\n", + " \"Innate Lymphoid Cells (ILCs)\",\n", + " \"Innate Lymphoid Cells (ILCs)\",\n", + " ],\n", + " \"level2\": [\n", + " \"HSC\",\n", + " \"Progenitors\",\n", + " \"Progenitors\",\n", + " \"Progenitors\",\n", + " \"Monocytes\",\n", + " \"Monocytes\",\n", + " \"Dendritic Cells\",\n", + " \"Dendritic Cells\",\n", + " \"Dendritic Cells\",\n", + " \"CD4+ T Cells\",\n", + " \"CD4+ T Cells\",\n", + " \"CD4+ T Cells\",\n", + " \"CD4+ T Cells\",\n", + " \"CD8+ T Cells\",\n", + " \"CD8+ T Cells\",\n", + " \"CD8+ T Cells\",\n", + " \"CD8+ T Cells\",\n", + " \"CD8+ T Cells\",\n", + " \"CD8+ T Cells\",\n", + " \"CD8+ T Cells\",\n", + " \"CD8+ T Cells\",\n", + " \"CD8+ T Cells\",\n", + " \"Special T Cell Types\",\n", + " \"Special T Cell Types\",\n", + " \"Special T Cell Types\",\n", + " \"Special T Cell Types\",\n", + " \"Special T Cell Types\",\n", + " \"Special T Cell Types\",\n", + " \"Naive B Cells\",\n", + " \"Naive B Cells\",\n", + " \"Transitional B Cells\",\n", + " \"B1 B Cells\",\n", + " \"B1 B Cells\",\n", + " \"Plasma Cells\",\n", + " \"Plasma Cells\",\n", + " \"Plasmablasts\",\n", + " \"Plasmablasts\",\n", + " \"NK\",\n", + " \"NK CD158e1+\",\n", + " \"Erythroblasts and Precursors\",\n", + " \"Erythroblasts and Precursors\",\n", + " \"Erythroblasts and Precursors\",\n", + " \"Reticulocytes\",\n", + " \"ILC\",\n", + " \"ILC1\",\n", + " ],\n", + " \"level3\": [\n", + " \"HSC\",\n", + " \"Lymph prog\",\n", + " \"G/M prog\",\n", + " \"MK/E prog\",\n", + " \"CD14+ Mono\",\n", + " \"CD16+ Mono\",\n", + " \"cDC1\",\n", + " \"cDC2\",\n", + " \"pDC\",\n", + " \"CD4+ T naive\",\n", + " \"CD4+ T activated\",\n", + " \"CD4+ T activated integrinB7+\",\n", + " \"CD4+ T CD314+ CD45RA+\",\n", + " \"CD8+ T naive\",\n", + " \"CD8+ T CD57+ CD45RO+\",\n", + " \"CD8+ T CD57+ CD45RA+\",\n", + " \"CD8+ T TIGIT+ CD45RO+\",\n", + " \"CD8+ T TIGIT+ CD45RA+\",\n", + " \"CD8+ T CD49f+\",\n", + " \"CD8+ T CD69+ CD45RO+\",\n", + " \"CD8+ T CD69+ CD45RA+\",\n", + " \"CD8+ T naive CD127+ CD26- CD101-\",\n", + " \"MAIT\",\n", + " \"gdT CD158b+\",\n", + " \"gdT TCRVD2+\",\n", + " \"dnT\",\n", + " \"T reg\",\n", + " \"T prog cycling\",\n", + " \"Naive CD20+ B IGKC+\",\n", + " \"Naive CD20+ B IGKC-\",\n", + " \"Transitional B\",\n", + " \"B1 B IGKC+\",\n", + " \"B1 B IGKC-\",\n", + " \"Plasma cell IGKC+\",\n", + " \"Plasma cell IGKC-\",\n", + " \"Plasmablast IGKC+\",\n", + " \"Plasmablast IGKC-\",\n", + " \"NK\",\n", + " \"NK CD158e1+\",\n", + " \"Proerythroblast\",\n", + " \"Erythroblast\",\n", + " \"Normoblast\",\n", + " \"Reticulocyte\",\n", + " \"ILC\",\n", + " \"ILC1\",\n", + " ],\n", + " \"description\": [\n", + " \"Hematopoietic Stem Cells\",\n", + " \"Lymphoid progenitors\",\n", + " \"Granulocyte-Macrophage progenitors\",\n", + " \"Megakaryocyte-Erythroid progenitors\",\n", + " \"CD14+ Monocytes\",\n", + " \"CD16+ Monocytes\",\n", + " \"Conventional Dendritic Cells, subtype 1\",\n", + " \"Conventional Dendritic Cells, subtype 2\",\n", + " \"Plasmacytoid Dendritic Cells\",\n", + " \"Naive CD4+ T Cells\",\n", + " \"Activated CD4+ T Cells\",\n", + " \"Activated CD4+ T Cells expressing integrin β7\",\n", + " \"CD4+ T Cells expressing CD314 and CD45RA\",\n", + " \"Naive CD8+ T Cells\",\n", + " \"CD8+ T Cells expressing CD57 and CD45RO\",\n", + " \"CD8+ T Cells expressing CD57 and CD45RA\",\n", + " \"CD8+ T Cells expressing TIGIT and CD45RO\",\n", + " \"CD8+ T Cells expressing TIGIT and CD45RA\",\n", + " \"CD8+ T Cells expressing CD49f\",\n", + " \"CD8+ T Cells expressing CD69 and CD45RO\",\n", + " \"CD8+ T Cells expressing CD69 and CD45RA\",\n", + " \"Naive CD8+ T Cells expressing CD127, not CD26 or CD101\",\n", + " \"Mucosal-Associated Invariant T Cells\",\n", + " \"Gamma Delta T Cells expressing CD158b\",\n", + " \"Gamma Delta T Cells expressing TCRVδ2\",\n", + " \"Double-Negative T Cells\",\n", + " \"Regulatory T Cells\",\n", + " \"Cycling Progenitor T Cells\",\n", + " \"Naive B Cells expressing CD20 and IGKC\",\n", + " \"Naive B Cells expressing CD20, not IGKC\",\n", + " \"Transitional B Cells\",\n", + " \"B1 B Cells expressing IGKC\",\n", + " \"B1 B Cells not expressing IGKC\",\n", + " \"Plasma Cells expressing IGKC\",\n", + " \"Plasma Cells not expressing IGKC\",\n", + " \"Plasmablasts expressing IGKC\",\n", + " \"Plasmablasts not expressing IGKC\",\n", + " \"Natural Killer Cells\",\n", + " \"Natural Killer Cells expressing CD158e1\",\n", + " \"Proerythroblast\",\n", + " \"Erythroblast\",\n", + " \"Normoblast\",\n", + " \"Reticulocyte\",\n", + " \"Innate Lymphoid Cells\",\n", + " \"ILC1\",\n", + " ],\n", + "}\n", + "hierarchy_df = pd.DataFrame(data=hierarchy)\n", + "test_data.obs = pd.merge(\n", + " test_data.obs, hierarchy_df, left_on=\"cell_type\", right_on=\"level3\", how=\"left\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GEX_n_genes_by_countsGEX_pct_counts_mtGEX_size_factorsGEX_phaseADT_n_antibodies_by_countsADT_total_countsADT_iso_countcell_typebatchADT_pseudotime_order...DonorRaceEthnicityDonorGenderQCMedsDonorSmokeris_trainlevel1level2level3description
036324.4704902.311520G2M1354152.024.0NKs4d1NaN...WhiteHISPANIC OR LATINOMaleFalseNonsmokertestNatural Killer CellsNKNKNatural Killer Cells
117818.8433790.789157G2M1386323.030.0NKs4d1NaN...WhiteHISPANIC OR LATINOMaleFalseNonsmokertestNatural Killer CellsNKNKNatural Killer Cells
213914.8913040.556811G11375038.048.0CD8+ T CD69+ CD45RA+s4d1NaN...WhiteHISPANIC OR LATINOMaleFalseNonsmokertestT CellsCD8+ T CellsCD8+ T CD69+ CD45RA+CD8+ T Cells expressing CD69 and CD45RA
317897.4125870.733487G2M1343586.026.0NK CD158e1+s4d1NaN...WhiteHISPANIC OR LATINOMaleFalseNonsmokertestNatural Killer CellsNK CD158e1+NK CD158e1+Natural Killer Cells expressing CD158e1
436443.9353152.522098G11342841.032.0HSCs4d10.352826...WhiteHISPANIC OR LATINOMaleFalseNonsmokertestHematopoietic Stem Cells and ProgenitorsHSCHSCHematopoietic Stem Cells
..................................................................
1506118558.7798920.702011G2M1242093.012.0Naive CD20+ B IGKC-s4d9NaN...Other RaceHISPANIC OR LATINOMaleFalseNonsmokertestB Cells and Plasma CellsNaive B CellsNaive CD20+ B IGKC-Naive B Cells expressing CD20, not IGKC
1506214844.9743690.508755S1242695.014.0CD8+ T naives4d9NaN...Other RaceHISPANIC OR LATINOMaleFalseNonsmokertestT CellsCD8+ T CellsCD8+ T naiveNaive CD8+ T Cells
150638018.8424430.232119G11323590.014.0T regs4d9NaN...Other RaceHISPANIC OR LATINOMaleFalseNonsmokertestT CellsSpecial T Cell TypesT regRegulatory T Cells
1506416308.5006110.549119G11335432.017.0CD4+ T naives4d9NaN...Other RaceHISPANIC OR LATINOMaleFalseNonsmokertestT CellsCD4+ T CellsCD4+ T naiveNaive CD4+ T Cells
1506517467.0742210.661751G2M1372665.010.0CD8+ T naives4d9NaN...Other RaceHISPANIC OR LATINOMaleFalseNonsmokertestT CellsCD8+ T CellsCD8+ T naiveNaive CD8+ T Cells
\n", + "

15066 rows × 30 columns

\n", + "
" + ], + "text/plain": [ + " GEX_n_genes_by_counts GEX_pct_counts_mt GEX_size_factors GEX_phase \\\n", + "0 3632 4.470490 2.311520 G2M \n", + "1 1781 8.843379 0.789157 G2M \n", + "2 1391 4.891304 0.556811 G1 \n", + "3 1789 7.412587 0.733487 G2M \n", + "4 3644 3.935315 2.522098 G1 \n", + "... ... ... ... ... \n", + "15061 1855 8.779892 0.702011 G2M \n", + "15062 1484 4.974369 0.508755 S \n", + "15063 801 8.842443 0.232119 G1 \n", + "15064 1630 8.500611 0.549119 G1 \n", + "15065 1746 7.074221 0.661751 G2M \n", + "\n", + " ADT_n_antibodies_by_counts ADT_total_counts ADT_iso_count \\\n", + "0 135 4152.0 24.0 \n", + "1 138 6323.0 30.0 \n", + "2 137 5038.0 48.0 \n", + "3 134 3586.0 26.0 \n", + "4 134 2841.0 32.0 \n", + "... ... ... ... \n", + "15061 124 2093.0 12.0 \n", + "15062 124 2695.0 14.0 \n", + "15063 132 3590.0 14.0 \n", + "15064 133 5432.0 17.0 \n", + "15065 137 2665.0 10.0 \n", + "\n", + " cell_type batch ADT_pseudotime_order ... DonorRace \\\n", + "0 NK s4d1 NaN ... White \n", + "1 NK s4d1 NaN ... White \n", + "2 CD8+ T CD69+ CD45RA+ s4d1 NaN ... White \n", + "3 NK CD158e1+ s4d1 NaN ... White \n", + "4 HSC s4d1 0.352826 ... White \n", + "... ... ... ... ... ... \n", + "15061 Naive CD20+ B IGKC- s4d9 NaN ... Other Race \n", + "15062 CD8+ T naive s4d9 NaN ... Other Race \n", + "15063 T reg s4d9 NaN ... Other Race \n", + "15064 CD4+ T naive s4d9 NaN ... Other Race \n", + "15065 CD8+ T naive s4d9 NaN ... Other Race \n", + "\n", + " Ethnicity DonorGender QCMeds DonorSmoker is_train \\\n", + "0 HISPANIC OR LATINO Male False Nonsmoker test \n", + "1 HISPANIC OR LATINO Male False Nonsmoker test \n", + "2 HISPANIC OR LATINO Male False Nonsmoker test \n", + "3 HISPANIC OR LATINO Male False Nonsmoker test \n", + "4 HISPANIC OR LATINO Male False Nonsmoker test \n", + "... ... ... ... ... ... \n", + "15061 HISPANIC OR LATINO Male False Nonsmoker test \n", + "15062 HISPANIC OR LATINO Male False Nonsmoker test \n", + "15063 HISPANIC OR LATINO Male False Nonsmoker test \n", + "15064 HISPANIC OR LATINO Male False Nonsmoker test \n", + "15065 HISPANIC OR LATINO Male False Nonsmoker test \n", + "\n", + " level1 level2 \\\n", + "0 Natural Killer Cells NK \n", + "1 Natural Killer Cells NK \n", + "2 T Cells CD8+ T Cells \n", + "3 Natural Killer Cells NK CD158e1+ \n", + "4 Hematopoietic Stem Cells and Progenitors HSC \n", + "... ... ... \n", + "15061 B Cells and Plasma Cells Naive B Cells \n", + "15062 T Cells CD8+ T Cells \n", + "15063 T Cells Special T Cell Types \n", + "15064 T Cells CD4+ T Cells \n", + "15065 T Cells CD8+ T Cells \n", + "\n", + " level3 description \n", + "0 NK Natural Killer Cells \n", + "1 NK Natural Killer Cells \n", + "2 CD8+ T CD69+ CD45RA+ CD8+ T Cells expressing CD69 and CD45RA \n", + "3 NK CD158e1+ Natural Killer Cells expressing CD158e1 \n", + "4 HSC Hematopoietic Stem Cells \n", + "... ... ... \n", + "15061 Naive CD20+ B IGKC- Naive B Cells expressing CD20, not IGKC \n", + "15062 CD8+ T naive Naive CD8+ T Cells \n", + "15063 T reg Regulatory T Cells \n", + "15064 CD4+ T naive Naive CD4+ T Cells \n", + "15065 CD8+ T naive Naive CD8+ T Cells \n", + "\n", + "[15066 rows x 30 columns]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_data.obs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "View of AnnData object with n_obs × n_vars = 15066 × 14087\n", + " obs: 'GEX_n_genes_by_counts', 'GEX_pct_counts_mt', 'GEX_size_factors', 'GEX_phase', 'ADT_n_antibodies_by_counts', 'ADT_total_counts', 'ADT_iso_count', 'cell_type', 'batch', 'ADT_pseudotime_order', 'GEX_pseudotime_order', 'Samplename', 'Site', 'DonorNumber', 'Modality', 'VendorLot', 'DonorID', 'DonorAge', 'DonorBMI', 'DonorBloodType', 'DonorRace', 'Ethnicity', 'DonorGender', 'QCMeds', 'DonorSmoker', 'is_train'\n", + " var: 'feature_types', 'gene_id'\n", + " uns: 'dataset_id', 'genome', 'organism', 'log1p'\n", + " obsm: 'ADT_X_pca', 'ADT_X_umap', 'ADT_isotype_controls', 'GEX_X_pca', 'GEX_X_umap'\n", + " layers: 'counts'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "mask = test_data.var[\"feature_types\"] == \"ADT\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: False, used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n" + ] + } + ], + "source": [ + "from argparse import Namespace\n", + "\n", + "from models.babel import BabelVAE\n", + "\n", + "args = Namespace(\n", + " **{\n", + " \"config\": \"babel_vae\",\n", + " \"method\": \"babel\",\n", + " \"path\": \"logs/BabelVAE/version_0/checkpoints/epoch=4-step=2585\",\n", + " }\n", + ")\n", + "\n", + "config = load_config(args)\n", + "model = BabelVAE.load_from_checkpoint(\n", + " \"logs/BabelVAE/version_0/checkpoints/epoch=4-step=2585.ckpt\", cfg=config\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compute Latent" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\Documents\\Projects\\D4L-Hackaton\\src\\models\\babel.py:145: ImplicitModificationWarning: Setting element `.obsm['latent_embedding_adt']` of view, initializing view as actual.\n", + " anndata.obsm[\"latent_embedding_adt\"] = adt_latent\n", + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + } + ], + "source": [ + "model.encode_anndata(anndata=test_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "test_data.obsm[\"latent_embedding_adt\"] = np.random.randn(15066, 16)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(15066, 16)" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_data.obsm[\"latent_embedding_adt\"].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.00075617, -0.00012047, -0.00157885, ..., 0.00145785,\n", + " 0.00113771, -0.00021118],\n", + " [-0.00183929, -0.00210283, -0.00253586, ..., 0.00120097,\n", + " 0.00213714, 0.0005422 ],\n", + " [ 0.00249436, -0.00069681, 0.00244574, ..., -0.00321709,\n", + " -0.00191487, 0.00041383],\n", + " ...,\n", + " [-0.00079689, 0.00165317, -0.00082831, ..., -0.00021885,\n", + " 0.00055164, 0.00090701],\n", + " [ 0.00143119, -0.00046476, 0.00708481, ..., 0.00776629,\n", + " 0.00340727, -0.00622026],\n", + " [ 0.00187882, 0.00162486, 0.00180858, ..., 0.00034421,\n", + " 0.00015332, -0.00174637]], dtype=float32)" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_data.obsm[\"latent_embedding_adt\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize latent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### UMAP" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:1217: FutureWarning: The default value of 'ignore' for the `na_action` parameter in pandas.Categorical.map is deprecated and will be changed to 'None' in a future version. Please set na_action to the desired value to avoid seeing this warning\n", + " color_vector = pd.Categorical(values.map(color_map))\n", + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:392: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n", + " cax = scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pp.neighbors(\n", + " test_data, use_rep=\"latent_embedding_adt\", n_neighbors=15\n", + ") # use_rep specifies that the calculation is based on the latent embedding\n", + "sc.tl.umap(test_data, random_state=1) # set random state to ensure reproducibility\n", + "sc.pl.umap(test_data, color=[\"cell_type\"], size=10, ncols=1, title=\"ADT latent by UMAP\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:1217: FutureWarning: The default value of 'ignore' for the `na_action` parameter in pandas.Categorical.map is deprecated and will be changed to 'None' in a future version. Please set na_action to the desired value to avoid seeing this warning\n", + " color_vector = pd.Categorical(values.map(color_map))\n", + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:392: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n", + " cax = scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pl.umap(test_data, color=[\"level1\"], size=10, ncols=1, title=\"ADT latent by UMAP\")" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:1217: FutureWarning: The default value of 'ignore' for the `na_action` parameter in pandas.Categorical.map is deprecated and will be changed to 'None' in a future version. Please set na_action to the desired value to avoid seeing this warning\n", + " color_vector = pd.Categorical(values.map(color_map))\n", + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:392: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n", + " cax = scatter(\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+QAAAGtCAYAAACflb6cAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd5gd9X3v8ffM6X3b2V61u9pV7w0VJCGKkEQXvRiwTVyxk5vcxDdxnGonufa1Hds4tikG04tpogmQUEG9d2lX23s5vZ+ZuX+sWLwR2GADssn39Tx6Hvac3/zmN2fm2eVzfk0xDMNACCGEEEIIIYQQnyj1XDdACCGEEEIIIYT4n0gCuRBCCCGEEEIIcQ5IIBdCCCGEEEIIIc4BCeRCCCGEEEIIIcQ5IIFcCCGEEEIIIYQ4BySQCyGEEEIIIYQQ54AEciGEEEIIIYQQ4hyQQC6EEEIIIYQQQpwDEsiFEEIIIYQQQohzQAK5EO/hhz/8IYqiMHny5PctoyjK6D+TyURubi7Tpk3jrrvuYvv27WPKLl26dEz59/v3rW99633P95nPfIbq6urf63oeeeQRvv/97/9ex35YR48e5Vvf+hatra0fqPy3vvUtFEVhcHDwY23X0qVL3/d+Dg4OnvX5P/DAA6P3ZePGjWcdYxgGdXV1KIrC0qVL37dem82Goijs3r37Pct85jOfGfMM2Gw2Ghoa+Pu//3uSyeSHvUwhhBBCCPEnRAK5EO/hvvvuA+DIkSPs2LHjfctdc801bNu2jS1btvDYY49x6623sn37dhYsWMDdd989Wu4nP/kJ27ZtG/33t3/7twDcf//9Y17/7Gc/+7FczycdyP/hH/7hAwfyP3Yej4d77733rNffeustmpub8Xg873vsQw89RDqdBnjPOt7hcDhGn4Fnn32WefPm8Y//+I/cdtttf/gFCCGEEEKIP1rmc90AIf7Y7N69mwMHDrBq1SrWrVvHvffey7x5896zbFFREfPnzx/9+eKLL+ZrX/san//85/nhD39IY2MjX/jCF5g4ceKY444fPw7A5MmTmT179sd3MeIPdt111/Hwww/z4x//GK/XO/r6vffey4IFCwiHw+977H333UdhYSFVVVU8+uijfO9738PhcJxVTlXVMc/RypUraW1t5YknnuB73/seZWVlH+1FCSGEEEKIPwrSQy7Ef/NOT+Z3vvMdzjvvPB577DHi8fgHPt5kMvGjH/2IgoIC/uM//uPjaiYAP/7xj1myZAmFhYW4XC6mTJnCv//7v5PJZEbLLF26lHXr1tHW1jZmaPQ70uk0//zP/0xjYyM2mw2/38/tt9/OwMDAmHNVV1ezevVqXnnlFWbOnInD4aCxsXF0NAGMDPNeu3YtAMuWLRs91wMPPPA7r6Wjo4OrrroKr9eLz+fj5ptvHtOGO++8k7y8vPe8F8uXL2fSpEkf+HP7MG644QYAHn300dHXQqEQTz/9NHfcccf7Hrdjxw4OHz7MLbfcwuc+97nRYz6odwJ6W1vb79lyIYQQQgjxx04CuRC/IZFI8OijjzJnzhwmT57MHXfcQSQS4cknn/xQ9TgcDlasWEFLSwudnZ0fU2uhubmZG2+8kYceeogXX3yRO++8k//4j//grrvuGi3zk5/8hIULF1JcXDxmeDyArutcfvnlfOc73+HGG29k3bp1fOc732H9+vUsXbqURCIx5nwHDhzgL/7iL/j617/Oc889x9SpU7nzzjvZtGkTAKtWreJf//VfgZEvC94516pVq37ntVx55ZXU1dXx1FNP8a1vfYtnn32Wiy++ePTLhbvvvptAIMAjjzwy5rijR4+yYcMGvvSlL/3+H+Rv4fV6ueaaa8Z88fDoo4+iqirXXXfd+x73zhc7d9xxB9dffz1Op/O3Dlv/75qamgDw+/2/Z8uFEEIIIcQfOxmyLsRveOqppwiFQtx5553AyHDlr33ta9x7770fej5vVVUVAN3d3ZSXl3/kbQX43ve+N/rfuq6zePFi8vPzuf322/nud79Lbm4uEydOJCcnB5vNNmZYNMATTzzBK6+8wtNPP81VV101+vq0adOYM2cODzzwAF/4whdGXx8cHGTr1q1UVlYCsGTJEt544w0eeeQRlixZgt/vp76+HoCJEyeedb7f5qqrruLf//3fAbjooosoKiripptu4oknnuCmm25i6tSpnH/++fz4xz8eM9f+Rz/6EV6vl1tvvfVDfHIfzh133MGyZcs4cuQIkyZN4r777mPt2rXvO388Ho/z+OOPM3/+/NHpCmvXruXBBx+kubmZ2tras47JZrMABINBHnnkEZ599lnmzJkz+nkKIYQQQohPH+khF+I33HvvvTgcDq6//noA3G43a9euZfPmzZw6depD1WUYxsfRxDH27dvHZZddRn5+PiaTCYvFwq233oqmaZw8efJ3Hv/iiy+Sk5PDmjVryGazo/+mT59OcXHxWauLT58+fTSMA9jtdsaPH/+RDKu+6aabxvx87bXXYjab2bBhw+hrd999N/v372fr1q0AhMNhHnroIW677Tbcbvcf3Ib3c/7551NbW8t9993HoUOH2LVr128drv7EE08QDofHlLnjjjswDIP777//rPKxWAyLxYLFYsHv9/O1r32NlStX8utf//pjuR4hhBBCCPHHQQK5EGc0NTWxadMmVq1ahWEYBINBgsEg11xzDcCYIcsfxDshtbS09CNvK0B7ezuLFy+mq6uLH/zgB2zevJldu3bx4x//GOCs4ebvpa+vj2AwiNVqHQ2E7/zr7e09ayuy/Pz8s+qw2Wwf6Fy/S3Fx8ZifzWYz+fn5DA0Njb52+eWXU11dPXqNDzzwALFY7AMNVzebzWia9p7vvdM7bbFY3vN9RVG4/fbb+dWvfsVPf/pTxo8fz+LFi9/3XPfeey92u51LLrlk9DmaOnUq1dXVPPDAA2e1w+FwsGvXLnbt2sXBgwcJBoOsW7dOFnMTQgghhPiUkyHrQpxx3333YRgGTz31FE899dRZ7//yl7/kn//5nzGZTL+zrkQiweuvv05tbe3HNlz92WefJRaL8cwzz4wOjwfYv3//B66joKCA/Px8Xnnllfd8/7dt6fVR6+3tHRNAs9ksQ0NDY74EUFWVL33pS3zjG9/gu9/9Lj/5yU+44IILaGho+J31FxUVsWvXLgzDGLOoHUBXV9domffzmc98hm9+85v89Kc/5V/+5V/et9zJkyfZsmULwJjRBL/p1Vdf5dJLLx1zXbLavhBCCCHE/zwSyIUANE3jl7/8JbW1tfziF7846/0XX3yR7373u7z88susXr36d9b15S9/maGhIb797W9/XE0eDZU2m230NcMw+PnPf35W2ffrxV69ejWPPfYYmqa979ZuH9Y77fmwveYPP/wws2bNGv35iSeeIJvNsnTp0jHlPvvZz/Ktb32Lm266iRMnTvBv//ZvH6j+FStW8Mgjj/DKK6+wcuXKMe898cQTqKrK8uXL3/f4srIy/vIv/5Ljx4//1vUE3lm47ec//zl1dXVj3kskElx++eXcd999YwK5EEIIIYT4n0kCuRDAyy+/THd3N//2b/92VgCEkf3Cf/SjH3HvvfeOCeR9fX1s374dwzCIRCIcPnyYBx98kAMHDvD1r3+dz33ucx9bmy+88EKsVis33HADf/VXf0UymeSee+4hEAicVXbKlCk888wz3HPPPcyaNWu0R/b666/n4Ycf5tJLL+Xuu+9m7ty5WCwWOjs72bBhA5dffjlXXnnlh2rX5MmTAfjZz36Gx+PBbrdTU1PznsPdf9MzzzyD2Wzmwgsv5MiRI/zd3/0d06ZN49prrx1TLicnh1tvvZV77rmHqqoq1qxZ84HaddNNN/GTn/yEa6+9lr/+679mzpw5JBIJXnrpJX7+85/zla98hXHjxv3WOr7zne/81vez2SwPPvggEyZMGLPw3G9as2YNzz//PAMDA7KCuhBCCCHE/3Ayh1wIRno1rVYrt99++3u+X1BQwJVXXsmLL75IX1/f6OtPPfUUCxYsYNGiRaxdu5YHHniAefPmsW3btjEroH8cGhsbefrppwkEAlx11VV85StfYfr06fzwhz88q+zdd9/NNddcwze+8Q3mz5/PnDlzgJE9059//nm+8Y1v8Mwzz3DllVdyxRVX8J3vfAe73c6UKVM+dLtqamr4/ve/z4EDB1i6dClz5szhhRde+J3HPfPMMxw/fpyrrrqKb37zm6xZs4bXXnsNq9V6Vtl3thv7whe+gKp+sF9jVquVN998ky9+8Yv88pe/ZM2aNdx4443s3buXe+65h+9///sf6jrfy7p16+jt7R2z7dx/9/nPf55MJsNDDz30B59PCCGEEEL8aVOMT2IpaCGE+Aj9xV/8Bffccw8dHR2/s+ddCCGEEEKIP1YyZF0I8Sdj+/btnDx5kp/85CfcddddEsaFEEIIIcSfNOkhF0L8yVAUBafTyaWXXsr999//se49LoQQQgghxMdNesiFEH8y5PtDIYQQQgjxaSKLugkhhBBCCCGEEOeABHIhhBBCCCGEEOIckEAuhBBCCCGEEEKcA+dkDrmu63R3d+PxeFAU5Vw0QQghhBAfkmEYRCIRSktLUVX5Tl8IIYT4Q52TQN7d3U1FRcW5OLUQQggh/kAdHR2Ul5ef62YIIYQQf/LOSSD3eDzAyB90r9d7LpoghBBCiA8pHA5TUVEx+ndcCCGEEH+YcxLI3xmm7vV6JZALIYQQf2JkupkQQgjx0ZAJYEIIIYQQQgghxDkggVwIIYQQQgghhDgHJJALIYQQQgghhBDngARyIYQQQgghhBDiHJBALoQQQgghhBBCnAMSyIUQQgghhBBCiHNAArkQQgghhBBCCHEOSCAXQgghhBBCCCHOAQnkQgghhBBCCCHEOSCBXAghhBBCCCGEOAckkAshhBBCCCGEEOeABHIhhBBCCCGEEOIckEAuhBD/QwXSgxyPHEI39HPdFCGEEEKI/5HM57oBQgghPhjDMFAU5SOrb+PgK/Sne7Cb7FQ76z+yeoUQQgghxAcjgVwIIf5IJLUEr/U/R7G9jLm5i4GRXuxAZphjkQMMpvtZW3obTrP7A9VnGAbA+4b4id7puOMeimxlH80FCCGEEEKID0UCuRBC/JEIZ4P0pDpI6LHRQP7awHMEM8N4zTlkjDRZI/uB6srqGS7/xXO091p59asrKM1xnlWmwT2ZBvfkj/QahBBCCCHEByeBXAghzoHm2HFUVGpc40dfK7SVsLroOjxm7+hrBeZyrIqTCwtXoyoqTpNr9L1QPIPDasJqPns5EB2D4YhKPKkSS2fGvPfZX+6iP5Lisc/Px2kd+TOQ0pIEMkP4bcWYFNNHfblCCCGEEOI9SCAXQohPWFJL8PrACwDc4fgaFtUCQDZhUOaoHC3XEx3my/cksVocXPq/rewMbqLEXkGdq5HWwRiX/GATU8p8PPln5511Dqtq5bIJ49nbHqLQ/W7vuGEY7GsPEklmiSTSo4H8kc6fkTZS1DjryegZPGYfC/MveN9wntDi7A5uodbZSOlvtPk3z5PWU9hM9t//gxJCCCGE+JSTVdaFEOITZjc5qLXOYqCjlkOdUQA63zL49Sqdow++u+K5y+zEZjbhtFjoSXVwNLKfPcG3ATCbFFA0QnovGT39nudZf3SQXa1BWoZio68pisK6ry7m0a/W8nzgp+wYfoum2HHSRmqkXsVCZ7KVY9ED7AxsAmBP2zDffvkYkeS7Pe0t8VMcjRxgX2jHe5576/Ab/LLjR3QkWv6AT0oIIYQQ4tNNesiFEOIcOH68ghdeaMVU8UPMt60kV5sNBuhZ0A2ddX1PYBiw86+vwaSa2DD4IgCltnIA8jwGX73tGKoKST2JRbUCoBkah0N7aUmc5B+unUE06mR6Rc6Ycxf77KQsJvSERlJPYlftmDAxM2cBM3MWMJQaYDg7QCKjMZwM8dcvbOZUp5k6v5u1sysAqHNNIK5FqXbUvef1KagYGCjGR7cqvBBCCCHEp40EciGE+ISl9BSFtXu4PLMZ644BNtVGuWvNdC6bZcFwJ4ll0wykejEARdUxqWZ8llwAjkYPMD1nHk6Tm0pXFQCbB18jkBlkkmcmxyIHCGtBAProBicc6l9CvWMCds+7c9OrnLUsd9/O5x84REPRID+56euo6kh4rnDWEAoH+MfHQ9QWbWHerA5KCgqZU6/SEjvFluH1zMpZyOychQDEtRjbhjdQ62qg2lmPZmQZSvdhVWys638Sm2pnZe4dXP6f25lQ4uH+2+d+ch+2EEIIIcQfMQnkQgjxEUplNVb9cAtmVeHFryzCbDp7ZtDmwdcIGB3k3liJ7YCfxlkX8mLvE0zxzuLtrjfR0Li48GpcJtdoz/ec3EUktDiRbJCtQ2/gMfu4yH8Fj3X9nIQeR0Flb/BtMmRwqi6cZjeD6T4Ajpx+m+7enSxYeTNeW+5oO/rDadoDUVoG4/xwx5t8ds4cBlMDHAjvJMdUSFlRCkc0n0V9Oia1j9cCjzLePYm4FmPz0Hq8Zh+FthI6E600xY4R12LYVAcv9j6ORbWS1NKoKqT0JIcjuxiOpekKJt73s+tItGDC9J5z0oUQQgghPo0kkAshxEcoqxnEtQiZhAXNMDgZOcDewDZKHRXkWQuY7ptHqaOSgXQvWoWbWGmUQ9n9AOwMbCZtpLGpdtb1Pc44ZwORbIikHufq0s+wpOAiwpkgj3b9HBNmDkf2kmvJx25yMi93CZuH1qNpOpcV34COjmZkCaeDrOd5wv4sufHDzLUtHm1rt+1VLjxP4/ApL1l3Ew937qXAWjQyVL4pQUlxnK/PPI/g1jAt1kGSMRudavuZow3W9TyJR3NxXd3nSelJyuxVxLUYBgbl9moees2MYe9n+ZwoqiXOW3+5jE7tEM2xE9S6GoCRIfYmxURCi/NS31OoqNxeeTdmVf48CSGEEOLTTxZ1E0KIj1Br6hDnL2insSZBMq0zkOolpkc4FTvKzsBmNENjomcaN5R/jnHOhtHjJrinYWCgGxqL8lagKiYsqpVQNkAkG2Yg1QPA8eghFFQ8Zt/IcZ5pXFt2O63xJmJahFxLPp3JNp7ovo9dwS1UuGowK2YME1Q768e01WfJY/FUjfs/O5kVlQswKSYsioUD+8bx9KvldHQ7WTf0FNYFE/nW3gq+91AZujYSlN26G5MG1oTK4fBevOYc8qwFlDuquKXii2hGlvMWHeYbK84jbSQ4GTuCZutnb+QtNgy+RMdwnFdbt/OLtu/RHDuBXXUw0TONSd4ZEsaFEEII8T+G/F+PEEJ8hDoSrWzdU0B7j4XXG/q4fMZyGtyTCWeCWFQLsWyEbYEN1Lsmkmst4LrSO1EUBZ8ll1g2SkpPkmct4A7n3aiKSmYgQ3PsGP2pXsocVSS1BAY6wewQAMfCB2h0T8FpcuEz5zKU6WfL8HpUTPgsuVhUK1cX3EJSTWFSxn4He1Hh5aP//XjnvWiGRk+qk6SSDxSRihRg0M8z+9sYjKZZ3ljI2opl9Ka62DC4Dk2F8twGtgfewqE6mZ+3lL5kN9N8c/FZcrGl7LisZiZ4ppFjyaPMXslM3wKaI6e58Psb0HSDr9yqktQSDKR7WZx/0Sd5q4QQQgghzjkJ5EII8QfI6GkOhHZR6RxHoa2EhfkX8KULD9DRmc/KKcWYVTPF9jKK7WUAHA7vpTXeRCgTIJQYovGkn5qyKfimzSKhxWiOn2C6ae7o/t3l9iqaY8foSXbSqE1mUf4KGt1TeaXvaRJGnEB2iJ2BTRyO7MNnzmW8azKn4ycY52rgvLzl9Bw9xM7ON+itz4ACHpOXKb7ZTPHOwjAMMnqalJ6kwFYEikKts5E5i9yMd2XIKzvOhQWX0ZbMZUvZSe5YWoiGxtHIPopt5RgYHIjuxqxYmOCZxuah9WSNDEej+7mq5Bbm5y3l8ebn6M02cWHJBSiKQqNnKrsD2yj229F08Ntz6Uq2smV4PbN9CzkU2cOsnPOY4p11Lm+rEEIIIcQnQgK5EEL8AVrip9gTepvuZDuXldxAR+I0IecOLj/vUpzWsb9i1/U+SUpPcl7uMnyWPI5GtqP2BOiLHqV82ix2B7fSlmjGZXIz2TuThBbnaOQANtVOb6qThzruYU7OYhJabGRYtwbjXZPIs/oBsCl2irocpHPKaIs3sT+4k9bBTnalHVQqI3uIR7QwnYlWxrsm8WT3/aT1NFkjw5UlNzOQ6qUn1cni/NmcnPggoWyAQ5G9XN54AzWVIV7tf4LwYA2dyTZyLQXM8M07M6Q+xGC6D4tiIWtkMGPGrFjoCSX4u/steJzjaa3PoBoH+PbVE5noncqfLXcRSCRZUbSEzkQrg+l+UEYWgAtmht/zsx5K9+MyebCbHB/vTRVCCCGE+IRIIBdCiA/hZPQIuqHT6JkCQJWjlkmeGZTZq9g89BpZPYuBQTgbHHOcbugMpHvJGlnq3BNxmJxUNo5jyH4au9dHf6oXzdBodE2l1tUIQDAzzEC6hzxLAcFMAAODncFNo3W6TB4meWbQkWhhnLOe0/EmIvSRQAcdTgY7eXk4yIbtZdxRkqIoP8WcnMVM8ExFRyetpzEwsKkOrKqNg+HdhLIBJrinMtk7k0PhPUzzzkEzNKyqHbNiJqUnz7RtiDcH13F58Y20xpvoT/XQ4JrMOHcDaS1FU+wYNZaZFHrsVOY5eW5vP3k5Ce5vex1UncGUjadfL+eCChcVOTXkWf1UOWupdtaRY8knocXYH9rJePck8q2F9Kd6+HXPr/Bbi7mq9JZP5mYLIYQQQnzMJJALIcQHlNHTbBh8CYBqZx12kwObyc6i/BWcih7laOQAhdYSTJg4HN7LDN981DPztruT7TS6p9LomoLD5ARAzxh0vVqNd0KG9ZU/QkfHqtjoS3eT0hIoisqC3KVUO+tpT7Swdfh1bKodp+omkB0kocXZOvwG/ekeTJgAA6vLjUGGx18r5kSrha9dlUfp+U4q8xxkyeI1+3ik82dM9EzDptpIaAnWlt2Gjk6Zo5pJ5pmU2CsodVTitxbzbO/D6OFq3ny7jJsWribsfQ0AAwNzpoAccwGFtij7Qzs5MdTDj3bYWTCvifZAkBnVzbz5l9djVW3M/9c3CMY0DEVHAQryUnz+6h7qC9081PEgCT3OtaW3k28tBOBE9DAHw7uJZaOsKFyD0+Qmx5JHka30k77tQgghhBAfGwnkQgjxAVlUKwtyl6Kjs/lEmJcPneCrK+rZ2taEs/AoHpOPmuEi3D1xkhO9vDX0Kk6Ti3m5S3h94HlSeopwNsBFhVcAMHgEDh9oI9XwNjo6AGkjRTaTPfOzwbHIQZpix9EMjYv9V+C3FWNRrTzV9UsiWoj+dC8mTFQ6amlJnCRkiQAKLleCixYHMedE+adZdwNLyRoZ+lM9ZI0MoUwQu8kJKJgUM9uG19MUO06+xU9vqpMp3lmYFTMqKttPR9jVGiDPl2bmgjgmzGT0LK1DUd5KB1jaWIVVsRONKQxEUuzdX0nd1AGCWj+hTAC/rZif3zqbgz19lLrN1DjHczS6H7+vGEVRaD3ZyGv7Eyy52URu8chnPd49mbgWY7xrEgBus4fryu78hO+4EEIIIcTHSwK5EEK8h75UNzuGNzEr5zzKHJWjr0/1zQFg5a9e5liHTntoiN2nk9x25SClRUmih1twxjJMapzOC9EXAIhmw4x3T+FQeDduk2+0LrVxEP2Lm0i7+0d+RkVHx28rZnbOQl7qe4pg9t351C3xU5Q7qnmx7wk8Zh8W1UqZvZLz8peT0TMMdPUS16LM9C3AteQgMS0CQFyL4jZ7sSo2yh3V3Fj+eZ7tfpiknqA+u5avPrqfmQtOgQmGMgMMZQZI6nHWFF/PBf41KNNeZXp+LsloHtmuJShlW1AVKPAZTCxyMRxLcUf1VxjIT/FX002cHojxQnOUGr+C31aMZmh0Wd7AKO7nZCzC+sNBJldamVlWA0B7l4/OwSRNfQkmFOcC4DS5mJ+7lA2DL6GgsKzgUhRFIa2nsarWj+/GCyGEEEJ8giSQCyHEe2iPn6Yn1UFrvGlMIH/H+QvaKK2wkOdNEUtMYEJOIyH20zMhy0LTIkrKxjNzeAkvNu8klXuCCncxNsWOy+werWN7cCMxdz9FllLSRooG9xR6010oBpyKHMFAR8WEVbWS1BOYsZAxMgykelFQuK3iy1hMVqLZCG6zhxpXPYfCe+hNdZHQYlgUC4vzL8Jt9gKQ0GJsHX6TGud48qx+BtP9vHKkiy2n+5h+noYKFFlL6Ut3M5jqJ6tnGecaz8YuC/9v3VEggMWk8Oo3VrNteCM4wrwY/Cm6rjAruJb5lVUATCn3sVs/RUsqRXu8nmg2QluiGQA9kUd/NE7E1MWxiJNiexn/cc1UjnSHWViXP+YzzuhpTsdOAAqL8y9kd+BtDoV34wkvYVnVVIp99o/j1gshhBBCfGIkkAshxHuY7ptLUk/Qk+xgINWH31YEQEKLM5weYFFVHfl5Byl3VPPtJYv48ds7+NErE7jjYoX6qSle6/gp2w5beHXzOMbXhLn+4gEypP7bCuIGAKqqssp/LS6zm6p0LY933ztaQkfDrjpI6UmOxvZjKMbI3G89QWeyjbgWZcvw6xRZy6hy1LIs/1JORY+iozPVPZtcSz6v9T9PLBum0TOV5thx4tkoLrOHpB5n4tTjeF11FJrTaLFyQsp+ADJGmnvb/x/n56/EwAXA6qklXDypmMFUM1EtDICijLSzzdjK4R3DRCMu7r6gHqfqJK2nCGWCRLIhzFjIkmFV+Upef3svLadt9Dl6aGvfzWdmzWZRfQGdiTbyLPk4z3xpYTPZuazkBlRUhiI6w7EUhgG/2HKatw6Y+OktsjWaEEIIIf60SSAXQoj3YFGtZI0sQ5l++lJd+G1F7A5sZU/obQAUFFYXXUepo4IDoV3s6TtFJltInj6eA6HXSBlxyott+DxpSgsTaGSxKFbMigmA/mQEXXfjMnnoSXWyP7STmBamN9lFjjmPYHYYBQUDY8yw9WPRA8DI/uTl9ipa4qc43eEi4e+hL92FRbGxMG85nalW9kd2sj+yc/TY822XUGGvoSPZAimwqXYS+iDVDRk84cv48mM7+cotaWxWFRMqWbJsHnqVG+ffxTUzL8LntKAbOo93rcOuOnAauQwb/TR46mlOHONwOMLrW4u5fk4li/IvYkfgLXpTXZyOn8BrziGhxUjqCS5YdoxMRsVu0+nsOwTMpj3ewsv9T2Ek8vnpE+X8zcoJXDe3gpd3p/iXl47h9xnEMhn+87obKLV1ctl0WdxNCCGEEH/6JJALIcT7OC93GdWOOqqctQCoZ8J0vsXPUGaAF/oeo8JeQ6N7Ktee5+azs8exoKKKBzsymDBRXgB/fkvXSPDVzKSNFMFMgJbYSbYPthA2jlBorafUXsEEzxQ2DL5MUk9gUW1YFftIT3g8TOFpC4GSLFquhbSRAqAz2cbrAy+wrOBSnnm1lfNm9rFgxhAZUmweeu2sa5njW0yetWC0Zxsgo4/sTW43Oaj1u5g9IcXhUy6+sHAaU7yzeKn/KZJanEBmiPZkMzNtC7CoI3uNg8KTr1ay87SPn31mMg35Jqg/zLRKJ8U+OwdDfQykexlMD+DSyljiX0aJs4j2+GksqgmrTUVDp7pYYyDVSzgbwKrY2NNiZsqkLo7qTWxrvYLBaJqsrnPD5adQTToTSy/goTvnfcx3XgghhBDikyGBXAgh3ofNZKfGVT/688yc+UzxziKaDfN0z4NoRpaOZAsdyRbs+FhdPQGAhXkXcDi8j6Qex6yYuab0NqIpnU3NbSTU3bw28BzjHcvJJksptReyv6uH1489R31uKVqqiHDBQQDSWpL8PjN53Wb8ip9tShKHNzU6TLw9eZpfdv6IRbPzySQ8rC25nKd67yOja2SyKjaLzmzP+QSNfurcjWweWk+exU8gM0SJrYJxznq2Bt4kmg2jeds4/7xWAMyqGZNqotxeRW+ym81DrxHOBsnoaWpdjVxXdie6oZNa+jBz5qWJuMN4NB9DATsdHRbuHG/Q6JnGzsBWNDJsORHj5KEhmgabmD3/AKrZoNRVQMIIEtMDtCdO05fqJm2kuHJyA/uCu/B4E7x45BT/tHIJa2eVsz8TJq2nybHLvHEhhBBCfHpIIBdCiN9iZ8swu9uG+dzicZyKH+RY5CDLC1bx2aqvs3loPUcj+zEMaBtKsC7cw5KJLnqSHQxl+pjtW0ihrYTHun7Bju0TeWFPlFvPL2fODBMp2ogb3ZyMhsATo8oDaQLEVJVcw0lWiQMwYcIS3O4sB1zHiYQTOJV326brCqoC86cPUW73kG/PZ6J1GV++v4NrLunAn5diV1cHK+unE8wMczSyH4tiAyCQGaLOfTleSy5OkwuTYqbQWkK9eyKTvTPRDZ2dwc2j51JROR49xMnoUcY5xzOQ7sVsi+G1phnMxuiJDfLIsw3ku62wBqyqlR27qygp7+J0cwkzpzrYN7wfpytBLG5m27ZGvn31JFrjTdS6GkhocbYH3qI5vpnzixZx+lAXF09tYH9nkI3H+/mzpdfitL77JysUz9AfSVJf5PlkHgQhhBBCiI+Beq4bIIQQf8z+4on9/PsrJ9h0coCOeAuD6T4G030AlNmrMCtm0Kxs2FxDjjfJE1330h4/zbL8S5nmm0MgM0RMi9JQlWZaRQ5XTJrCRf7LCWWCAPhtJUx0zaGAiWCA26mTVeIUWktpdE/F7y3lZcdROkwDlBRkseAAoNBaQiDg4LWthYSjJiZ5Z5DUkuwNb8JkMtixq5pwIA/Fd5rNQ+spd1RTY5pP//DIr/2kHudgeDel9kryrYXkWvO5svRmJntnApA1snhNOQCYFTN1rgn4rSXM8M1jMNNPKBug2F5GnqWAjm439z5TTk2Bk1e/tgTlTBd+qbOIN7cXsXZZnKStlRULe3lzWzEbN02grDDJwd5uGj1TsKhWvJYcci35GBhow0M4sx2cHHiN77x8jB++2cQrh3vH3Jfb7t/JRd/fxMHO4Mf8BAghhBBCfHykh1wIId7HwT0H6AgkUIDHd3XwvRsuYkJmGhWOkf2zx7nGszu4lYAxyM2rBzjGr3GpHtwWL+M9kwCY4p1Foa0Ef1UxX5qjMpwZoD3eQzA7BEAkG+S8wmW8kv41ZKDSUcMM33xK7OUA7ApsQXEMcuR4DpdVXYDDf5Lh9CDVznr68zcxY4JOhauMWDbK7sQW7HaNxnFhsoHx/MWMVewJvk0ybXB8qJO21HFUc4bhviIqSuN0J9o5ENpJnWsCy/yXAtCT7ORU9AhVjjrCWhCnycWqwrU81fNLDAzcJjdFthKSWoKORAuXF99EqfUkfQPt3DB5Cu3DUX68cwML6nIom7ibL031se71cWw5nuTS833cvMyKKVzBlx9o4b9eD3DzvCR/fnEVz/X9ihxzLjeXf4FDp4bpHn8U1D6+eMFiJh3zsWJi0Zh7M7nMSyCepsBt+4SeBiGEEEKIj54EciGEOCOWjbI3tI0G92QKzIUE9m1hrsvPnriLDSf60TLT8Jh9tMZPUeMaj2ZkKbGXs/FQlpc2FrN0nsJ1C7ysLL5mtE5FUSi2lwFwILST7YG3mOGdx5ycRSioHAzv4snu+8kaWQDK7NX0Jrt4e/gNVvgvY5JnBi2x08wdnyJgfYO2aBCA/nQPAHPLKzg8dJrtO4N8ed5S+izdXDRuIjNKyzkU2o3PnMuXf3GC4WCYz10XI8eTpTzfQ2e6j5gWAUZ6wxNanB2BTQTSg/Sne8iz+lnhX4PPnEuezc9y/2oimRC7gptRUFlVvJZoNkyxvZRjkf3MntZHtd9g46ldTJxyip6oEycGpngVV01tIB5v4+szl1Bf5OGpnlbyfGmGQ1bu39rKFbPySeoJYpoFl9nN683tbO0p4+IpuSydX8PSurPv1T9fMeVjfBKEEEIIIT4ZEsiFEOKMpthRjkb2k9QSXFh4GY2Ll/F/9D4OGGn64r10Zo+wtf8NDHRKw5V0p9qZlXMe49zjgCTHmn0creukO/V96lyNnF9wyZj6veYcrKqNHGs+492TCGeC7ApuAQwW5a7g7cCbHAzvIq5FARhKD9CX6iKQ7QMVUlmwYiPNyErrCiqF9hJ273Tz9vEUcz0OFkxewBHTXo5lDxAKDmPDjttZSDxuocxZhNkSpTPdhEWxkDEyZ+qBjkQLJ6KH8FuLmJVzHg6Ti2BmiBrneADqXI0EM8PsCb5NntWP31qM3zrSa72k4CKm++aRMdJkfPuIxkycOlnGgZYMFSU9rJiU5q+ud1OfNzLf++oZVRR5XIQTWULJJA7vIFdbbwUUXup7iovmjWN822JWTi7+2O+5EEIIIcS5JIFcCPE/lmEYbAtswDDgvLxlNLinkNJTONPjaB+KY1TY2DtwmLSRxOuE7cMbMNAB6E61A6Bi4n8tuoBTLbt59UgfbT1O3J4gA2fmmb9jMNVHvrWQ2yu/OvpaV7J9tL59oe2oignTma3VZucsZJxrPNFsaEw9PmsuZizE9SiritaiobFi0bMUFuQwtyaX5vhGupLtVNrHEdeiZIwM161qxzAgrVjpD2u8srmcBePyyThaqCwLE8wEGKdYmOiZjs+cy3BmkK5jB3C3a6yb3sTk8gXUuOoJpofRyDKQ7uHxzl+go3ND+eewqFZyrfkMpHpRFBODQ16mFpYxrm47Pm+SSGyIR3Z7+OfjJn5wwwxq/W4W1/uBkSH5Gwa3MdkzE6/FR0eihbQtxbWzZ45e84GOIMmMxrxx+QAcDO3mUHgPFxVejt8moV0IIYQQf7okkAsh/kfI6BnMinl0wTGAjJHhcHgvALNzF2I3OZjmOY/Z//Q6aU3ji7cco8DpZpx9PK2JU6iKyoq8yzgeO0wsG2ZJwcVYFAsPd/yUK5fXMKd6AqtnzKc9c4QidTz94SQuZxbd0Him5yFsqp3bKr8MQF+ym95kJ8XWcnrTncT0kV5xv7WYq0tvw6aOzI2e6pvDePdkXuh5nOHsAAPpXmyqnZSeZMvw64xzNpAxDzFjaoKeUJLGwoVUOmrw6DWUK8O8nXgMAKtiJc9aQHeHnZMtdvSYhUlTDQ4c8zFvYpj1A8+hopJnKWAw009hxoYprRKKDvDGwAt81vXneMw+AA6dyMFhtlBfO0hrvJl698h2b35bMRcXXs4rPINZ2YrpTA98odfBk89X0RsK8y8vHuO+2+eM3oNK5zh6kp2U2it4feAFTIqJ8/PfHVmQ0XTW/tc2sprOzv+zggK3jYF0L1EtTDAzPCaQD6X7GU4PUueaMOY+CyGEEEL8sZJALoT41BtI9fJszyMU28todE+hOF2IJ68Aq2plkmcGPclOMnoam2rDoqpMKffSlxwg1+5hknc6031zWagvJ6Oneb73MewmB6uLr+ONgRewqw6iWgSvJchnF49jf2gn+0I7+K9HBwlHLdx1QxOLSqfjNLlQUEloCV7vf47BdD9pI4VTdWNVbKSNkWHop6MnORFoYUXhKrqyJ8i3+BnnGo/VZIUs1DjH4zZ5ORrZR62zkSpnLeqQiUQ2xWce2M78mgJ+ded8Zv/z64STab5y2WRWT65l4+BL9KW7+eLcO2lwxCjwD3HSiKDr4LEUkcok0dHRzvTYD5SkGCwB3QIN7ilEs2HyrAXUmefz7Q1hFOB/VQ0ynBkglClGQUFRFHRDp8ZZj1WxcTp+AgODXEs+X13ewLeeP8KmU/2cHogyzu8GoMhWymUl16MZGqX2SqyqDVVRiWYjuM0eLCaVCycWMRxLkeOw0JtIMcG1bHSxvN/0xsCLBDJDOE1uyhyVn+gzJoQQQgjx+5BALoT41DMwAIOeZAetb7xN+vlmUjNXcd0dtzCsDTCU6ac/1Y3b3ICqKnzvlkqe692CxZRLlaOWjYMvM807B7vJSVSLkDZSBNKDtCdO4zZ5ubb0DlxmNxk9Q1u8CQUVrztDVlOxmHWsio24FsPA4Imue0npSQwMfObcke3DbGUE0kN4LDkMpnux2NK8FXweFI0mYEfwLWoc9Yx3TWJ+3lIcJifn5S8DIJqN4LP42NukUZCbwuk/RU+yjBJ/BlMkycZTUWqKrCzKv5BQNsBwROOZvV2cP9mKUgqqCm6Lh7gexWP20eiaSm+qkxOBVvacMtNQE+FosoUjwaMUOwtYVngpl0xqozMYY6pvDieihzkY2o2Cgt3kIKZFuNh/BWWOKtZvKWd/R4B7b5vLcEWapRNy6Ij2YrOYyOpZNg+vJ9eSx3TfPEyKiVXFa0locR7u/C/MiplbK77E6YE4m5u7uOT8DtZ3afSlxqEAN9WePVR9omc6PckOCqyFn+jzJYQQQgjx+5JALoT41Cu0lXBrxZc4Et5Pm28nzZxma1uUvo0H+caaxUS1CDXO8RiGQSgbIBXLQQk1EvYd582BdQxm+uhLdnNd+Z1cX/ZZTIqJ9QPPo6KyOP9Ccq35HAsf5GBkF8HMMAA3r+6CjIZmHWnDyJcCYDc5KLaV0Z3s4IKC1QSyIwunhTLDvNL/65HCuglF1VEVMzbFRlyP0ZpowqLYyLXmM903jxd6HqMv3cPcnMUEMsNYlCKuvKCP3Nw4rw48yxWXaKSyGl09HrrZSzpSzGC6F2umhW2n81BUH+eXgoqKz5zHBQWraU+cxqxYWOpdSaKvi29v3k9vh4W6hmb8eSpmcx99qS5ah2L0xoboDllImGNYFCtZI0tMi5Bjzmf9wAvkWQvY1lzB6cE433z+MK8d6ePv7wgxy9pFH/uwZ+s5GT088pmoDho9UwGwKBbyLf7RnvLdrcP4vAlqK2MElZPUeiahKgqm3xiSHs9GQVGY7J05uo+6EEIIIcSfAgnkQohPNcMwOBLZh9ecw8zc+cxcPZ+OBXfQt+kQuTU72R5oZWXRNTza9XN0QyemRehqqaM3NsQsL+RYchnM9BHVIhiGgcs8MtQ6qSUwMHCZ3AQ62+ja8hZKWQYqRs5b1GQht91K+9Q0g45+lheswoSJSmctiqKMLt7mp5j2+Gm2DL9OTItgVW1M9s2k3j0RQzPz5pEw9eV9HEi8SdpIsi+wnayu0Z/uQTOyxLUo5Yk1fPulZmqLi7j2ioOk9ZHh726rg/+z4EZ2BjajGRopPcHk3In87RV5WDwmshwiS5QD4Z3EtRinYkcAGO+aRDx3kJsuCzOjuIYhNUoqrVDrbKTBPYVvXd3CgewOUnEr2VNDMCGfYls5brOH2b6FPNv7CHbVwcw6E6cHIWx0UuSz47eW0Usvu4JbKbNXM941iZOxI3Ql2kcDuVm1cGXpzQB897UTPLy9jVsWTGe+ZwpV3iJyLLmj97Z1MMbVP32LO68/gaJbmcg1LKkvlPnjQgghhPiTIYFcCPGpNpTuZ+vwG9hUO5+p/AoAFflu/n7NJP7ihS6eXuei6jNBklocVTGhojKjwke/uQkzVpb7VzM5NYuknhgT9Ax0DAz2hLZRnSiheW4Si2Fmtnchu8NbUUwqiqIw3jOJXFcVrYkmcrfHaI2vZ2iBk7WVdwAQSA/y1tCrxLUo412TOS9/OQktxit9z3DsaDW/fDPFqql+5i9yE9ejpEmzJ7QVgGneOeRbizhtOUhFCdRVmEglLdjsGfzWYublLsFl9lDhqOGNwRcBGOeq51TZIYYz3cz3XUlPZjv9yR70M/ugA5w8E8zr81zktPqYPvMyBttPYtsaI7ksxDi/kwO9kHRkSL3YjKO+iH66WVpwB5qR5fLiG8ix5nG44AWmNoQ4b34fd+VMYVnh+ewIKHQl2vCYvdS5J3AydoTBzNgV6QFO9kX4zzebACj02piWX3VWmVg6SzipE4/beGtHCf/WvJsfXD+dy6eXfRSPjhBCCCHEx04CuRDiUy3P6meady4uk5uuRPvoYl+diTba+3WGIjqDIYMbGj6HigmbyY5u6OwIKPgsuSiKwqnYUY5E9rG8YBX17okAnJ9/CVuGX6clfpJ2y2msig2v2cfu8FbsqpP5C6/BtySXjUNbOdyXJkOCiaEglgygGaPta4s3E9eiFNlKWZx/IVkjw7M9D5PSkxTXBvmzYjPPvazg2zeb9Uf7uPyiZvz5aRQUjkcPA4dImZN88epcIjHQrRmioRyqS7wcDu+l2F6Oy+xBQaXEXs6r/c8yqI3sax7R82mJn8KsWKh1TySUDTCY7gfAoTpxh4txRvIoSJeR7DtBq62PgkAnRVUN5JjzcJrdXPLdL/NG6CX6Ut1k9QzP9DyEoqgUWIq4eeZizN6XsFl1XjzQx7zzs3iT0/k/j+r8c2ITN18SoajIS0ZPk9QS2E2O0c+lwG2jsdhDZZ6Tm+adHcYBJpX62PyXK7DZMgz3biQasTChxPvxPEhCCCGEEB8D9Vw3QAghPi47Tg/xl08eoso0l85kGy/2PU5T9DgAgcwgly5v58sNJmaZCnGYXNhMdgBURWVB3jImeqYD4DZ7MWEiq2dG6y6yl7K04BJsqh2NLGkjxVBmAACbasfAIG7EaIl1klJfw2ayMH7NKiwXTeDCsqs4FIjyVv8hdgQ30eCazEWFV2BWzQym+kjpyZF2mAxyvRkK/AGe2NnLQEjBYXvn17ZCSk/gNecwL/d8FMCwBVAUcHuDtMZP0ppo4vGue+lMtHJt6e0szFtOOBMEoNRawXTfPNwmD1kjQzQb4urS21jhX8ME9zQSehx3hYnGuRXkFLrJziyka2Kak+42rKqVtWW3Y1GsPN71a+Z4lzI/dykei49iezl21U5fuouuVCsFPo11b1byypZ8ehN9vBW/n4Q6wHDUoCc2RFyLEtOiJPXEmHuX57LyyteW8LNbZ//We1zssxPQuqkaf5y7bxhgfJHn939ghBBCCCE+YdJDLoT41Lp/ayuvHOllUqmXCRNyaQd2bHyWl5/aQ/nty7BWGdjmnCLUchG5DQq7Als4FN7DquK1FNlKR+upcdaxI/AWbwc20JPqpMReQZm9knxrITeWf56NAy/TkjiFgYHH7KPAWsgzPQ9hV+xUusppS/RS6XbRpDVxMLOXWFCnPTQJk5ILZii2l+M0uQAoc1SxMO8C3CYvUS3McGqIipVh9vc1s/tQHuPzi+hOtWGgsyB3GRM8UzkWOUgoG8Bl8jDDO58tgfUAKChEsiF6U10cCu8hY6RHr6nIXkZbvIkCazGNtqk0uKeQTacJHm3C5rexNH8l5fYqXu5/hszRKI1Fs1BQMSsWYGSo/bHh0zgdOj/Y+wxlZQF6U53kWvJZmn8xfeleTJjYZ2zn1uUlLMxdhmbtQzGlue2iLKXGBLJ5QfrSMWb45pNjyfut93Io3c+e4DYsioVJ3hljtjyrdtazJP8iim0yVF0IIYQQf1okkAshPlX2BrehGRpzchfxl5c0MKXcx9rZ5aRVN0ej+zGGY6QTCTpbjmGtqqTBPJOBeVsp0mYRyYbIGGmG04PsDGxinLOB8e7J7BzeDEDWyHAqdpRTsaN4zTncUP45htODzMw5j2pXHYPpAcY56xlI99ESP0nSSNKb6mRp/kr2BLcy3TePBvdkJnumk2uy4bWYqXZ/jdPxkzzd/UvqXBMptpeNrhT+woFu+rUotRUu8nMy+PPSmIdWMLusgsF4mFLTJCyqlVJ7BQXWInRDY0fwLRblraDQVkpfqos8cwHmjMpm7U00I0sgO4SKiX3h7aOfmUW1YlWtdD39CAendJBGpSGUw+H+raQCg1QfsDNQtA9jso5ZMZPQ4rw+8AIWy8ie5XbFQ7ndS1eijYgWptpRR62zAc3Ick3pbRiGgVlNkGOp5vqyz+IyuTGrFmLZQrqSrdS6Gn/nfT0eOUxL/CQAST3ByqKrR99TFZUJnmkf2TMkhBBCCPFJkUAuhPjUyOoZdgW3ADDePYnSXBuXzNWwWXU8qp/bKr5C/zU9PFtvYCvJJdeaR9jWwfFQBybFzPkFlzDOOZ6MkaE72UFaT/H28AZyLHmoqOgY1LsmMJQeptReRiQT4vneR7EoFm6vupvxZ9qRMTJUOWqJ63FqnPUEs8NEtDAJPU6lYxw6WWbm+0fbfTRygMF0P4Pp/jGLz/3bm9u45crTnIyaMQyVnq4C8qel2R3aQiqt8g8Pmnn7by6gwFZEnWsC2wMbAdgX2kFCi6GjMy5eQVemg5Rv5Fxzchah6Rr7g9sxZ1TSNo3W+CniR48Q/od/ovqqGaTuWssXft6DpsM319rRLAYxR4occx7z85ayru9JgtlhvFYnNtUJpe3MyrmRvcFtRLQwbwy8SKG9hO5kBwtzl7N5eD2KonJrxRcxdDd7g3Em57pxmd2Md08e/Ry+8ug+BiMp/v66HJoSB1iYt4Jcaz4A031zsagWklqSRs+7x/x3hmEwlO4n3yqrrQshhBDij58EciHEp4ZZtbAkZw2BeJxnex5GN3TSRorJnpkszL8As2qmyFHKrIblBDMBWhOnsKo2AAqsRXQl2nh14Fkq7eO4yH85oLB+4DniWoxxrgbOz7+YjliWtmCAU8k2TkYfpNRWicfiG21DT7KTl/uexsBgUd4KJnlnoBka5fYqbKqDp3t+iVWxcXvVVwHQDZ3+VDcA1Y46CmxFAFz/s22Eww5SoVIK85OEswF+dusc/LZiIv1TeergMIV5Gve3/ZBJnhlMcE+jOXqcoUw/MS0CgEv1YEpD6sw6Z1bFzjTvXLr6T6IZBoMJE6mQhZLCJM3+CLufuo2KARu1uZOoLWolpgeIeuL0XeAnmBmi0pJHWk/Rk+wAYFnBKtoSTaTjIwuyvbMlXNpIE8oEyBoZNg2/hoGBknFiViwcDIRojiSwqirT89+d753MJojZD9HU7uHQUD/Dajv/uH4jzS1FPPlnC3CZ3czNXfw7n4H9oR3sDG5mds5CZuWc9wc8TUIIIYQQHz8J5EKIT5VvPR7gYNcQ//sOEzazFZ+SS761kM1D65nsmUmuNZ9CWwkVjhrKHJW0RjpojnWw9ViWqRUu3CYvflsxNa6R/u6rzLfwdM+DbO9oZUmeCadZRyFDhgC6kaTSVctU7ywMwyCcDXI0sh+DkVXUtwy/Tk+ykwmeaQyl+yl3jAMgY6QxDIOfn/wlx7tSzK6qpiG/lJm+BaO9uuFEFrsty5qKlVTkeEnqcQ62pvnzDbv4m5XzuecyHxsGXuJkLMW+8HZOxo5QYi9nINOLW/FS4aoZ2Vs8pwlDszAUUNi1fRL1127gSHIfB7c0UjWziRJ/hiX5FxPJhEi7TTS7szQPP8dllyq4TV5imspEz3Qa3JMwKWYURcGm2MkYGfJtfiqc1SzKX4FmaCzIW06FYxx5Vj9Pdt0HjKxyP5Tu55VtLubawkwpdGMzqdT7nGPu2/HYIebN6GP1LDcXly5n86BOtqGJox0GqayOzWwaLbv7hWc4+OZrXPbnf0NBxdgV2L2WXGyqHZ85FyGEEEKIP3YSyIUQnyoFHhsW1cIy961U5jtRFIUdw29xNLIfMJjgnsZrA8/hNLm5peILHD3p5/89ZcZiasKkKmz5q9toG47zeFM7182pxKxaOHjcx7qNZSTbj/BPV0zB5niVVDaE15zDcKqf3mQXbfEm9od3MtkzE6fqImtkSBtpYtkIm4ZeJZwNcqnFT6N7Cmk9RUv8FFnzIA3jDN7a7+HGK8b25j70+Sk803cfW6PdjFcm4bPk8vJheLt5iDeO9zGl3MeSgovQDI3m+HESWpxG91SaYseIGmF0tNFtxHJNxXRFkly84ghpvRYVleXLw3QndFxmF1k9w3BnK6WdFgbqNDJWnRpnPX5bMTsCm+hNdTLJO320bTeUf46skcVpcqHrGs1b32J3yQmSljTXlt1JVAvjM+cRzgYos1cR7ZhDvSNLY7EHu8XEPL+P/67O1UgwM0yjewpDIZU399h5amsj37jCj9duGVO28/hRAt2dDHd3nhXIe3vyuSDvTircYwO/EEIIIcQfIwnkQohPlR/fOBPDMMbMH57knYkBTPBMxWlyM87ZQL51ZA73FdPLyGg6j+xsYiAZ5GBsC3/3qEpXMEFJHpw0PUVjtYX2uhjj/CNDsid6ptMcO0GNs56dwc00x49jCWdR7Bp5JwLUzFhNU/Q4iqIy0zePnlQnfaluSuzllNjLua/9+5yOn2SS8zy2tXXwV0uWn3Udbqsdj9mL3eRgX2g72ayJruACvr6inkd3jcxv//MVEzi/4BL0AY18WyGHwrsB8JlzmZd7PmhWHtg4zILZHdRUWckYafpSXTR6ppLSEqSVKDN8CzgVPUqfvZep5gpMqk4n3dQ4G2iKHWW8axKzcxaOaVu4tZ3uA3vxV5ZzsLQPPdhJxpfF8Jlpih4lqkUIZAcBOBHcz7jaiWQMP3/x5AH+7eqpuG1n/+lxm70sLbiEn2xs4t9f2c/cmjx0fRi/tfysspd88WsMdrRR3jhpzOt72gLc9IsdNBR5ePXrSz7EUyOEEEIIcW5IIBdCfOr898W83GYP8/POB6Av1Y1VtY0uJpYiglH6El9cW0BXsg2XbS5fWFrFoc4QE0rdnOgzsNqT3HhxmGvLKwEospViVe3UOOrpSXbSkWwh64GG/9hCfr2dzdUxBtP9AHgsXqb75lLnngCAoetUOGpoT5ymwOnky7NXEc4GAchoOp97cDdOq4mf3DSL68s/Szwb47W+F+mjHW/ZIYorqjH2hVl/up9J/cdZVbyWi4quAODt4TdREgqhbIC9wW3kmovp6cljYCjIrLJS+tOdOExOjkb2n9l/PMumoVdZmreS3lQn7ZOSXF16Kyk9QXu8hbZEM8W2Mp7vfYxqZx3n5S1nMN3PQEsz0cAQ29QOlAIomFLApdalPJ1+iu3Bt5jjW4wDBwkSZFJxjkUPcCzqY93BMu5YWMOsqvcfTl7gsmFSFa6fXcH3rp1Gee7ZPd12l/usMA5Qne9kbk0e88flf4inRQghhBDi3JFALoT4k9Gd7OBY5ABzcxfjMZ897Pm3SWlJNgy+TCQbYjgzgM+Sy3TfXFJakrgWw232cmfV1zApZubNHzkmo6eZlXMev9p3gF+/VsyxZRv4x4tW8Er/s6T0BEaeTp7VT5GtlKFQN4NfcrEnr5B4ZoAyWyVOs4taVyND6X52BbaSHBgilg6PLALnAQ2NV/ufYTDdz+XFN2LT/GxpGkRVNV7t6SGiDTKUHQDAMGBcZYSg7QB3XukiZcQZSjtGry+rZ8lJzWKKw8nBxGYOR/YC8Pjn7+KJnsO0J09xVfHtDCTsWBN7KbT6GdA7UO0xShzluEwevGYf/akeiu1lFNlKWZS3Apvq4I3BFzgRPczJ6BHSRoqc6jx6UuCYAGXmChYWXojH7MPe4SBjZGhPNJMgga8vQ+SZfk5c3EBlSYy71rbizqvCMHJQFIWNJ/r54sN7+cuLG7h9YQ0A186pYO3s8g+1QnownsZlM5PvtvHEXQvY0xbgp281c8fCGqxm9UM9J0IIIYQQnyQJ5EKIPxlHwvs4HT9BgbWIab4571nm5PYtDLS3seCa61HVkYXANEPjlf5n6E11YcGKW7ezr+8tDg5vp8E3nevK7mQoPcATXfdTHp/M919JceG0MlzjXielJ0mm3BiGgp52kdbTpPQEACcih+nP9DDJM53JRXN5oe9xIqlu0kaKGb55o/uJ7wocpC3RhOpQ0N0GUX0YgApHDSk9iaqY8FpycNqt/MetPo7Gd9OR1tANffS63CY3BTlFqIqJnmQHmmYQDRTT7U3gcWf49x2P8dALZSxt8PPTW7/MI60P8dC6AppKWqg/81G1RAyOBMPYeqw8svkgAH9350qSaVhZdBUHQrt4rvcR/NZiBtK9VDnqyIkt4Z5fTWXhzEFmTO7DrFgImofxTXLjVMpYUHgBudZ8epKdTPRMZ294GwYGje4pzK1YzH3xHqpK1mG3Z3G5smwcehkUaHBPpj+cIp7W6AwkxtzDDxPGj/eGuew/t3JeXT4P3D4XgG8+d5gj3WFUBT6/pPYD1yWEEEII8UmTQC6EOGd6dxocf1Rn2hdUcsf/7hA2N3cxflsREzxT37fMmw/8jFhgmJrpsygd3whASkvQd2ZrsQxpMipgBUixP7yDWlcDwcww4WyQzYcOsae7jIzSw9pxBpqRZUZjmFumLGR+6QQURWFe7hJ0w6DYXsbOwCaORPaT0lKomCi2lTHVN5tSe+Vom6Z6Z3MqdpQIIeqp45TahMLI9dpUO2YsvNH/AiuLrmFpdQOJgSNUOepojZ9CNzTieoyYHiWWiKKgsLroOh54u5WfrQ9zZOoRVi1vw+FMkePWmVDipT1+mmAqQWuPlUCoi8nz7CT1BHn2NLkmM3pvF3cUDmFTDR5Yf4jHjwW46bJWVtTVY1WsDKR7AYhmwoQDIepq+6jIc3FTxZ9hVa1sG97Ikcg+0kaUlJ4knAnyfO+jo9drxkye1c/bwxupaAxTZV/Cr/btI8eXoLrQTL5lZP7+tXMqmFmVS02B68M8NmOYVRWzScH+G6uw3zK/ir9+5hD/99XjVOW5mFzuoyzH8VtqEUIIIYQ4NySQCyHOmc5NBgP7oXeX8YEC+cgw83m/tcwFd36BwfZWtHIbWT1La6KJrUNvYFedJPQYRdYyci156KkUvUY/ZtXC8z2PcmnxWlYXXUuyrI1KI8HS5bPwuKfwav+vqXGNZ5K3iuPB03z/xQBzawq5c9HIEOv5uUvZNryBQlsJp+MnSBtpmmLHsao2/LZi+lM96IbOZM8MWuJNzPWvoDBehdPkYmdwE63xptG2p/QELYlTRLIhQplholqYPEsB1c56BlP99Ge6MTDw24q4eFICV+k+Ks0eupKt+HMVdn3jItJ6hl913oPbqfDIXdPYG3udpJ5gw/ZCVl8GUwtDNC8xY28ppEgvQOtyohBAUaAz0UqDZwqHwnuwq3aGsv0Ul+ziwvy+kfuVaKPYXkqlYxxt8SaiWoSEFsdvLabCUUN/soeUkWQg00f3cAcWxUrGyOBQPDS3eRlXZbC2fiFvDr7ENO8ctFgpFsWCSX3ve3+gI8g/vXiULy2vY1lD4XuWqSt0s/+bF2ExvVvH1bPK2do8RCyV5a5f7WFudR5P/NmC3/l8CSGEEEJ80iSQCyHOmSmfU/BPhfLzP/gQ5XccCe9jd3ArF/jXUO54d+ur+jkLiNarvNT/FFO9szErFpJ6nHS4CKvFg27VcJrc7M0eAsCi28iQ4VTsKIH0INnKLFMaGynPcQEuri2/A4AXe59g2+kBXj1Szf7uEKtmeym251NsL+PK0psBKHdU8WT3A3TFO/nhugA/v/Yynut7FDC4teJLTD0zzD6jpzmeOE2jawqHuobRTGEK1HG4zB7MioUyezVzcheRFyvgYHgP07xzsagWzCYTc3IW05fq5nDqNeyOFGZ7N/nJfDJKlnA2RJ7FzyTPDKyqjbm5FdQmV3HHrzZw/LSH8IVZNkWeA0ApUZhfdRXfMeDCRf30axbq3ROZk7OIWb7zONo3wOvDT5G1d2JTFTTVYDDdy97Q2wQzw8zPWUo4G6TaWYtJMTM3ZzGv9z9PSktS5awDDCZ5ZrA3uI3TyWNcvtxB0khwOnGUQGaQt4c28uC6AvoHPOz8m4txvcfK61uaBtndFuCNY33vG8i//dIx9rUH+dmts8hxWkfuqUnlP2+YQU8owdcf388lk4o/9PMlhBBCCPFJkEAuhDhnbD6Fqos+fBgHCGaGSeqJMyuUj92L2m8rxmvOochWSrWzHjVZwtWPHMNhVfF54ySTAe6+yU1aiZIxUkzzzuVU7AhxLQZANBtmWs5IeE5pSX7d8ytC2QA1pSZuXVGDy2Pj+Z5nubJ0FX7bu2HPbfZiU+0YJKgoDxGNG9S7J6AZGnEthqIoWFUbJ2NHCWaGmOlbwETzpTy0rY1/umIy4UyQbYENgEJfqpah9AAGOpuHXyNrZAE4EtlLID1E0hiZd+3QHHTTAQacjp3E58tlUf6K0TYV2gv57upLSWd1xuXaac2Moz15GgODV/qewW8r5nT6IAoKM33zURQFm8mO2QS/+nU9X750P+ZMmtnRcXRM6sOEiXxrIceiBwhlA1Q566h01rAjsIkXd5hp6axmUU0/X1++Ar+1GFU14TX5CGshXCYPS/IvZijTz5aB17l+VQe9XUXYLe8ON/9Ndy6qoTzXwdL3CeMA64/2cXowRmcgMRrI31Hic/DY56VnXAghhBB/vCSQCyE+EcmjR8kGArgXLvzdhT+A+XlLaXBPpsBWNOZ1zdA4HN5Lib2CEns5kWyIWSW1fOsyg1PZzazbnEc2Y+Hywjt5duAeMqQ5FN6Njk6OOZ+skWF+3tLR+jYPrSeUDQBgVizMnniS3uQQJiWC3TR2XrJFtZJn8dMS6WBN/Uwq811UspL+VA9PdN9Hsa2cy0tu4OLCKwhmhim2l3HpFHAU7+OYto5K9QpqXY00x46zL7QDt+rFG4Wsy4zd7MSiWGiKHcepjsy5VlFZULCcts4msiYdu+rgvvYfMN49iaUFK8nqGQwDbN4+xtmriGtR5uQuoi4zgebYcdoSzXQkW/CZczEpJvaGtjM3dzEAvcpevnjLSWp+dgD/66fo+I+b6E6NXKeCykzffAwMyhwVAEzQZ1OqNrG1N0WpEmHfhmewLxhPW3xkvvxU7xwqHTU4zS6c5hrm5C1iy/DrXDNlyvsOWbdbTFw+vew93wvG09zxwC5mVuVy5cwyXjvaR2OxB7NJVlUXQgghxJ8OCeRCiI9cUktgUkxY1Hd7LNtuvwM9FKL21VewVlX9lqM/GJNiOiuMv3Pu9kQzJsVMV6KNuBbl+vLPcsWcPB7vGuSOtcOs8l+PzZZGVRQwIN/qJzxYxu5TPv7qoin4XTYAMnqGlvjJMzUrXFF8E0/3/hJDzVLnnvKeW69VOseRNpLM9teNvmZXHbhMbhQUuhJtlDmq8Jh9HArvocRWTluimZSWYlNzDyvGr6HcXo3Pkkt75CSztoVQDQX1ts/w+MCvAEjocQCuLrmNuJ7m2Klq3O4YnfYWDAw6420cDe/n7eENuM0eQtkA07xzOBE9TEpPcmP55+lKtI22750vHLSYxtzcxeiGjteci0kx0/z5uXTddf5ojzyAgc6+0HburPo6qqKSTWv07k5wpbmM2iUxSro7iHl12mOHz5Q3GEr1M+M35v+3JZpJ6UnSepreUJK/fOoAF031MmV8mEb3VOwmB7FslL5UJ0ktSY1zPAk9Tp61AICeUJK97UEC8QxbmwbpCSVZUl/A7Oq8D/0sCSGEEEKcKxLIhRAfqVg2yuNdv8Bl8nBd+Z2jr+dcfTWZzk7MxR/ffN5AepCknuTy4ht55fAAGd9hPA4z0WwEp8lFhb2GDlrYG3+deZalpIwUHlMOKwvX8pX1h3n9WB+TSwq4dJadaDZMSk+hM7L1mNPkxGlxsyz/UqJaeHQ++H830TN9dEu2lJZkd/Btqpy15FoK6Ey2sq6vk6ne2bQnThPIDKGgMN92PZ97YjuR8HGO/mM1jZ4pAPgthSQqAriwg8XC6uLriGsxTkQPkdZSeMw+Hmj/MePqM7y1009JeQvDQRsuTw6bh9ePtEFPkm/xU2qvJK7FiGkRbKqDWTnn4dKdhMIDBBwRZubMp+DM8PuORAv7wztQUZnqnU0kE6I10YRDdaAoKnbVgT1VR1N/jPFFHkwWlbxyF4aiY87ZyFabjy9OW8troQfR0VBR6Uq18ULv41xTehuKojDZMxNVMVHnauTtk0E2nxqkZvwJ4oE+snqWab45PNvzMFEtDMDB8G5C2QBXltxMoa2ECSVenvnieRR57RztDnOsJ8yMytyP7dkSQgghhPg4KIZhGJ/0ScPhMD6fj1AohNfr/aRPL4T4GCW1BM/8ajvW1jKu+N/1mO2/3xzx38cD7f9JSk+yzHMzl3x3D1+6+RR5LhMZI4NFtVDvmsiRyD6iMTObNs7lx7eX8dbQq2SNLNNN1/HG0WFWzNDYFn0RgMuKrueV/l+jGRo3lH8Op8nFfe0/IGtkuLToGgqtJZyIHqLcUcP6gecxYWIo08/yglXUuydyPHKIt4ZeodhWRm+qCwUFAwOPyUdECwFQZC1hddGN/OtLxynLdYyu3h7XYuwJbqXeNZFie/noNeqGzpsD6+hMtp45vozjA/3oiXwszjBv7bcyv7KCinGnCGWDuE1e1pZ9htf6nyXfWsiCvGUAbBx8hczedrqLwyS9BhcXXkm1c6RXP6Ulea73EQKZIcyYyZLlwoIrqHbVEsmG2Dz4Oj97OcuRJg9/8ZlWFhXNZ2dgE7mWAqJaBDCodtahYqIpdozWtjxKK3sAMGFmdfG1FNvfHYrem+jigT17WVpbxYnIcV7a6mHq1BYq/AYmxUyhrYRwJshgpo8J7mlYVCtTvbNxmd0f6/MkziZ/v4UQQoiPlvSQCyE+Uv2pHsz9+RgbawleDQWTP5nzakYWq2rDolipycnnaxeMx27pwqzomBQzXouPvlQXGHCsyQsYlDmqMCtmdDQmlHiYVlbA090PAuA2efDbirml4ovo6FhVK3EthlW1ktUyvNr3LFO9s9kX3k5B7BjBzNBoW94efpNxrgYqHNXYVAfhbJAV/svwmn1ohoaCwst9T1NgK2J18bUAfHPNRALpIQ6GdrMvtJ1qZx3Ho4eIZWNc8huBPKUnOR0/gcHId6mLCy5kZbEHgKFoClewm6tmlJHrWspgqg+7yUk0G6Yr2U4oE2Ru7mJMipnT0RNkx6VxBlVK9WIqHeOIZaMEMoOUO6q5uvQ22hOnea1/ZFV2p8lBW7yZUDZAV6qVOVPchGMqmBIcjuzFrFpwml1cVnIDT3Xfz/HoIYpspaSNFIfbdA62FrN6vkHW2kcsG+VweC/l1npsqpPj0YOU20+S3j1AU3QiO04MkVfooKFYxaramO6bx3BmgM1D6wlmhuhJdZLJqMzJXcgP3jjFwrp8Ftf7P4nHTAghhBDiIyU95EKIDyWbThPq6SK3ohJVHVkdW9c0jr/xClaHk42V+9GMLAtP3cGkFXkoyifTQx7Nhnm487+wKBZur7x79LxvDb7K8ehBCq0l9KdHemk1DbzmXNq73Xx20mXke6xkDY3h9ADt8dMcCO9iZeFVVDhrCGeC2E1OrKqVzkQr6/qexKraGOdswGFy0pVow28t5kh0HwoqCgpW1coU7yxK7ZU81/sIABcUrMZmsrNp8FXm5Z5PnXvCmPZHsiEe6/wFJmWkR1/FxCTPdOrdE2mJn6LAWsg4VwMALbGTbBpcT4WzmuX+VR/o8+lOdtCT6GB3aCtF1lJyrAWciB5EReXWyi8zlO5nXe8T6OisLLyGSudIT30wM4yCwmC6j9cHXsBvKabRMwW/tYiuZAeHI3uZ6J7OjJx56OhoepaW+Ck0I0uNs56X+p7mxMAw1aa5XDd5HrFshD3BbZyMHea+J+pJJZ383zs8NGe34B5yMN91PvuVIHOLKji27RWCngT1kxegoxPNRrCqVn598BSvbi3kCwun8H/XH2XxFINfXLcKkzLyPHYmWmmJn2JOzqKzFt4Tfxj5+y2EEEJ8tKSHXAjxgeixGNnBQdo7TtN34ihls2dzqqSXGlcDFZQT6GzDZDYzccICUkaMiStyP7EwDiNbjq0pvh6rYh1z3um+udhNDupdk9gZ2ERbogmbyUzLQJKkkeRvX9jLXYsm8fbgJqz5J1nhX8NN5XfxWv+znIwdoTl2nEJbCVeU3ES5o5pLCq8i15JPQovzbO/DKCj0J3up2LiKzmUvk2PNI8/qZ1dwCxPc07CpdgosI2H6YHgXUS1CZ6KVo5H9TPRMp9hehsvkwabaybP68Zh8BDJDRLIhpvhmEctG2BfajsvkHg3kNa7x1LjG/87PpD/VQ0v8FDN88yi1V9AZbwEgoSdYlbechBbDnCrl2nt2c9MFGrpdx6b4yLPmM5TMEM5kqfGMLJIWTWokYy4GXL3oYRNRfTMGBg3uyczMnU+wv5vnwk+SNmfR0bmgYDUOs4srS28m5A+Qa80HoDXexMkzi72ZFBUF0PVCFD0Pe249/TmDDIZ3s2voFIXdWYxCC5M9M/llx4/RyFJqq+ToaReppIXuUIKrlmSobWjmYKiQfGshXksOe4Pb6Ul1UGQrYbz7ExqiIYQQQgjxe5BALoT4nTKaTsuXvoq2Yxu+n/wQV34BiRw4HT9JUk9QV9zIlFVXkVFNvBDIYAIOvv00FdNmkV897hNrZ6m9YvS/+1M9xLUY1c465uUuAWBR/gX0dneS0pMUF4BOlipnmBt+to2MZuJvrrHw84MD7Go7wbVrekjqCRwmJz7zu4uFVTlrAXCZ3ZTZq+hKtmHqKiD2UAPet/Jp+GEHOwObMWHCqlpJ6UnMqgVVUZnmnUuRrYzh9AAnYodJG2mGBvuZlXMes3MWcnXprQBk9SxZI4Pd5MBl8jAnZ/Ho6uLv542BFwlngqwqvpaMnqYn2cHx6CG6km14zTkUWAs5FNlDlaOO5f6R3uRSewU7Ww0OdAyxoK8af+kl+O35uM1eXuroI5bVcFtM+O1WTh4a4MHNxXz2ml4CmhfVPEDWSHMovId8SyGR3UdJ16fPLIEHMS1KRk+zd89LeC255E4/H4BQNgjAvJwl3PHnc9B0g5gWoSC6lhqPnVC2nT5rNwUdVjqmBAkXahyO7MVt9hLOjgT7/325QaC/kK8/1EJVgYdZk/OxqTZe7n8arzmHFf41tCdOU+Ns+CgeKyGEEEKIj40EciHE77T6h1voK17DL4rbqR1XT2nVCjRDw4jaKbGNzG92FxZiGArlmWG0UJDYYD+BzrZPNJD/ppf6niKlJ7mu7E5yLCO9vG6zl7WltxPJhjgePcTp2HEunzCH1oZTtL6+iY5v99G0Yg6tPRYmZ1bg6xmgauJMDmuHOBDcyVTfnNHed5NiZkHeUl7uexq9Kk7uZ5tpdx+kNZ5FVVQyRpq2RDOXF99EQouiGzqqolJiL6fIVorN5CCjpdg8vB67+u6wasMwOBzZCwaUOSrx24qZmTP/d15vd7KDhBYjmo7x9V9vxuQc4POL68izFlDjrOd07ARZI4tmZAlnggyke9ke2EhOWT4/vXkl1oKTnI7pWC0RoJQJPifHY9t5se8YgaY87t3gZEYqQDKRh9tux4QJ7cwidQdCh4hXdqFbAA281hy2BzbSFW7Bd3CAYbo4WGGnyjueaHZk1fSBdB+KotGeOsmGwZeoM9WzL9qKoRgYhk5lpBpv0kTUb+AyezArJgwMjkT2jVywA2693EuD9TxW+KfjMDlpTTRTaCvBbyvGb/v4VvMXQgghhPioSCAXQtCT7KQ/1c0U72xURT3rfc0wUJxOal9ch9U1sre4STEx0TMNgDcHXqQpdpxxzgZWlK5BL8oh4LgEX2n5WXV9HHa2DHP/1hb+18UN1PpHVt6e7JlJKBvAYx47z9VlduMyu+lItJAxMvSmOvnXW8/jM709PDQ8hSsqBrhpTZr8jmGGjp7iNeUkg8Uje3C7LV5qXY2jdeVbC7m27A6ORQ5QdW0B5cnxlNorsapWtgfeotReQVPsKEci+5ifez7TfHMBUBWVujP1NHimoCoq0WwYs2IhmBlmR+AtAEwhM3dU3v2e9+S/u7LkJqKZCMNhM28dMGGzFnL9giDLC1bRkWhh8/B6yu3V9CQ7eKbnQQwMyuzVTPBMpba8hGDGhsm8i6nekS3XGnPsHEt0kNZSuGp7WJjIZWl3nIh7GKcphN3kYzhlxqRNIKj3YLjPLEdigqgWwaxY6NDaSDUWoukFHAmdoCvbicc0snf76fgJSqLleMw+PP0mmgtOYU4p6A6VXGsBqWl5DAY60BWdoXQ/Q5mBM3u5qyT0OIZhUFwUxm47xFPdr5BjzhuzzR5AW7yZ/lQPM3MWjM4vF0IIIYT4YyKBXAjB5qH1BDKD5FoKqHSe3aP90lcXo+kGDuvZocYwDE5H4yh6PXEtBoBqMpFfXfuxt/sdj+/q4OXDvUwu8/GlZSNbd83OXQhA0+4d+Cur8BWO7TF1mlyomHCaXADMvdDM0P4gldXD9GeTeEotRGMZAjkZzIoFl8lNSktxf9sPmJ+3lAlnvow4GNrNntDbDKb7ucC/erT+pQUrATApFrqS7RTaSt+z7e+E8cc6f4HL7ObasjuZ6plNb6qbfKsfVVE5HjnEnuDbjHONpz3RwvKCVfhtRWPqORU9xs7gJpYVXMr3rp3GodRrtMSHCGTm4TF7cZk8FNvLUBUTw+l+YlqUKd6Zo0Pwcyx5nF9w8Wh9bYlm9PYA+Q435kIfX5w3k8n5dWwYXMfp+EkKbSWQvoiEkiVNBBQb1c5aimwleC25DKR6aY6dwF9/AR1RBZd6DDXjoT19CACraqPSMQ6X2YOhGqgaoIOOhm5oHIrtwbAaLMhdxpObNU7HSlk8txuzakYzsszzXUpzyIOqnwa6iGoR4tkoe0JvU+eaSF+qm0Oh3cT1GMPpAerdE0fn4AshhBBC/LGQQC7Ep1TngT0MtDSRWJCH31VGvXsiAKFMgObYcSZ5ZmAz2QGYnXMe3ckOSuzv3aNtNatkdJ3eRIoi+9hF0xRFwZJdiI5C6YmjfCfRwyM9Qzw2rZaJ7k9mhev/dfF4JpZ6uXZ2OT3JTuyqnVxrAZs27eCFn/8X0ytzuOlfvjdaPqklOB0/wVTfbDRD4/HOX1DgV1m9bIjZvoUU2UsZTPfTOb6D83wXUeOux2Fycji8l7SRJpwd2UP8eOQge0JvY1cdowH9v6t1NVD7O4KgWbHgMnvwWXIxKSZm5oysKu4wOQEYSPcS1cL0JDsIZoYYSvefFcjf0RI7yeUz1nBe6iLC2eDo0O2bK/6MtwZfRTc0nCY3US1CJptk6Be/wDFtGs45c8bUU2appO+oHdCZcfWlKCYVs2pmum8e7YkWHCYnF1QVsn14I4cix5junTc6Vz+jp+lP9bC0YCV+WxHPZV5kOD6TjlQaw9xLscPLgvzFeC05ANTXzmVfMMCDQ3ZudB4gkBniRFMe1aUJ3sps5OGtEzAMHxf5BygbV4ndOZV9gw5AodRch4sAk71VNMWOczRygOH04Oi+707VTWuiiVA2IIFcCCGEEH90JJAL8SmjZw3698JwfzuDmT5OJ9pxpE6OBvLdwa00xY6hKirTffMAGOdqOCusxMMhjm3eyITFS3F6fWzrD9IcSTI1T2FWfsmYsjNcFlqPH8WjGpyIJelPZ+lJZT6xQF7ic3Dnohq6Eu282Pc4VtXG7ZVf5ctvBomUXcXyGZkx5SPZEN3JDgZSffitRQSzAWBka7JqZz1m1cyh8B5SegqryToajGucI3Ogp3pnA9CVbAfAptrHLCj3mwLpQZ7teZhxrgbOL7jkPcvYTQ5uKP8cwMgXBF33oqFxU/ldWFUbC3KXUe+aSK4ln4F0H2X2SgAMXUdRR4azz8iZx8nYEVoTTfyq46eUO6rH9Nhn9DTHowcBmONbRLWzDv+BQbr/73ex1tVS++KLY9rksDqpmbcIXdN44p++QXign9u//1P8ecVM987lVOwYj3T+F0ktzpycxUzyzuBY5AA+Sx7hTIDdwa30JDtZXXwtDZ5J7A4NkkhacXjmMM7hpNCWQywbZWdgEyX2Cu6qWcwFRUlMxjgODbQSKzuIzaGRSpn5h6srGT7RRF2LhcrCajqdBUCcrHIMj6WB7sQ8IikHc/0OUnqSrkQ7VsVK2kiT0GPMyVlMsb3sgz1MQgghhBCfIAnkQnzKHH/E4Mj9BvXXX8icNUH8rm5yLfmj70/yzEBFpdbZOOa4WDDAr/7maxTW1HLlX32Tnc8+yZ51zxINDDH/hhtpS+7EoIbD0WOcTC/mhpJ365xaWsjkonxUk4kfaRodyTSNrk92/+dtwxs4FhkJnB7TyLzxlZNL6A4lWHb57DFlzYoFgIyRJseaj9PsxmvOYePgyxTZD7Km+DqqnLUk9cSYxcF2B7dyPHoQi2ol31pIU+wYeabJWPWZ9MZTFDttZ7UrrafJGBmG04P8ou3/Md07Fw2NQHoQnyWXamf9mJEJKipOk4uskUVlJGybVfNooCx3VAGQikXZ9+vHaE3ZeMMygZ/dMovZOedxJLyPnlQnwczwmHZYVCuTPbMYTPcxyTsyOkKfFSf3ppvO6h1/R+nkkV5/u9tNIhLGZLaQ1bN0J9sJZd+tv9xRRSgzzKah13Ca3Kwt/QwD6T7GOUe2ZjsWcJGx2Khq3Yc5ZwYR/TAbBiK0xE6SIc3J6DEqHTXUOd0YRi1llRVs7czhkX2HeGNHAYWeXnpDFm5b4OLPyhr54n9u4c7rW7BYwhQ4JtCTMOE1mbCZ7MzJXcTJ6H+RNTQsjIzmmOKdiUW1/tbnRwghhBDiXJBALsSnTP5EBU+lQeFkFzmlbqbzbtjTDI1CW8l79hZmkkkS4RDBzjA7nlpHqqyGmtnzaDxvCXEtSpxDWKwneHJgIrsjHUz3OJnwGz3gqmlkfrnLZPrEwzjAYLqPjJGmxjGeeXkjQ6f/7ZqpY8oYus6JDa+imEzYxtlJ62lyzQVM9s0glAlwKLxnNKxP9Exnomf6mOMb3JNI6QnGOceTNtJYFRt2pYrBpEZ34r0DeZG9lBvL76I32ckbgy8S12K0nNkujsTI9mzLTcsxWSw4c/NRFIVryj4zpo7TsZMY6NS6Gtkf2kFrvInFtmXo2SyZFGxpHSSV1elP9dCT6mSSZwZ+WzGbBl9jft5SrGfC6ML85WPqVZ1Oiv/ub89qs6Hr9B4/gqeoGHe+n+v/4d9He+PX9T5BT6qTpfkrMStmVMVEoa2ESDZEsa2MGtd47CYHs3MWYlNHpkTkGVkSkSA54WEmWDI8G9lNhgwqFjAUcpU5OEwuwuksL3QMoCtd9Ce2MHtaBrNF4+VNJYBC3JLLwzs7CMQzvPSWl29dPZl6Twl33LMBV28HP4hvQb35Eq5ccDNZI3MmhBujYVwzsqT1FH2pbqocdWOmXgghhBBCnAsSyIX4lCmarXDJL99dfC3WY9Cx0aD80jS/Dt+HXXWwtuz2s47LKS7htn/7BRvv8tJ+WiP6HwGmTJtDUcFIb/NSltN/+CSXT5zIFK9BndP+kbfdMIzfOyTlP3wZdi3M8q8VYbK8dx3ZdIrhtlYUVWXxzBW8PvwirzUd4+E2lc8vK+G2yi+P9kq/oyV2kreGXmVe7vkMpftHho6f2RP89qqvktF1umIpihym922/2+yhzj2BIlspLrOHSd7ptEYjhDID1JlzOfjcM6hmM/Nv+dxZx2f0DOsHngOgzF5Fa7yJvlQ38ZwUc667jfxAkhfMFuwWE5WOcfSluqlzNbJ56HWGMwNUOWtHF277IAaSaTq7u4lv24S7oJBpl68FGB0abzc5sSgWiuylo9vJAewNbqc31UWFo4beZCfP9z42sup+4RrKlSwdtKBUFnJs/TrKck2ULl/M/sAxMtmFYFZ5rWuIybluMrqBxeSiwGMmmYGl42qI9rjZfGqQJzeZKXC3owBHm714UlMIZIbwOVXmde/HOLCFLlsfztmz0Q2NU7GjzMsd2f98+/BbHAzvwm8toj/dO7r3uxBCCCHEuSSBXIhPi3AYhofp7a/ixBM66Qg0XqfQvQ3aXzfI6graYo2skR1zWKzXoOUlg9rLFBz5uaTVYQwlQ7nDRK3n3Z7uAw8+TceRg1zyxUI+d/4FAGQSCSyO9+8N1zWNZDiIMzf/fcu8Y+9QmMOBKBeV5r9nT/NvYxgGfW/ayChe1t3wFMXuYubmLh59P6vp/M0zB6kpcHPLmqtoGUpQaCtmTs4ifrRJw5y3i9dCAS60XjY6l/6dcB3OBs/MS26jOX6cnmQnNa7xo3U3xQ6T1OKs73ybWlcDy/2r3rONb/YME0pnubTcg0PN5+BQFpNSSYndgbmglLxc73uGeYtqYXbOQjRD42hkP4Opfublnk+FowaAht/4/MscVZQ5qkhocRbmXcBgune03Ae1sSdAVLMytXEa+cU5vDHwIv4uG86omXHzF3OBf/V7fvFgUkxYFAsJLc6xyEEUvMTSZaQ1nVOWIWJ5R2lRi6kYsJE1R9HRcPepBHMtJLMQy6aZnAvX1hRhVUswp6pg+3aoraNokZ1EWiOrGRzuDnFmgzVcdnim5yGuXQ7FpdW0LboQlk3Hby3izcF1tCdOU2KvYKJnGoPpPgwMrGd67dvizRLIhRBCCHHOSSAX4k/U0FEDPQP+aQrhNoND/xhifPV+TkcK6N8zEtK6tkLdFSPBqXqZlfHFnz+rB/jE4wbNzxroaSi8OkCne2Qv5yv8j2C3WUbLzbnsanKKiqmZMTIfu/fEUZq3bKBq9gLKp818zzY2b91I/6njNCy/mIKaut96PYmsjmZAStc/9GehKAoX/ERlS+Z1OrRWwtGhMYH8oW1tPLmnC5MKRaU+dg0cpHNPKVcti/C/LryUN7oDqISxKjZ6kp1sHHyZcDbIvNwlTPPOpcxehc+SR0GkEM+wheNvvkLl7Pk8H36K0JkF4RRUdM5ue3s0yd6hMImsTkrX6Ux005U8SrV7BjbVwpU/2oamW9n5jUXoukEwkSHP9e5858GWJiq0fArrGni171k0sjhU5/t+Fr3JLp7rfZThgQLWlF6J6vvde5j/pkm5boaSaabVnkd7oommgWNYjriIJA2+tTPO7Stnc8GEsSu8x7IReuOdaKkMnYNHCOalqLSuoTfu5UQ4ziRfEQNDfia4xmO29+DI8TPBM50ck85g6wEqFpxPQjFR5vqNURdtbXDyBIlkiJ4pg9x1dRFz3Su59IebAbh4UjGlXhfl6WroGMYdTOKauJzpk68AYEHeMtwhL26Th4FUL13JNhyqkwv8q9kR2ESNs/5DfS5CCCGEEB8HCeRC/AnS0gYbv6ZjaLDmGZWuzQbdp0uxOrJM+3OVgrkKVh+UzFGw5SgUTHmnN/PdnmctkyHU08m41ZXoGYVB08Nsuuswk9b8GVpfMT1vOam59N1z1kyfRc30WaM/q2eGML8zd/y9OHw5mG12rE7377ymBYU+puW5cVve+9dSPKsxmMxQ4bK9Z0+yt0qBvjQkGN1+6x3VBS5UBa6YXk7GfoSaihhaZpDBdJDyMhNfKVmDYRjsC21nV3DL6HHRbARFUSg4s8XYdN88ju9+haHWZtyFRSQ8cVRMuMxuZvnOozPRyrreJ1nhX0P7YAYDCKo6gXSWKTkuKpw29kVfoi3RzMK8Ahqc07hoYjHxtIbbbuZvnzvMYzvbeeD2uSwZ70fLZjjx5qsAxIaHsIaGoXZkMToY2XatN9XNwrzlWFQrxyOH2B/ajq4rdAxleH6gmwK3jWLfB59eMDHHBYzszV7trGNR3gq859vYuKuPLaf+P3vnHWZHWffve2ZO72fb2d77pmyy6aQ3EiD0Ij2oqFhAXqyoIAoKYsECyisK0pReQggECCG99+ymbLb3evb0NjO/P07YZU0hSFF/77mva69kZp555pk558zM5/m2ABNa3ScI8jebn6df6iO1w4nrWJjiSVVkleRzRApSYDGwxf0uAaUXcagAb1s7Rq8D3VQdeZOmkXeqgRSXQCjEMZcPT7ieiBJBkxRi4/dGx8HPSJrHPzL+jEOQWDx2xvB6s2ShzreXWt9eig3x74NeNGCQjKPqrSdIkCBBggQJEvw7SQjyBAn+C5F0Aq5FQTo9nTQTpWhJEVnOZrRZNoyFJkoLP7yP5p1b6Dy4D53JTMrMYry7zLgGf4b/uRBu3kQ+kEPBOamn3D+tpJzkgiIkzYgVfd/DCgOHVGb8RERnFcgeX0P2+JpT9vFBREE4pRgHWN/tpiMQZl66k3zryd3kF6WeT0D2Y9c6R62fV57GkbuXopFEvLF8ukMdTLIPst+7E2/Mg03rQBAEbBoHWnRYtXaMopHpznnDfaiqymHffqzji7G5MtAVuIj0htELBryxIZoCx1i1r5f8nCH6I4/S1BNj5Zoc3vj6OWQY9RxudXP54xv46uJs5lSn8ZuXQ2xreJtVt8wi2xm3eBs0EkadhFaKT3b0NzVgsNlxZufS3LgHISJTWVY5XNd899BWPDE3peZKMo25HPMfYijmZoJpAQark26vlx+sfYoxjiq6+0x8bV4xOUmntq6f+JmIVNkmgA2uSC+nYMwAUwriceP+mI86315yDYVoJC3akJmYthDR0UNF7lRMJgMuo55NPUMYhSoyDQHyksagLMzBaHeccKyWQCN7PVuZ7pxHit7FhkY3B4ZsTM2PQBhCSoDnOx4nRZdKobmcCms8YZ9RMqPV6PFlqxjNtuH+NIKWHMMY2vxBfJEkkrSplFmqzvjcEyRIkCBBggQJPgsSgjxBgv9SnF8+ysGBt2mPVFEk5KITwyg9bt75chIV12vJnHH65Gj2jGwGW5sJeYYYbGth5vLP8e5+D4PuXbiVv2KubGXer8eTatbz5BensKnHQ4pByxinBTkWw9PVjj0ze1SfbetU/B0Q6Aad9ZM931yzgZiikGzQnrKNVtRhP0V5K40kEpZDBGJ+ii0VrOtbTVgJ4Ym5ySJe17vYUkGxpYJ6/yF0gg5JlPBGhxiKDSIKEu/1v4lN4+DKMTcSkoOk6FykaNPIMuaxepfMy+9omFhp4oK5A7hSQsyq0mIzaHGKAnUKqEA0aGWys4L7g5uYNymTBn+IbKeJF1u3kF+RyrfKx6Gzx8+x99gRQp4htEl2jmYE0apalufGY9SjSoQUnQuXPpN63yFWdb9AjBhmycrElDEU6Xaxrq0Dp22A3p6D/GN7Oul2A99cWHrS6wNx93qLViJJr0WRZQRBYDA2QEeohSLTWKYWJaE97hmxz7OdfZ4dNGqPMkAv49Imk5Q+GeN4EdPx7Ptvt/fTFowgYGB5yRXxg+SdmE+gwRtke38Yt9pPg+4IDYEj/GLNELWtKn/Lnsb5Wdls7H8bSRBpCzWjoA4Lcq2o5crsG9GKWiRh5JEWVAJkGpMoMZWQYbRh1p4+ZCJBggQJEiRIkODfQUKQJ0jwX0qFdTwWjY10fRaSZCDmNCEOBnDY3PTuSRklyFVFpWs7JFeCzhpfn5xXQHJeAZ7uLvRmM1qTyNQ7A+x8YQ90V+KfUkPbWi8D3gh9oSiNA0F6TRHGOC207NxKx4E96ELnkjs1D9ekeJ8llwoMHlKxnWEeMTUURRkMIKafPKHZqPN1mKlwmP+la/U+a/pepyV4jLNTL6Ir3IZJslBsHqnHrqgKjYGjvNO7AhGRWcmL2TjwDjE1yrmuyyg1V+EyZAJgkIxcknnd8L7BwiHW5nv5yuRJTM+y0hfpJjsvf/i8Flels/tHi7Ab42L799dO5PX2AdrCEcIhP9KRbsTUJOQPGP+Lz5rLUFcHjvw8knr2Ypbirv/1/kPsH9pBT6QTAEvYSEwfAxVyDAWs7fo7haF+qi16uq2TMBvzMc2PcO20UzqI0xeK8E7nAGaNxMWZdnY9/zRag5GWGdAV6mZ3Txo6QeSyfBeiJFFmGUtICZFvLKIpUE+mms6h995gyJWPkuYgL7+AwaEh0BlJDQ4Bmac89lFPgEDURpV9EZLQy46hTZy7WGRJTEc0Ngmb4OLSrOtRVZUfvLaJLQMiC66MYdJpGIoO8lzHY9g1TkotVYy11SAKIrvdWzjg3cV4W5Bi7ZyP9kVJkCBBggQJEiT4jEgI8gQJ/ksRBZE8UxGhQZV9zynkTkvHpB8g60I7KTUfELf799G0CnasqiJnvsC0H8WTwAX7wFUjYHOlDze1p2cy/2v/A0CrP0R2kZdxyVZ6ntBheS6N8T9VoABsrgy6dnloej6HjjdinPPzHqTydA49DaE+KDofks/AOzh6oB2l14t2XDZtzgF2uDcyI2k+GYbsD9/5X8CisaIT9GgFLZ6oD5BRUKn17OGov47ecCcyMqk6F9mGAtb3rUERojg0SfhjXjwxNwPeXkrMlcO1rd9nbLadZ78yfXj5g9nNByP97BrazHjbZAQhHn/tMhmY5XJg0Ur0Hj5ASlMbptAgzVUeTPo5wHj0FitpxXH39A+K/819awiofvToyTLlUTTkYn/7NkpKp9E9kM/+wY3o0gaocE4h01rFGz0vMm9KMcmWslNeG7tOQ67ZQLJBi0rcRV9VFcbaJhFTduIe8hPq9/DeplUEF9jo62khryeZjAWLafWm0tS4DktfF1I0TPNhN9rwTFz6Do5QS75jximPCzAjzU5XIEKRLYOAnIEnNkRrsImQDJ//204umZDD/ZeNRxAE3toXpNcbpm0wSKnLiiiISEh4Ym62DK7FqU0h11RAqaUKX8yDX/ZS76uj2FJxht+SBAkSJEiQIEGCz46EIE+Q4L+chtdUDv9dJdhnZOrtOaT/c4NDdTgVsOeW4poUF5HrvqPg0/Sz5O4UHAUnz8KdYzaQnqrn0N9VhppVUAUsx28ZyfmFZFfm04aK0RxGbh0g0jRA/tgUIuYUHCUCLW+rpIwTMKWd2vItpttRYwqCw0RbcDd9kW46Q63DglzxhxEMWgTpo2UKPxV94S4iaphdPceIKmFEEY72dbEx8NZwG1XWsG1vCr40PUpyBEURmGJbyPLHtuKwKpw7t5e2YDM2NRdPKEZBymir/cb6Pr74t+1cOEPiq3NLyDEWcMR/kHp/HTpRzyz9ouG2mUqIuhUrceYWkFZSTm1yEzJh1vWvJkmXiks/YlWOKhGe7/gbAgJVgRIauw9QKhUzdtY5kAaFTMMbinLeg6sBHbvu+CoOo54N/W/TE+lkKDbIBMe0U14brSiyIHOkrvikK65DEEVESaIz1EbX/scI/e0AhkuvotE/QNShMOD30u4PccwbJCW1mpTxCk6DiZ2mdlqkDQRUPwBBq0RYVtCJwgmeEI19fqwGDSX2eGz73qFtHPXXUm4Zh16tJD+5nskFI+N69IbJvFzfTW0oQJFixqqxc5HhUppb9zOYI+GLJBPRK6Tq0xlrn8SKrn/QE+5ICPIECRIkSJAgwX8kCUGeIMF/MbGQSvt6FXMGlF2qwsrX4huWngPHY31ZuAjHxAEWF41k2tbdsJuh8nc5bJrGVGad0K+3VWXnrxXMGdC06vg+FpmNPxDJni0z/S4tFpeKwRoluSBIb7eNPS+40OgUUir8tL5rY/u9KulTVWbde+os7JpsJ5rseAK2KcaZZBiyyTPFM9LJPR6iO5sRM+zoqnPP7Hoc60HxhtCOzT5BxCuqQk+ki1hM4I5/BKiuSiI/288O5zomJc9EI0hsda9j5bpU9h1W+co8HTYHSKKKP6LQ268j2xVARWVt3yoef24cLQMBfnnpOOaVp+EwxSc7+nxhglGFw319bB/sJsdYwDjbJLSC7oSkYv6hQUJeD5199WTMm05X7y40aLCHzEiDMUiPW9dDShCnNhlvzIOKgpJWwYBBYY/UxNgP9CdIQb4414UcNWE3xMeTonOhE3RU26ec0TV8H0mrpc0fwqGDQlMpB8p34bj7MryGxax4dR9aUxtfnzqbfKuJkKySYdKTVJBHV6iNnV37kUQJSdYw1XE2O3rtNPS0kr3pdSoWnYs9MwtBEGkbDLLo1+8xsTiJ719QyVinlagaRUWlzreXMVaJNbctGB7T9sENDEoe8jMnMBiJ8cSxVs7ONtG9eT3+/j5EzWy2mn0EYjApJR7OMc05lxRd2kc69wQJEiRIkCBBgs+KhCBPkOC/mKgPhhpBawJHgQLr4zHFyPKIIHcmgTMJOaIiauM1u4tn2Wjt02LXW/Gs3smOv2Vgrk5m6rfjZdH69qv07gFJD4XnQcdm0IgyEZ+Ir1kGtDiKYNHNDRx4y8WWv2WBAFJEJWOxHmeJQObUGFVzO4m1WGjY4mT/Iyoz7hLJmC6g+ELEDnUh5SUTSzKjFQW0oo5C80jCMUGnAY2IYDx5kraTEWvuh3CMcJ4Ng9NBc+AYetFAuiELFRWjYMRLCBWFI8ecTJswQJguzFI15baxOHWpjDnbR12ZhssnFrN+6BitwQaSLBpuvrYZxHi5Ma2gpSrTRo8nxK3P7mV+WSo/vWgsETmCPmMrf/66A6sxn1xzPgBGycTEf7JOd4c7eFl9EeNkkbApQMB/GL1oQByIkLEzSm/eAVLSc3m16++ElCBXZt3IrKSFHPYdINdSQEPoCFbNSFZxRVV4vvNvpJXHuDr7y8OW6G2D64ioEfJNJSiqQkcgQq3bz+QUG079qRPktflDvNUxQJpBy7k5OSxLW85bHQGGIjEWlGWz9rCe8kwXkiBQ5Rwpa2fx6bhQfwl6yUjd6hWYyjxYU5PR+gLIKgTcAxxe8wb2jCwyz1pMYaqZORMz2DPgI0mvZXbyYkrNVRz07qbUUkUsHOLQO29gTXNRm7aHkBJk43oHVVUuUuwa2oItpFRW015fj8doJ9OoI/d4PXNREBlvn3zG358ECRIkSJAgQYLPmoQgT5Dgv5BjryjorJAzX2TxIyIaA6CV4JLLQABV0hDqUzGmxEWZp1nl7a8opE+GGT+RcHlKuEy4BdtAI63vHUWSUxg4Ig/3n3e2gGQAS7aKgEDmTAFngcTQrkGSpjkAELQS+jllVIyBzm/EY8dd0wXkkIAhGaZ9K0J0uwe5OUxwwIkShfCQCggoPV6UXi8hEV50eym0GpmdPrpUmactRNOaICU3uzi1bByhJ9yJtyzC0f69CJF6jH1m6nx70QhavpD3TaJuLxfXzaTB3kH5jRIzkpbyas8TuKP9vDfwBkHFT5llDGtirxHLDBEUrmFx6gUEZB82rYMiaz4dwVZyTUVkGfO44opyyn/0BgCVWXaW/GYdxYUDLJnTBsCNSbchCiL1/kNsH1zHrOSzyTaOJFWLKVEAwjZI1qXTEDhMtqEAn32QtHGlkFyEqqrkGAsIygGMkpkK23gqbOMBuDzrhlHnLwoiqToXYSWMVhi5YsWWCoaig+gFI/9of4RYpBpZzibDHxolyD3dncRiMpGkVNIMOpx6LS6DjhxLXNxmmlK5JC+GokKH08KNc4rQ/7MXQizGrtWraBo3E5c+jCUcIebzMGuMg9ejMsaFF+O0aWnesQU5GuVoeBtf/VwbYy3j6WvvQdfpZbczA51oZlHa+QD4+noZ6mwnPNTHJQEP64oKmDL5KC+8GeD7FyczwTEOHBpabWnk6eNVAN6nud9PbpLpQxMGJkiQIEGCBAkS/LtICPIECf7L8Hep7HpARRBhsF4GBMZ96bgwcjgA2PdHhSPPqtTcBr4OgeRKUGWQI6DKKqu/qCBHYNlTWRxtddDfbWfi9erwMURJwNOosvWnEC/WpVJyiYbqr4+uSy5oJfb8XibUF1/uXA8d76l0bFKJJu1j/HwX1txMxp0lUHiOir6riWitAU1ZOmhEvDYD0poglIv8c/B72823ou/Yxrbah5n591loTacWVe/9eoAWTxeOLx0hkqJSZMhk6+A6AKqs1QAEoj4MqkiOlEe204VRq+U812U82fYnAN5pOsBabxRTTggBAY2gRSNqsInxa1psrqA73MkR/wE6g02UpqTz/UuN9Ic83DylgH0d3ZSU+zCKZtL06YhC/DPpCXfgiQ3RHmwaFuSN/iMk6VK5KuvL6CUDh7x76Y10UWapoji9gkc7Grnrf/fyxbkdpJbXUmisYHezl/x0mVr/TiRfCT94tpl0u5F/3DgNUYxfm3PTLz/h2sxIms9h7wEaA0fikwCaA+QK+fjdETgemq3IMrvefZsBVx5D2SI1yVbGJVmZm+GM1xGXAhTbTFi0Grb1DnHQ7ccbizE5xT58nNq3VuLubCNU4UDWGYjodVQtOR8VaAh0IApaBmURt87M5M8tR9Jqean7SfoiPUx1+lC3r6NOo6N50kJUoqhSA+Psk7CkpFK19AL0r34R4+HN6ISr0eUUsuKWiwjJQWJqDIOkPWFC54nNTfzolYPcsqCEWxedutRbggT/P7N8+XLcbjcvv/wyAHPnzqW6upoHHnjg3zquBAkSJEgwwieTKSlBggSfOpGAH29vNyYXVN0gMO4rAof/Dof/oRL1qaPaas0giNC3X+Dw31Xa3oNlL4icdY+IHAE5DKggmLTU3OVk4jcFChaNjvWWDIAAog5MaZAy7uSCOOKN/yvqQFXBUQQNGxrZu/Y5XvzLrxFtRmIhMDujKP1+5G4PgiQipdsJb1Qw/N6J/LCFPQ8qvLxMxl0fPxfnoimEdSUMDeQy1HDq6xJ0+xnseAlTk4/0WCGXZF5PtX0qRZEi5CNulE3dAKwIvcJzJe/ybtZOnut4lFrPHswaKxYx7vb9zjYjf30nwNlpF3FF5hdI0qWMOs7mgXfxy17Mopnprd2w7fdIzlr2tQ/ysy3PMm/+XtJcboKKn4FofIaiK9ROR6AFCYn93l00+o9w2HuA1b2v8HbvCqxaGzpRxzj7ZL6QeyvFlgrePdQT/wwlSM1sR0Tk7Z06Ln94E3/d8y6Hfft56cgGWgaCHGgfIqoop/3ehOUQa/tXsX5gNRdnXsdlGVfx1b/s5Ko/b6HXGwZgMKrQOHE+4fRczBqRpOOW8+5ghKbAIXa5dw/3l28xkmbQcngowJaeoeH1sXAIORal3dTKublmlmQnc2zjWt45+go7vM+jiAcJxBQavUG0BgOiJLE47SLOc11OhiGb7PETyc3JIcs8iCa4mVhdJ4oc99pwZGajzriWpsrZpJRcwgXpV+GLeXih83He7HkJf38fbft2ocRiw+NJtujRiAKpVv1pr0+CBMuXL0cQhOG/5ORklixZwr59+0a1u+eee5gxYwYmkwnH8cnPD2Pu3LnD/YqiiMvl4rLLLqO5uflD962vr+eGG24gOzsbvV5PQUEBV155JTt27PhXTjNBggQfk/fvFffee++o9S+//PKwJ9batWsRBAG32z28vaOjgzFjxjBz5sxR6xMkeJ+EIE+Q4D+M0IBK774Rge1pVql/WeHgqpXse/V5fH09FF8o0LVdRWOESbcJaC0CqqoS9LgBiAXAmgfFF0PRBQLFF0H7LpmjtVFEDdjywF4IGqOAvUAg4oNV1yoMvV0P/f0AVFwtcvEbIpe8KXHuMxLZs08uyOf8WmTWfQJLHhM471mRmT8X0cn5uNw/p2rufDb/WOblcxWOrtKim1qIbkq8HFjsUBdmfxvJpVGyZgoEulWifnAfU3nryzJ1LV/BfOfLTLwrl5QxAqqiEtneSGRHI6o6cn2ObFlDakWIlGm7mJwbjxcOej0c/tsK5A4PXVIXETlMSAkQ0kTIMRWiFXRYNDaaAvWYNGZSdC6+OXsav/98Br6YB7vOecJ5TnHOJl2fzbEDEzl75SR2yGWkh85m485UXllnJiyHEBUTKdo0XLosHmv+A692/Z3+WC8gYJIsrO59he3uDWQb8ikxV47qXyNq2HSsjxse284Lu9p469tTWX94CLdXorK8g6nj+3nybR1dLfnUJE1lSZWLV78+E71mZCJFVmWGIm5CsZHwA71kYKpzDtOcc7ForBi1Bi6emM3UgiRu/vtu9rS60UsiFq2G3CQHlxekk308BjvHrEPWbGRQ2YQvFp95STPqqEmxEVVUPNHo8HHGLLmAYL6BpA4NRm+YnnAb7kIRoyeGFAFXSOSsNDs1ydbhfawaG1nHvQYyq8bjKquiK7aWrLpeggdbGGxrpj/Sy76hHbQWjOPNKbPpEAZxGTIxS1bsGidp+gwatqyneftm+pqODfd9ztgMjt6zlGtOU3s9wX8msqKy+Vg/r+xpZ/OxfmRF/fCdPiZLliyhs7OTzs5O3nnnHTQaDeedd96oNpFIhMsuu4ybbrrpI/V944030tnZSXt7O6+88gqtra1cc801p91nx44d1NTUcOTIER5++GFqa2t56aWXKC8v57bbbvvI55cgwf+PqKpK71CE1r4gvUORUe8GnxYGg4H77ruPwcHBM2p/7NgxZs6cSW5uLqtXrz7jybwE/7dIuKwnSPAfxqY7FPoPwuz7BXQ2gT0PKfTthYLPjcPs2kuwy8qb/6OgMYAiQ2p1XCi379tF844t5E89i969Y/E0ghIVGPNFWHW1wh+WtHCw1MNreSUs/svoUl3t61QCXeBZexS7JwAXXwKApPvw2NvQANjyBEyueFslppK7QERn1zHhgktY+fe4OPS2gJgUP667XkVntGHKDTP3fhXRJlIw18+E2a145WTcR+K+1DqLyti7FTZ2exhjM6If8IMAQ+3tuDtbyameRMmM2Wx5+lGUSITmnVvJq5lKf2sLofpejD6ZpfffSFQdEY6V1mrse4N01+/kYHEXYTXEwtTzyUkr4JGm3yINxPjTm0PMLSzh0ppsmgPH2Du0jRlJ81nqupj1/jqiqkAwdwETsxSWTo0yMSeFNzf6MJuinDvRQqmzkvpALXrRgEOTxIK0ZdR59rLbswWdqOfc9MtOei1L0qxMKXAwtcjKc1v72LAzFYdaRN5Z9aBK+Pwa3tvu4M7byrl60on7r+1bRdNQGpKaxdJ0Jy5rvJTYBzOsq6rK2VUu3jig8o/trbxd2011joPLClzDbWKRCKIo0hVtZ4pjFjE5yrb9jYS0esp0IGgDRDVbUDSZwAUAiBoNJaZyhjrb0ZstrOl9gUCKn7IuJxXrw2SPt5Jnj3/+YVmhLxQh06Qftio0bFlP96GDZI6z4y0XyA/m4MjK4fW+F+kItTA3eSmzkhbRH+1nKOrGrnXwuewvAjAwtgmDzY4ze3Q2/kTs+H8fbxzo5K4VtXQOhYbXZdgN3LmskiVjMj614+r1etLT43Ez6enpfPe732X27Nn09vaSmhoP1bnrrrsAeOyxxz5S3yaTabjvjIwMvva1r/GVr3zllO1VVWX58uWUlJSwfv16RHHEdlJdXc0tt9wyvNze3s7//M//sHr1akRRZObMmfz2t78lPz//jMb20EMP8Zvf/IbW1lbsdjuzZs3i+eef/0jnlyDBv4P2gRD7mryEIiNeYgadyLh8K1lJhtPs+fFYuHAh9fX1/PznP+cXv/jFadvu27ePs88+m7lz5/L444+j1Z5JRpwE/xdJCPIECf7DcE0WkCMqXTvgyDMKOfMEsmap6MUSCiaXIUdAlBRcNTDxVhG9PS46tEYTgiiiM5o462cigW5IKheI+FRUwCSL6BAwiic6xvjjXtKYS50wJl52bKhRRW8HQ9LJRU14SGXPHxTa1scTui97QURjFBA1AlN/OLJPaCD+b9F5MiAxcFjlna8oOEvNLHzYhhyOz2iL4QhCNIojM8T0uwQ8TSrZc0QODnk54gkQ6xUo0ZeQPhmOvLMCb2835qRkUotKqT7nAureep2wL27Fza4cwwXf/hFJmdkYdXFRmqRNxRtzo6gKA61NdGb5CatRUnXp5JuK6BoKs3pTKsn2KNsOudGat7EwYuKtnleQkXmv/036Iz2cM2cM31mygDSrgXV9q6mecJQSi4E9R0upGLueQfpR1PEYRTMufSZnuy4EoMRSyWCsn7G2GlRVZfPgu0hoGGubiEkTT0SWatVz5bJGeiKdTNJdRo8nmxvOKqAkfRrV59Xz7vSV5GjGcmBoF0aNmZVbRF7Y1cZfrp9E1NhIb7gLQUgGWaF21UvYly7DYLVR691Dd7iTmUkLWLW/j5v/vpvZJSn84pJxnDNutMiJBPzsev5pBLOOPTU95BmLKA1M5IBFhxCLEW05iqgoSCVhjJKBsBxCLxk4MuTHMGYS1dNmcsCzi4DiJ8uQx/Ql5zPU3UdKxshxNnT00RKKMcvloNhmwtPdhUanR2syYXFMoxUToVwbkkbLWFsNZslCrqmA3UPbqfXuosHr47q884cFd1JuPkm5+Wfw60rwn8wbBzq56cld/LONq2soxE1P7uKP10z8VEX5+/h8Pp566imKi4tJTk7+RPseGBjgueeeY+rUqadss2fPHg4ePMjTTz89Soy/z/sWtkAgwLx585g1axbr1q1Do9Fw9913D7vb63Snr1CxY8cObr75Zp544glmzJjBwMAA69ev/1jnlyDBZ0H7QIhtR4ZOWB+KKGw7MsSUUj41US5JEj/72c+46qqruPnmm8nOzj5pu02bNnH11Vdz1VVX8fvf//6kv+UECd4nIcgTJPgPou+ASsnFAlXXizSuUtBaIGsW+LsE9v+vir9TwZorMO4r0PoutL2nUnR+XJS4SitwlVYM92U47nWtswic94zI+VIeigQa8USBPfnbIt4WFecVU0EQ8LTEE79ZMmHpExKKrKLGQNILdG1TObZCIa1aoOVtEDRgyoJdv1XQGmHCLSMu1P6ueI10bwsc+I2fmb8TMCZrsOZBcpXA3j8qHH1eZdYvRFw1TgSLHsFqIFsSYXa8jzFRCxpFoPG7RnrcEhe8LJI7aRqDzU10vL2djY8+zqJv3cbEy65Bbx7JsF08afQL78WZ1yKrMjpRx/jzL6Mk4qNV10GxuZy3DvZx+0v7uWrKZOaXpzKr/B3C+ibqfEkoKAiI9EXiseje2CBavY+2YBd1vr3YNU6mOGcx53Mmmn0ZhFQv9767CZdLRnW1s8O9kUb/Ec5Ou4iz0y4EwB0dYL9nJwB7PFsZb5vMtKS5AKTo0wgpQcrSkrj/svzh8WskEQSVQRppHYzHtjZ4x9PcH6VpwEuDYTUqKimGeixbdiAFBPwxHwZs7B3ahic2RLllLFWZDsZm2VlU6eLyyTknfgmFePiDKMcnMbKMeeQlZ5N/qJ6oVkd7XgWoKtflLqDOt4vHWn9PuWkyx4bykAQ91xdnEjvukVBgKuHp5qeJCiLL/JeQYbXi6+shtH8HxtxS7IKd3S/+g8BgP4IkMf6qq2gPaqDHjQZo27uTpPRM8l3nAlBmHsuhoUF0lI0acpM3iDsaY5zDnHjp+S9FVlTuWlF7ghiHeFpJAbhrRS2LKtORTnIP+7i89tprWCzx+4ff7ycjI4PXXnvtE/k+PfTQQzzyyCOoqkogEKC0tJQ333zzlO2PHj0KQHl5+Wn7/cc//oEoijzyyCPDk1OPPvooDoeDtWvXsnjx4tPu39LSgtls5rzzzsNqtZKXl8eECRM+4tklSPDZoqoq+5q8p22zv8lLplP/qXlJXXTRRVRXV3PnnXfyl7/85ZRtrrjiCh588MFPZQwJ/v8i8eaSIMF/CJ2bVd79hsLWuxWUmMr+P6uoKqRPFsiZJ5C3WCBlnEDt31QOPgZ9+6Bx5cjra8dmlZ49J4+f0hgERK0wSoz316pEPPH2mTMEyj4nDj+89HawF0DKmPjyuzcrvHy+wr6Ho0QOdiAMDKHEVFyTQY2BNQua34T6lyE4MOI+1rBCxdsCGr2MOUUBScSYIrDkMYkJN4so0XgiuOMVwBAdJoR/KqVl1WqYnG6nbJGG4gsFtNZ4kq+88VOord3CsaN7aK3dj9FmR5RGJgNibYMoA/7hZUmQ0Ilxi5HR7iA5NZtq+xQsGhvHejycZ+okK3yIXepjyPp2sg35lFvGcnX2l3GIIynguyJtPNvxKD2hTpK0KRRbKjBJZgRBIN+ay6ajQVZtSOaN9zKYYJtKk7+egWgfg9F+OkKtbOxfw/6hneTs11Gwx4igwF7PdvwxHz9fVcedj+mYZb4aywdqjAMUmsu4JvsrmKV4DLZFsvGDxdN45WtnsaAsg0xDLhpBS1+0C+WsDKRzynE64uOen3oec5LPJl2fRW6yjq9e3k1pWTypVH9zA521xwW+/zCDgV6UWJSoz8+lGdcx1laDpNEwb0w5i8sKmZpqYkqaDq0kIqvxJGqHAtuJap8n19aBqqrkGou4JvsmSi1jiApuVGGQcMCDqqpIOh1WfxtG4T2C0Q4C7gFEjQZfOvyj8y9kmmNcX5xBylAPzTu20LB5xGKXrE/murwLuCyvbNSL1ubeIXb3e3m06XHe6X3tpL+B95E/gxjDBB+dbY0Do9zU/xkV6BwKsa1x4FM5/rx589izZw979uxh69atLF68mKVLl55R8rUP4+qrr2bPnj3s3buXDRs2UFxczOLFi/F6Ty4q3o+D/TAxsXPnTurr67FarVgsFiwWC0lJSYRCIY4dO3bafQEWLVpEXl4ehYWFXHvttTz11FMEAoGPfoIJEnyG9Hmio9zUT0YwotDniZ62zcflvvvu429/+xu1tbUn3X7BBRfw0ksvJbxOEpwRCQt5ggT/RoL9Kjt/qZA1My62rXmQMlZAEOOZzWNBELVgTheY8n0BRVYJD4K9GA49pTJ4OG4lTx4DG29XEDRw8RsionT6F7mubSrrv6uQVgNzfimdsF1vF1j8yMh6NQZKBPo2Bim9coCkc7QYFjjJXQC7fqPQvgG01nhm98HDKlufkXGWCQR6VUougeKLtFiyTnT9rP66QOX1Anq7QKzfj9rnRVOYiqA9cUzjbxot1EWTjsXf/B/ajh6idOpZo7YpQ0Fi+9tAp0E/v5wD3l04tEnkGAtOej2uH5/M3kYvuAMcQEZEZX7qORglM0e7vazaGWbaBEjVunBHB4kSQSvpuOwDtcADsp/n2v/KkEVPeamVslwPLaER8RdRwuz37KA91EKBoQRLv4SoCFQaxhLVKnibWtlyqJ2G3jD73fs5JruZ7pzLEf9B7FonOcYCzBorM5Lnc9CzmxrHDGxaG6lxj3zOS7+cwUg/TYGjVNkmoBP11Hr30uhv5qykhZRbMwHwRj20BBtoC3ZRZJrO0bVvocRihJM1vBVcSUGdBTNgT8/E19+LNdXFBzngfxF3dIDe0GW4DJUI6lYQYqgohHdvZ6ulib1ZjUx2zKLcMoYLbRcTDASIHTvGljdeY+y5F+OeNof+kI66SAORhQ66Yh2YtTZ06JEEDaIgYM/MJr1iLI6s0VZ8zUkslpVOlW0De1GEXoKyadQ2f8yLX/aRps9gQ7ebBm+Ac7JTSDGc3p03wWdLj/fUYvxfafdRMZvNFBcXDy/X1NRgt9v585//zN133/2x+rbb7cN9FxcX85e//IWMjAyeeeYZvvjFL57QvrQ0Xqavrq6O6urqU/arKAo1NTU89dRTJ2x7P+79dFitVnbt2sXatWtZvXo1d9xxBz/+8Y/Zvn17IvFUgv9YQlH5wxt9hHb/KrNnz+bss8/m9ttvZ/ny5Sdsf/jhh/nud7/L0qVLWblyJXPmzPlUx5Pgv5uEIE+Q4N/IQB10boHBuhCi7KfyqzaaV2tIrRZY+KfRolRVVERJoOqGuNhuXSMT6AFrvorBIVC4TEBrYViMB3pU9vwxgJC9h0nXTkKrGyn/ZMliWPyfCfMfFGl+SyE8YEYqzUBr1yMZBDQGyFkg0LFJpWiZwJgvCLxxvYKvDQYOq8ghMGeoVC5X6NwsMnBEpeIaAVESqH1CARUqrxMZOKTiW9NNWoEfwahFk3tmcZvJBQUkF5wosgWLHiknCcGipy/SzaaBNRhFE9flfu2k/ViSkymeNR+d2UyWI0x7qIW9QzuY6pxNn1DLxDGDdDWVUlCh0hvtxtwvsC28hp1d69AbLcxNWYKCQkgJYdKHuGh+PLZtIBIjrIQoMVeSayzErnXSFKin2FTB6mnPkK7NYm7mEuRYjC2vPswSycC4KTX0izto8Q2Soktj48A7o8aeps8gLfXkcbROXTJO3ci12+Pejlce5O3OfC7NGwdAki6FXO1SOgNGNnS7qZk6C8XnIS05n9z+IpxOEbm3B3dnO607djJj/iJ0kohP7sMgGUjWpRGIxWjwyngjYbSxy6hOspLt7+FI2xtI2QpaQUtT4Cg73BtY5voceSmV1B19g+aKqQx5Imh1TgSipOrGsCu8D0VUEQWRJG0G2wbW0R91EwjOoLKsmnzbh8cBVtlTGZQFrNJZjP9AAjuAld3PMRjt55KM64gpWhQV5ISR/D+ONOuZxXueabuPy/tlyoLB4Cfet3Tck+dUfVdXV1NZWcmvfvUrrrjiihPc5t1uNw6Hg4kTJ/LMM8+QlpaGzWY7aV8fhkajYeHChSxcuJA777wTh8PBmjVruPjii/+l/hIk+LQxnGTC/uO0+zjce++9VFdXD0+ifRBBEHj44YeRJIlzzjmHlStXMnfu3E99TAn+O0kI8gQJPkOUmIqoGRHBmTNg6g8EDvy8Cb9SRtPzffQ1pNC5WR12FwdY922ZwaOw+JG4m3f3DpX2jaBGQRQEBEmg5n9Gi+vWd1Xa1xrw62PoM99k4tLzh7dZsuJu42eKqBGIegX2P6Jy4FEnohYW/a+KNUcgd75IWrWK3hl/ANlywdcB474M+/+sEOgWCO3uZvcfXfg7IXWcgLNE5eBf46ro8D9kchdD3+Y0hvp9VMz+114sAbq2q3iHZB7z1nFWcQrn5KcQ2iCT9cY15N94YgKYD/J+/L1FibK69xVUVPSBciJ6HzqtwhU1BfhlHx3hNvTBGAFHFFWOEZbdvNu3ign2aaTq0hGCMklbA3iSIrgrBXSigWnOORzqCHHXiga+OrcUuUhmyBBAr/MBIGk0FEydyT2ruqnd1s7P8qYzsyRCmWUsQ7FBkrQj1q5ITEFWVIy6D//8ZiWfw8beJvJN8dJfYVlBIwosSK/k5ZZeBiMxNLlFZJjikzVLXReDC8KTQmzcvYUuRynvdQ/SHx4kol2BSTKzNPUL6MJuxJibqlwb7miIbKORQ71RWibMZXJBDsutJl7a9SeEZFjT7sam0zNjxlyCbQMEZSjXxegKCnQFBC7JuJb+SB/v9b+BJ+ZGLxgIqUG0ShDfoVa2HNpD6dxFKJl5tAfCjHNaTrCSH/a20BMaoDSlCo0Yf6yt23eA8JCbrMJsNDotZo2V2elGpskKBs2n/6KW4KMxpSCJDLuBrqHQSePIBSDdbmBKQdKncvxwOExXVxcAg4OD/OEPf8Dn87Fs2bLhNi0tLQwMDNDS0oIsy+zZsweIW73fjz8/GYFAYLjv7u5u7r77bgwGwyljvAVB4NFHH2XhwoXMnj2b22+/nfLycnw+HytWrGD16tW89957XH311dx///1ccMEF/OQnPyE7O5uWlhZefPFFvv3tb58y2dT7vPbaazQ0NDB79mycTievv/46iqJQVlZ22v0SJPh3kmLTYtCJp3VbN+pEUmyffkbzsWPHcvXVV/P73//+pNsFQeChhx5CkiTOPfdcVqxYwfz58z/1cSX47yMhyBMk+IwYalR556sKmTMEpv0oLigEUSB3oUD3uxb8m8Bc6KTgMoGsf6r5HR6Ku6/LEdjzoELnJkiqgJy5YM39p7hwr8qRZ1W87eCa28WAepDCCRedOKD3rTNG4wmbwm6V+ldU8hcLIMCabyhYc0DUgBKLWxjl8Ej79zOxK4EI026LoeiMaC0CGWNDBHd2YMpyMP6rIoOHVVLGxgX+rB/4CLRG2fm4EzUGnh4jnjVGMi8VSK44YUinpXeviqRT2fB9FVUWWDGhm10tbs4Zm0HDyxDcmYZlpgvOoCS1VtSyOO1C9rUNctGfdrCwIoX7r/w8Tl0ysipTYR2PL83LhmMr6DMOIQBeeYh1A2/yhdxvEuwfZF/wOQw+EbPGykUZ1yAIApuOHWNXi5s1h3tYWDmWyzM/j0ky4+5o48i7q8mZMJlbzx3Pu4d7OK+qFJsh/jIxI2k+USUynM186W/XMRiIsua2OThMo92u+yO91PvrGG+bjEEykmPK5LLcNKJKlNe6XqArIJCpm83SzCQKGvYS0Blxplvw9rpHuaa/2rmFoSRI13mJCR2o5KIlmXR9Glt6h3APDpF+aAdrdBvolfqp6S0nvK8FW0YBwYI8ZEXB3ptHesMAjTVOIoqCIsS/8yZJxK1uRRYN+NUgr3a1c2HGVVyYcTV9oQCNXoUim0SaPpMhn4dWICZHWdPZRkQ24o54mJ+RjaoodB06iNsksC3qRGUinb4WlMM9GDNzOGZMAmMSF2oEznItptEbJCj7qXScWjgl+PchiQJ3Lqvkpid3IcAoUf7+He7OZZWfSkI3gDfeeIOM45UArFYr5eXlPPfcc6MsWnfccQd/+9vfhpffT4D27rvvntby9ec//5k///nPADidTsaNG8frr79+WuE7ZcoUduzYwT333MONN95IX18fGRkZzJgxgwceeACIl1Nbt24d3/3ud7n44ovxer1kZWWxYMGCM7KYOxwOXnzxRX784x8TCoUoKSnh73//O1VVVR+6b4IE/y4EQWBcvvWkWdbfZ2y+9TMre/nTn/6UZ5999pTbBUHgD3/4A5Ikcd555/Hqq6+ycOHCz2RsCf57EFT1s89w4/F4sNvtDA0N/ctuVgkS/LcxeCQuyNOnwMyfjbbQeZpUDj6mUHq5SHLliQ+RWCju/q13CLRvUNn6UwU5AnMfEEkdL6AoMp21B9hyWxVKZGT/wvNBYxRof09l9q8ELJnHLYuxGJ33rsHrsVJy9yQE3eiZ5IN/U6h9TCVrFlRcK/L2VxSSK2D2L0X6DqrY8sCUMmKljPriAj5V14DFEqTPn47k9eC6KAPREY/pDfSoHP5HPCu8LV8g9NZBiClEi4pp3qij/iUwpcKiR8STPkg9LSr7/6xQcolIWvUHy6qprLhMQdJC8SUy/v4QB6b1MbHASU2eE0+zSvcOlcJlwhnVVX+fI91ePvfwFgw6gc8v8zI1J5dazx7csQHKzGM47D8Qz0JuyGG/dxc2jYPLsz6PJEj4BvtolBuIamQ6Qi3MTj4bvWDlrdpuLOl1tIePcl76Fdi1TlrrdnNkw2Y26V185aLzSLWOhBa8f3v+e/ufCSshrsy6kfN+u40Bf5gnv1ZEZVLRcFu3P8p7h1sZNO5iQmbusOv2c+2P4Y0NEVUjoGrI117LwnQ72576K6igs1gIDbmxnzsZvz7EJMdZPN3QSlRRmekyste7ioFIP5rYUkqtmURVlWZfiPT2o3jzjjKImxTPRAoaekkdO4Gc4lIODPrY3uehxGJgcpoDUQB/VOa1tj7yLUZKHUF2D7TiiQ0wKB/gooxrSNWns6VniLohP+OcFmpS4s+GaDhEfbiDjd1+JJIBlWuLMjnStpXdPRtJadbSV7QIm1FgjHeQjr27sGdmQ80slHCIcTnx2PnH6zuQVbg4Lw27LjEX/a/yaT+//111yBMkSPDfxcnqkBt1ImM/5TrkCRJ8GiTeShIk+IxwlgpM/o6A87hRpP41maaVMOX7IrZ8gek/PrUbrcYg0LlJoXe/yrgvCUz+rsDAEUiujG8faG6kaesG7GP0WJNLsReq7H8YGl4FjUklFoDm1VC1/HiHosi2jTOJhPSkHgNnRXzCoP6leIx39hyoeyIe3z75O7D0CRG9Iz6O9JoTRW3D6yoHHlFxVWUwblkvmx9yIkoOzp/nQe5wEzElU/+6hvqX4pb1Sd8W0JSmowYi6IsNHPuOQtQLFbdB3z6VpApOEM/t61U6NoDWrJJWLeBtUVn3HYWceZAzJ559Xcp5g9BgkPOSppORF6/7ZssTsOV99JnyUpeVOWWpvLS7nS3HBrA7hnDHBoER691AtJdMfTYm0Ywn5mZD/9vMSTkbizOFsaTwevfztIda2NS3hnL7OM4bV8xrXRvwyfFEY3atE21BGk/tNrJmnwGfuY5vnOMky5DLrpZBrn5kK8tnFFA0TociyIiCyKpbZrGq6yXWe17EoD+fQnP8CzXgjaJEzKTpx1BiHnFVjaoRFGQWp16AReMgRZeMIAhUX3QFqNBZuw+vVsfuyA4CIT95xkLOcll4p+8J1vcb6OpxcnnF52jzmyi1m3DqtBRZw+QUz0ZWZ/B8UwcekxbTvKms7/eQ2t7PuCQLDq1IgE6CMSMOvRGHXuTqwnQEQSAUs9LhU4FsLsmZSrI+/lmNT7Jg1Ur0y1t4tKWW89OvJFmfSp6Uw26phZDShCwM0hWO0arrxJeioIuq5O9cQ+7EKbTu3wuAq6wSrROM4oh787RUO/6Ygk0rEZT9iIIGvTgy+ZHgP4MlYzJYVJnOtsYBerwh0qxxN/VPyzKeIEGC/06ykgxkOvXxrOtRGYNWIsWm/cws4wkSfJIkBHmCBJ8RPbtVtv1cxV4EEx/sZtuaIbSHihg8pGI77nbevUPFkAz2AoHwkMraWxVEDcz7rcjBx1W8zfESZTnzRXI+EIZkz8wmtbiMpPkaUgpENt0Rzy7qLIPMs6B9HRSe+4GHlCgy/hYDnmawl8bXH3tVpekNFWMqVC0XcE1SUWIgGcBiibeJBVWGGuI1xD+I7XgibE+3gUCPwPwvHaOtJxcCYeTmfpp3qrTsTaf0MoHC8wSUqIqUnUT7BuhcoTL1RwLta1W2/BhApfgimHDz6GMUXySgMUL2LIHGzVvp3iIT6J6K+xjM/kXcWn94ZTF9q8rYWyuT8djH/8x+cG4Fc0pTKSv0kmFKwxfz4okOIgkajvgPAGDSWgko8fJqh3z7mOqcjUGKhwFk6LNpDTbiPdrE3nAL4WkLWZx2AbXPRtj2tIkZP1FJr87i+unTiYQGKCjoZGX3W5yVtABPMJtQVKHXG+a7mdejEk98BlBgzSfq85GkG4ktL3AZCcZi3Pb8YbY3yNy57Ljbqcrx+usGUvVpw+2NNgcAhdNn8/B7x9i6ZR9zpnZx0LuXac45aEUNLe5Bnq7dxzkFU5iXMSLy8yzx8wtEBSYkJ2OWNBz1BAgrKm2BMOOTrNiMDdQHN9LfXcGVuecBI2Wcaoe6h/uyaO2E5RB+2UuSLpUqp4U3u71ElDBhJW4lNWm0nC0JHFq3h75S0GfV0BluQyfocBWXk19QQKarhHDAjxKNImTaeLb9ryTr0rgk8zpURSHNP4gtLR1vzM8z7X9GJxq4Pvemj/8lSfCJI4kC04vOLLFjggQJ/u8iCAKp9kTFjAT//SQEeYIEnxG2HJmkrC5cYyRkVcW//C0yF/WTu3AaAJ5mlXXfVtA74fwXJY69ouJpjO+74fsKgghjvwSuiXDkOYWmN1QmfstD4+4VhNoKySyfT0pBXLDlLBDo2KjiaYI5vxbJngOxcNwFunt7PP48f8noxFgV1wgYU6H4AgFBFJh174kW+52/Uml5R2XK7QJ5i0Q6NqvEgipaE5hckDwWdEIIozVCaipIecnIUehZ4cRZClU3CLSsUXn7KypGF2j0MHgYMmeIZM8RaFmjIEjgPDFhKVqTQMnFcUG376slzL6si8Llx7AvyQXiY82bXkFLsULK2FPf2iLBAAfWvk3q2MmkpaehP02CrxSLngsnZA0vN/gPs929gdnJi7ky60uoKBhEI02Dfby4vR+HSYshfyQm36GNW2gHsmVSG0V2uDdSZh2D3Kkl6lUJdKu43T0Ea9/hqilWivMnsnuog1++GKDXc5jV35xFQaoFQRAQGJmgGGurYaytBoBgTMaokRAEgbAic6jLOyrh29zUpfSFu8k0jC4f9j673FuQszbRedRFSPHTGWrBrLFwXc7X2CjWkTO5jzBJDEVio1y9O4LtvNUmoACzXA6mptrxRGPYtBpSDFry5Uyag3byTKOP2xPuZIdnJTphPlX2FPSSyCudL9IVbueC9KtIN2SxIHUZAdmHTesY+dwCAZBVxmsnYhFsCHINCG7q/Pvo1XWzIJZC8VlzgXipM4vGRrIuPgHRfmAPzds3k1E1HrFqLIqqJyZbicgKOunEMmoJEiRIkCBBggSfFQlBniDBp0jvHpWID7JmCkT3rcN04HXauz9H4ZU1XFN1A/qxhmGroSktnnX9/SRtuQsF3MdUMmfCnt+CHIXCc0V69kD7xril2t0SIBL0Eo300fyWStHxROrZMwUaJ6qoMihRlbduVBFEqP4q7Pw1ZM8VmH7naAu0OV2g6vrTu3ollUN/bbwm+eHnZPY9FF9vzYdAd/zPm58Pqkx2WT9O2YNg1jLjxhi6CbnsfUjhyHNxh29vMyz4o0jffpWMafFEbxetlIgGVPwd0L1TZeevFcbeKJIzd/S4TElWOuuDFM6LgFbDngdl+mvhrLtFFv359Bm0d7/xGhv+8TiHrevwTLmEp84tRzDpEJ3mD/08RbRs3ZtEarFMRZV9eP3slIX89NA6sp2j49bSDdmYJDMhgoRLTVRa46XHJnxdoPhCAXuBwKFdDVi7IECA0jFjKLWM4VftbzMYiGA1aulpraPL3UL1mEV0RFtJ02Wgl+LHOeYJsK7bzfgkCxOTbUzMdbLy5plk2kcmBTINOacU4wC+2BCSRuYb80uwWFMwSzbe6X2NDEM2s7KrMRg8HBj0oQLT0xwAbOpp5dBQDIPXiyIZ0PkEzLYMLswbscAXWfIpsnzphONpBA0mJUb+9ndQUnLpnjmPlFYtph4zhtS4pUMjarCJjlH7ZVSMwZGZTdOOzex8+nE0E+YgWAtIswRoDTbyYscTXJBxFXJzP57uTmrGTMWjelFVFUtKKgarDU2Ki2SDmRn269g76OXF5h4uL3Cxw72B3nAnC9MuSLixJ0iQIEGCBAk+UxKCPEGCTwlVjcc4K1GovEEgf+4kfPmZeIZK6N2nkrconuwMrxcAjdXKWfeMiElLpsCMu+LL9nyFUB8E+2HdtxT0STDrfoG08Znsv/xyYkMONEYIdKuYXPEyaLPvj++ryCqp41REDTjLBeyFKq6aDx///j8rNL+tMvsX4nAMdsmlIs4yhXdvGckFaUwFb1O8trmvHdxNGmxFGmzJYZBl8MgowSiqqpI+ReDYiniCOkEEaxYklYl0rIvQ8qbM+Ft17PxVPHY9f6mAvwMGatUTBLlrgsixt9JJXSaw8TqVWCieXd3XqXD0eQGNCcquENjwfQVJB9O+FUa0GRAkkdyx1WhfeQGzEiDDrCO6rw10GgwLPjy1u7c3jzWbu2mq95CR8S5HfAc5L/0Kki2pPPvNfNb0v8K6bpHZrrMA6A53EJD9pGhdXJJ13XA/olbAfrx8ektyAYGCCCWlxcPbV3xjJv5wjAy7kaeb3sbriODuCFOvHKXYXMGC1LgL+PtxtZrjkzqqqpKZbMKuldjh3ohZslBhHX/aczoreSHj7JORVZnnO95DI2iIqTH6Ij1UWqupsJtQVZUy+8iERVTWIyCh6GXyt67GPHsuDIbBmX/aY/U11nNAOYwcmktE2crRvLHUtvVT2SFg6lcJNHfiqIy74QdiMrv6vRRZjcNl2Yx2BygqqCqCqjIjzUGqcQkvtz2B8ViIduUQQ4fracoegDaRgCVGUqeWvl0HCI5PYq+qQ9fSzdT+FrRJueg0WgTgmL8OT2wIb9SNXu869QkkSJAgQYIECRJ8wiQEeYIEnxKCIFD2OYGOzSq1j6qEByzM+FMZfftUcuYfF5jRKDz3TPz/114P2pPXzdxxv4q7HuY+AK4pMHgItt+nMv/3UHZJMs1vqAR64mXR3icWVNn7kEryGIbFOcDiv5x+3NGAitYUt84HeyDYB7YPlAvbdIcKKkimeDmiksug9lEou1Jg/19UIoNQfRMYnHno7CHqHovStt2A/McISXlh5vzKzMFHZHoPCLxxncJ5z2s49NcI/c1Gwt4wolmPyQWll0LeQpHkMSeO0dMCoQGIeOJJ6/SGMOWze/C35XHoaRVEKDgHeveCKKmENjRAWhKGCRloRAuxUJCZhTYuunQ8g5v2s3fjGzgiR0fVav8gkf1tEFOYVJHJddPzmJyfxFB0KyElSEgO0BVqwx/zo6Ly5LajTDp7KiadhjxjEXOSl5CmP3V26JIkOw3aseSljljcXbYRS3uhs4LGSANF6VUMDA2SZcgd3pZvMXJtkQFvdweqamH/oI+d/V4qnQp7fJsQkU4Q5Ac9u1GP9hNt6aN8/hKMdgcWycHrbX2Y1Ek4NXaK7VpSjrt7W7QapnxgbG3BJpymITT+NBS9CfP8ZSStvQmaN3Jk+UY2RxzMcjnQSyLNvhATU2z4W5sYaGmk5+gh9BYz8sTxtEycC4KAQRLJLi2jaXM33XUHMezYg2i10TlvEUc9AQIxGatWwqKNP67KFyxhMBCkUqtDL4VoDBxlVmwGrY0bUL1dGCcVEIj2ka7PYJyphFhniFg4hOIPgsGHUTHRvX8XpUktTLjoCgCWui7F7e2BDi9qXiqCKBKMyTT7QhRajQm39gQJEiRIkCDBp0ZCkCdI8Ckgx2K07NxCxoIssmfnc+CvCrkLBczp8b9hRBGSk0EQQDq1q3VypYAcUbFkCsy6V2DV1QpRfzymu3sHTL1DIK1awOAc6XugDhpeU+nZC65JcRf39MmjLc2qrPLebQq+TkipgsyzBLbeo1J1vcC0O0QC3fEEcx9Ea4WwG7RGiAXgyD9AZ4ddv1Gx5kJkEI48B93bBWZ/pY/+Wgfebi0IEHSbKBiUSU4fwttgQWsSQNBQPHOAlGwthzemIWoUnJUCJpeIvfDkLvTTfiTi61CxFwpkTBbwvdWOv0+LuRym3S4jGiQMTpFF/6viOxog0Ktn/R/SsBUoSHoXNcn3M3VWhFhtB0f769i9/z0mF6QM9x8JBhjqbCc5v5CeUCeW9j5EVaQjz8NPLojPEDT1z2f9/nT2Rgdo1b6NhI631+UT82UMCzhBECi3jj3td6XAaqTAOuJiHpUVnt3RytSCJIrTrEzLXcxkVUUSBPItJSfsv3fVq6x9/M+cdcW1pC5chkYQcEYkxu1Jw1gYnwh4p66bp7e2cMvSNDYH3yavVY91QCIwOIDR7uCYJ0h/OAaU0ReDhekuDB+Ira/vO0DPlp1YiqewU7IQE9tYkpnO7l6BPREotuRgNSUTkMwowMaeIZx6Db2hKKlGHe4t6/GoItGUTERnCil6Hf2IaAWBeRlOunz9yHlWUu15dF/7BRAEivaeg9dhpisY5vmmHs7LScEjN7Lfs5PxtoVoYxJ7POs46q+lSqggo3IsamY+OyM6Ksw5TE7OwCiZeDm9i4AhmTml+UwzqOgVHbuCBfRYy3izrY8Fmck4tEl07txMe0sTJbMXkFZSzu5+L4c9AYKywoRk62k/wwQJEiRIkCBBgn+VhCBPkOBToHNXN3t/UYR9TCvz7io4oe74MJIEF1z0of1N/OZoC93Zj4ooMjSsUAn2qTiLRovxQK9K2zqFsivjCdO2/lShdy/M/LlIxrSRdooMA4dBDkFrTzzZGyo0rlKpe1Jl6o/AXjB67HN+KdK7Jx7bHvXBW19SIQqiBoxJcZFuyRLo2qay+xUXOeO8DPVEETQiIbeGoXYNh9c6Scn1Mf2XFtxHoX2fEVEUyJvuo2paK90NFnzteSdN7gYQHFB592YVZ5nK3F9L2M4t5cAdMp7XQ8xZ3oCoNQGF2PIFtt1rYPBwIRojaE1QOLEXhy2KqtEQlAPIQ4PMuvgKJl929XD/DZvX099YT+GMOUTzTKzK24qkivR63BQ6KxEFkVd29/DUxgHcfgdTp1kJ4mXR7Ga+lH/Zh36ep+ONA1384KUDTClI4tkvT6c3FGFVWx/FNhNlgX4CHjfJlWWYNBYAekQrfcZ0zE4nRTYTRTYTPUcP0dvvo0s4hLtiEquP9rDhWB+VdTEs+dBWGWaJeyLJkRgAyQYtBkkg06in1G7GoJFobGzCZrORnJzEgZaNpHbH6DG3Q3YlKWo2mcYU5OQIrb4Q2oseBElkvKrS0NyDLyYzzmlhMBKjwGJgaPps+gf62W3PJEIrqfWvMFHJpmz2Ql5s7SOs2IkUech1pZH27W8j2qwc9Uc46PaTrNOgE0X2DnjpDGoIILPOH0FWB5jqKqe/u4XI/kYsNYtw25MI9HoQ1WSMUjwkJEcN4T+8A0UbwzRmHEeCB9hlO4iketAEZxNWFDSiRHJ+MbFIBHdHG77+PgrGTcIfk8mzJOrZJkiQIEGCBAk+PRKCPEGCTwHFm050APDYPp0DCHF37bIrRMquOHFz0xsqx16BvEUCKWMEMqbHLey2fPB1qOz6jULBOQI580REbVyQV94Qj+s+5x8Cb96gosRU2l72kDXdjqCV6N0Tt4Cb0gTyFsdFvdYE5/49njAOYXTtcFEjc+RZHXU9yZRcBkdeiK8fPKyy+BEJQbCjtQjx4+yPZyNPGSMjiKA1qYDKm5+Pl33LnC5QdUN8UqJ1rcq+h+O11SNDI+csagUEUY370X/AsF5+pUjnphhjbxIxOCQi+6Io7SpeTQbhkAZzUiausmIEcWTSIzm/kGjAjz09E5MpiaSSKznctZsSVTNceuyaabn0hXswZ2+n0DCFQ96DGJQRK3uL+wi+umbW91rZ0Cvw0NUTsRpOHpLwQaYVJnPuuAyWVKUDIKsqigpRReXo+ndpLgRvs4cZKdkUmQu5dVMYIfdCFlXCMf8hiszlpBaVss+/k17zAO1+lfKKZG4vcrKs0MY2TyfZ1myy390JHIGCAlIMOq4sHHGrP3aojnWiDW17P9cIKhPLF9GlraM6dyL2TRsJd7QQsKeTn+oi/3gJtMPvvkl3Xz9FU+dQkufCG5MpsZnQiCLJeQW02Ltxu59CEjSYWrT0a+t5qvUwonIJIDHJNptcYyHiF+Kx9P2eAAKQHhgk1dPLTlcJMcWISZxHVBVJNWgpMrk4ZrTSX+mh52gdns3rKJh9DlNTRn53OXKIo34vgd4uYBypunRSdC4KjGXkGlMwH/cESCspIymvgK1PPgLA1IlTWJSVKL2VIEGCBAkSJPh0SQjyBAk+BXLmi+is4CgxnbAt2t1NtLUV06RJ/3L/236m0LYOdNZ4fe6q5aMt6IXnCsQCkL8krkzLrhApvVxl569U+vareFtAEFVy5kHpJQLeVvC2qLS+oxIagJk/g57Xeimu6UNuitLvSWPdtxRSxsKc34jU/k0lI7cXszCAriYP0WEiPKTiaVRxlgnUv6zg74qPRZXjcehqOL7cugbGf11BID7m5EqBogug+W0oWCZx4M0MCif24Tvsw9MYTyQW7FOpugGC/Qpb7oonlNOYYPqP4+fXtk7FUQwTrw6iHFYRxBFFnlE6REqgFakjmZg1nTaXg32dMuq9JlRVQI6ej+N7AlSOXL/UwhJSC0uIKBFe6Xwam8aB8d0OQtEI4Suq0ZvNJFv0XD83mXd6o5gNIhearkevjZ9T4yqFXQ/kM2GpjrKMHn5+tJd2d5Dy9A8X5KlWPQ9eNXF4Od2o53MFLnSSSN/0WbTIPiQlg65AjHzVw5wcE5b0MEeDe+mNtVJkLkcQRaZkzMfoSMKLiF07SHmqiSSjhSXGi+MdT9HEQya0WiJKmJ5wJ1mGPARBwGq1oO8ZwuT3wHNvk3vxpeSOPTf+eTnsDPrs6IwmYoqCOxIjxaBjoKUZv9NFoyeEag6we8BHqkHLEpcNjU6PUbKiETRMc85FyO1isLEBZ0uMaGE/qdpcqpPG0uYPUe8JMj3NTrHNRJHVyJbHV9ARizG/pJKY0UFfOMpAOMq0VDsqMt2aXlS7itKmosgybR4//eEo6ccTwaUWl6G3WDEnp3Jk/Rp6BwbJCSjkTrWQ4hxdv1aj01G5+Lzh/ydIkODkCILASy+9xIUXXkhTUxMFBQXs3r2b6urqf/fQEiRIkOC/jkSmmgQJPgUEQSB9ymg38vdpvekmmq+5lsCu3QB0hCL0RqIfqX9jqoCojVvJm1erJ2zv3qWiKmDJjJc92/17hfqXVZreiItxgKzZ8bFVXi8y+fsCvbtBkODQ07DxBzDQn4zosiGm27Fmg6MEXJMEBuqg7gkVT10YIjHUUHzs731LYc3XYxx6SqbuCZX2dZAxKYaokWlZrSKZQGsBQxJs/Qm8drnCYG08C93Eb0qc/3w87j1vRghLUoT0yhCzfiEy9YcCs+47fqtSBAQpHsd+4Wsi1pz4+h33K+z/X5VAxI6U40QqTB25GBoJBAFBp+G25/Yy/zfr+NmGOhZ8/Qhzb4wXepfDJ7/OITlAd7iDtlATii2diDGZvuDI9mJzOZ/PvYUJjmmk2HRYjfE5zkAPKBGJIY2Z/GlF/P3GaZSn/+veEgaNhCgIpBWXsaRgPFUOE1NTsji26T2uMtZTU1FOijSFWcmLgXg28/2vvcixDWtI0mu5OD+NSodldKcTJsL4agA29r/Dyu7nqPPtAyAtK4cLxuaS7DhMT6YRTCMTS4XTZ1Nz2TUIosjmVSs5+MzfeG5vHRG9EVtvGxPfe5CGhiYcOg3OSIAtTzzCzs2b2NzlZJrtRqpsE3AVlWNyJjOj5DwuzR3D/MwkJEFgfbebZn+IzT1x1wdBEChfsITiWfPAbGVVez9t/jAzXU40ooiiSpybdhUzHFeROmcpLLyIqMnKoaEAAN6eLurXr0FvsaLR6dhpy+RY8QRC4TCtXYc56qs94Vo7s3NxZueesD7B/990dXXxjW98g8LCQvR6PTk5OSxbtox33nlnuE1+fj6CICAIAkajkfz8fC6//HLWrFlzyn77+/vJzs5GEATcbvcnMtYf//jHw+M41V9TU9Mp93/hhReYO3cudrsdi8XCuHHj+MlPfsLAwMAnMr4ECf5/Zfny5QiCwL333jtq/csvvzxcwhZg7dq1J/zmOzo6GDNmDDNnzjztvaC+vp4bbriB7Oxs9Ho9BQUFXHnllezYsWO4zQd/62azmZKSEpYvX87OnTtH9RUKhVi+fDljx45Fo9Fw4YUXnnC898f6z3+HDh0a1e6BBx6grKwMo9FITk4Ot956K6FQ6Ayu2gi33HILNTU16PX6xOTdP5EQ5AkSfAzqX1bY/2cFVTlRFJ8Ky6zZGMaNQ5eTjTsaY+a2Q8zZdojYGfahyirdO1SMx72j/Z3Q9p4yvL3xdYVt96gceValvw4OPKpQ/2I80/ucX4vU3CYw5vMCfftUGl+X2fErmcF6BUkP0vESzHIYwj4J3cQ8RKsBk0tg0f9KVF4nYi9QyZoNUnkmupklSOl2OrfKDNWrpOT5sYca0Bih6gaYck03RksUENA7IG0inPusiM4GklZB2dNArKkPNRih7/lGjr0M2/6ehnZSPpqCVBxFcPgZlZa349fGmCpw7jMi5z4tjnr4TbhZoPJ6AXupBu2YbGpfMvHyeTIDh1SkVCv6s6vQFKdh0WvQSALjUlI49J6LUMzIshdECpcJbOx/h819awj5fcP9GnwmLk67hgvTr8Y5cS6h0vmYjaMtp1rxREtq5kKVsBTlnbUCGVkOphf9667PUSVKUPYPL9t0GqakOtBKMRrLvXjHGIjIGtSfT+XI9zNRZBWj3YnBZsealn5Gx8gw5ODUJpOqGyn5Ve+vpdbSw96pSWA+sUZ7f3MjYlcLqiDgM1jpyq8iy7OWir4ncB7egRIKUaCG6SmpZl9yHmIkhGft63Qc2IsjN5cJF3+O9OwSJEFDTFHZ0O0mzaDDgEJ2LEB3MMzbHf2oqZm4SisZOj5pJQnQG4oQkWVeaOpmbYfCtl6Ft7oGqU5PpsRmpNIRH29n7X56jh6ir+EoAKrFjqzTYzxrIdvS61jTt5KwHH+h6Dp0gKPr3kGOfrTJsQSfAooMjeth//PxfxX5Uz1cU1MTNTU1rFmzhl/84hfs37+fN954g3nz5vG1r31tVNuf/OQndHZ2cvjwYR5//HEcDgcLFy7knnvuOWnfX/jCFxg3btyHjuGxxx5j7ty5ZzTeb33rW3R2dg7/ZWdnD4/r/b+cnJyT7vuDH/yAK664gsmTJ7Nq1SoOHDjAr371K/bu3csTTzxxRsdPkOA/BlWBgQbo2hP/V1U+dJePi8Fg4L777mNwcPCM9zl27BgzZ84kNzeX1atX43A4Ttpux44d1NTUcOTIER5++GFqa2t56aWXKC8v57bbbhvV9tFHH6Wzs5ODBw/y4IMP4vP5mDp1Ko8//vhwG1mWMRqN3HzzzSxcuPC0Yzx8+PCoe0hJyUgS2aeeeorvfe973HnnndTV1fGXv/yFZ555hu9///tnfA0gXpr185//PFdccZJYy5PwUe6L/+0kXNYTJPgY7PuTihyOu4ZbP/D+E21sxP/eOmyXX4ZoGu22nnbrN+HWbwKglxXyDTqsGgnp5AnFT0BV4y7gUT+YMuIu4SljR3Zueuu4eE2DlDHQvj6+PmsO+DtU0qdC31448Nf4tlgQuraCsxTGfUlA7wQlKqAxnuzo8Qzq7evAmCySs1DPS/fdRXJsHJL2PPSmGCDga4f+XRFK55pZ+NMhvFGJNd/SEuqDlrdVZtwlEaofYuev07B0Gxj7ZbCmBMidt5ecOflIqfGY8kCPivsohAdVxn5JRZQEjMkCiiLT39SELSMLrd5A3qLRc4v+zvj1Cbvjy4Ig4O9U+en5Y/jx+VW0rIRdL6uEJJj1OQgpAQ54d4GssuO7D/P5+x4isEvGFO5Gqxqwnp9OebpMeaYJ4QxKYKkKiKqILiahnvlcDQDPbmvm1dpuvrK0lJkuByu6/sFApJfLsm7ArnUOt3NHB+gUu7Cl2jnHYuO9RoF+ZJ5pGOCIEOH2S65G+wHX/UBMZmO3mzyLgVL7aIFdbh1LuXUssXCIoc527BlZlFnGElbCFJvj9dndL76Eb/060u+4A43TSVpxKf7+PppbWtAH/TjVKKljpnDwUCq6cBCx+QhHWw5jqpiERxCYZBBwD/TS0aiw0vI2Y22TmJY0B4DBSJSjngDZddvI7W2nT5ToO+dztPrDJOuDJOm17Oz38v6c1cqmLqo6DmM3Owm7csix6DBIEladlrNS7fgH+mnYU0c0HCJzTDXp5VV4e7qYIwYRLGZ0ARWNczYqChpRw7aB9cg7DqOEw6SVVmBPz/xoH1qCT47aV+GN74KnY2SdLROW3AeVJy9L+HH56le/iiAIbNu2DfMHJp+qqqr4/Oc/P6qt1WolPT0+0ZWbm8vs2bPJyMjgjjvu4NJLL6WsrGy47R//+Efcbjd33HEHq1at+sTGa7FYsFhGPF4kSRo1rlOxbds2fvazn/HAAw9wyy23DK/Pz89n0aJFo6x2K1as4Mc//jEHDx4kMzOT66+/nh/84AdoNB/+2jg4OMjXv/51Vq9ejc/nIzs7m9tvv50bbrjho59sggSnoucAHH4Nwh9IJqO3Q9l5kHaSeqmfEAsXLqS+vp6f//zn/OIXv/jQ9vv27ePss89m7ty5PP7442hPUd5WVVWWL19OSUkJ69evR/xAXpvq6upRv1kAh8Mx/JvPz89n8eLFXH/99Xz9619n2bJlOJ1OzGYzf/zjHwHYuHHjaS3zaWlpp5wo2Lx5M2eddRZXXXXV8PGuvPJKtm3bNmr8999/P3/605/o7OyktLSUH/3oR1x66aXDbX73u98B0Nvby759+045lv+LJAR5ggQfg2k/Egn2q1hz/klNr3gFu1bL0DPP4DjNS4hRElkzpfyU2/e98ya1695h4QXLsYkWtGOyUKIi+Uvh6HMQ6ISJtwoYkuLH9zSpDBwEQwrM/oWAt13F3wmTvh13Nd9+n4qgidcVr/6aQPsmlf6DoDVDx0Ywp6scfQlSx6vM+dXJhWf6FIGeXSqZZwnxmN3aWoa0bmadX0N3nZmdb+ajMaiUT25m7fezEOx25v1eYuEfYdOdCtvvVendo9C5zU54ADTNMP5WiUPRLvwNE+kJhXGNDyA5TCSVC1jzwNsMzW+pFByPie+qO0Djlg2kFpdROmdk1vfYCplgn8DYL0HVDSLW7JEY8813KhSeJ1Bzm0jufJVAj0rvHnjpPIVptxvJfPjreJLfwCPtQ2z1YJV9xBSBmKpBDUUJrzuCYNCin32K1O8fIClH4rxnQTLYMGgl1KhMZGcTotWAtirrlPspA37O6RsimKbn0tomntUWYZCMaEUdGmH07TpNn8HZaRdi0zjwxXpw/+QtTDEb97RUMCDCuakOJn1AePeGIrQFwkQUlZTV7USaPaR+aRySTUdfuJvdQ1uw18WI1ndRNn8JKQVFTHHOGt5/8KmnCB08iH3Z+XSPn0BTbx+qLoNoqkzYbEUxG1glzyJj9hJKXKnUrdlJmgC2aIyFRRloRIEB3bn0G/1Ig5M43K9jgk2hPRimJxhhWqqNgY3dqEAgT8M0pwGnXkvR8ZJwYxwWekIRUvVaPO0t+DtacZn7mTR1dC6Gll3baNs74rbnbm8lEvQz2NqCHAmjMRiIhUKYklIYv+wSWoNNNNVtJyusx5rqwuY6dc34BJ8yta/Cs9cB/zSL5emMr7/88U9clA8MDPDGG29wzz33jBLj73OqF9QPcsstt/DTn/6UV155he985zsA1NbW8pOf/IStW7fS0NDwiY75X+Wpp57CYrHw1a9+9aTb3z/XN998k2uuuYbf/e53zJo1i2PHjvGlL30JgDvvvPNDj/OjH/2I2tpaVq1aRUpKCvX19QSDwQ/dL0GCM6bnAOx76sT14aH4+nFXf2qiXJIkfvazn3HVVVdx8803k52dfcq2mzZt4uqrr+aqq67i97///SiR/c/s2bOHgwcP8vTTT5+03Znci2699VYef/xx3nrrLS6//PIzOp/3mTBhAqFQiMrKSn74wx8yb9684W0zZ87kySefZNu2bUyZMoWGhgZef/11rr/++uE2P/zhD3nxxRf54x//SElJCevWreOaa64hNTWVOXPmfKSx/F8kIcgTJPgYZJ41OqV3yOvhhzsPcHFyOpP6uzEtnPmx+q/fvpn2Q7V05uzFkjUGNTeZd79nYKgRii6E9g1Q96SKMVlFjqjs/p2KEq9khSlN4K0vK6iWvagHI5j0k+Kx1IDWrOIsD7HnQQOiBnIXgGQQMKXB0RdUenfDkedU6l9UKFwmUHH1BzKQVwrM+52EKivEwhJ5vieIekV2HYtfB1M6XLRKInQwCe+TBpQ+gTdvUJj2Q5HSSwV6dqs0vamCGo9ZlyPQ+lw/JbZsNgWNtB00I/9JoeLzKqY0AXtWDG+zhp5dKgVL4mPQ6zMw2V0k5eYPj8vTorLr12C0henbopAx30jZFfEx6W1xd3xDSnwWV2sRMKUJ9B+Mv/i7GyDUqqOg4Hym3r8MpS9I7Ws2tHYRPAFs1UMgiaAVCfSo7P2TwkAdZM4QmPCNkz9gbckj5eLUcBR1MIAcjKKtOvXnrcoKkiBQYzNQo1XI0GspSboUVVVHuei/T74p7lLm1KYwq3wGkRYNX3crRAodTLSNeGYMRQfZ4n6ZPGsNk5IqCXa0EBn0EfOFkWI+jni20MARCjNySelLwuSMW+J9vqMIgojZXETGz39GaN8+LHPn8NLRDmTJxKC7nRd3Cfx9RhLujjZ2uHKJKVEU7T7OvmAMoYGJZKSnojluqU/KyWeoz4+gulGAXfv24vb66E7LZWFuKkenGxgK9RO0B5kuRqhwjMTdlzvMlBMXTA1pWTTa0zCrMYrCUcxaFXdnKz09TdgsSYgaDUoshqwzIUYCDLY0YUpKwdvdic5oJhYOExjoo2HTe1jS08nW5KLSjdHhPOl1TvAZoMhxy/g/i3E4vk6AN74H5eeCeIoykv8C9fX1qKpKefmpJ0Y/jKSkJNLS0objtsPhMFdeeSX3338/ubm5/zGC/OjRoxQWFp7SQvc+99xzD9/73veGX7YLCwv56U9/yne+850zEuQtLS1MmDCBSccTl+bn53/ssSdIMIyqxC3jp+Pwa5BaGS8d8ylw0UUXUV1dzZ133slf/vKX07a74oorePDBBz+0z6NH46FVH+de9P6+p8sh8c9kZGTwv//7v9TU1BAOh3niiSdYsGABa9euZfbs2QB87nOfo7e3l5kzZ6KqKrFYjJtuuonvfe97APj9fn7961+zZs0apk+fDsTvGxs2bODhhx9OCPIzICHIEyT4EGLhMNFwCEEQGGxtxlVagXgKt73eY0d4NablycxyNlx0IcWmf7GGsaqCILD4yzfTsG0TyamZaF3ZyGYJQ8FBQu5iyq8y4GmOi+f+2ni5r7A7njgt1Add21UsmTJC8WYEAdwHKkE1Y86C9FkHWPvNKqyuELoUAwf+AmO/BFkzBXIXxq3ooQGVQDcceEQlb6FKyzsqbYf2oyvZwcxzriCyvREyklGiLkRt3EVeEONu76H+GPUrJQqWqoTdMVrelRhqUCm+SCR7rkr7+nicV/XXYfdvQaf40CoyE2/wsfa+ZBreFAh6FGb+TKKwvJVQWxq5M/WAhKqobPhWMrHARVQ8E3/Yth06yMoH7idv7I+ZPjuIzhjjnUeKESQ9pZeKpFYLXPyGxP5HFJ6fr5C7EArPFTGmqBRdDBVXiiSXhXBW6pE0AgM9Fo6sUZC0CnLURigwiJJSgnz9ZiIvWel6Nx7A339gtHiIHulG6XSjnZSPaNYPrxctBnTTi0B3ku9Nbw+dew0INiuuSRYOFyTRqpN4LjcV0/GSXCcTibGWfgSjDinViiAIlJnHoOaEqKww0OQLEpEVDMf3d0cHcMf6sGgOY9ONQ7oil4ZVzzO0e5Cxbh8TIh7MSyZRmjMFY2lc9MpykK6uFYCAy34lYpoLx3HXsyKDyNGQQigmcfnkHHLMBrKLi9ANehhSW9jt3UtXcBBfcCZSfRvzNR6yS+JxtMkmPaYuEXNnLUrLIWxAsgQppS76DINgkLgw/SosmhExrqoqO4c2oRN0jLNPJt9moqfPg1/QsrlnCI/wMmnrguiDIq1TbSy9/ss0bd9E+77deFMyKZ48HR0KBwaDpA31YBzsJzm/iJ6jhxjqbCeropI2uumX3JQAQZ+XACLJlhMtpgk+JZo3jXZTPwEVPO3xdgWzTtPuo6Eejyn5uBMxH5w0+/73v09FRQXXXHPNKdu3tLRQWTlS2iEWixGNRke5ol9zzTX86U9/+ljjOtUYT8fOnTvZvn37qLh4WZYJhUIEAgFMphOrh3yQm266iUsuuYRdu3axePFiLrzwQmbMmPGxx58gAQCDTaPd1E9GeCjeLqnwUxvGfffdx/z580+I7f4gF1xwAS+99BLr169n1qzT37c+iXvRv9JHWVnZqFCb6dOn09rayi9/+cthQb527VruueceHnroIaZOnUp9fT233HILGRkZwx4xoVCIRYsWjeo7EokwYcKEMx7Lv+O++J9CQpAnSPAhHFj1Mv6BfuzpmQx1toMgoBeqaFqlUnGtgDFl5MaXXjGG37z3Hr1Hj5A+Pgf+FUG+4lUYHIBLL8doteFta8bb1kzKVeW079mBmLaXMd/yEgvMoHe3iqiFquUCiPF63YKksuH7KlvvVlnyuIbB9sW4G6Lkf8tC/SsqrsnQvtV6PGO5Sv9h0NkgZSx074CWt8FeCAv+KOLvVBAlEDUq+/+sAmNorbubijHTsKogSQozfipw6AmViutEUsfFr4V3UxfFY/vpabGSNtlL+ZxkbLPjrsB6Q5Rx10YRNQrFF1pJm6iw9ccZ2FIdTLrbSmkDtG9UyZoLKz8n48jJ4qzb+lBDUSJdTrQuB0ll8eft+3Hug53t+Ab76Jj5JmLBEoJNUSIBiX1/UvG1K0y8JS7cfW3xh9VQA6TmNjDte+m8930Dvu312NO0hHb3kfflGpKroPJ6gUC3CDGZY287MBfF6H/QhP69JFzT3BSf4xwVuw+gDgVQAxHUQAQ+IMgBRMdJXmLdg6gvvoDNb2HVyqu48Ckf5Y0DVFgN6AtH4kFDUZmLHtqEzaDhmS9PR/GGiB3sAI2ItChuco8d7kJu6qMnP5n1Gii2GpmVHrd055mKOD/9SuQeDbvXHCO3xIIgiYiShFxcTIuvnqNyE0mRfHKMBfHxigYcjslEA1H2vfoiiDrGX3Q1amSIAk8v00sqEMvirnqR7Y1E/BEGMp0Yjh0h3WRAt34x6kYz4hdraXZvxO5wYU110RQK4nBoydTn0qIqmLtbcPgG0YpalmmXEn53A8nnmwlr4snWQj0D7Hn3ZQ7NiCe2K7WMpcJhosBiYFufl2wtHAyZcBeFsXp0ZGeWE4uE6ao7SMRoZrB4HCGDBVErEvaDmplPpiQj5RZzSDBiMuixWhWO1QTJaOpiz0vP0OTIYDC7mJlpAiX204uPBJ8Qvu5Ptt0ZUlJSgiAI1NXVnTQD8ZnQ399Pb28vBQXx386aNWvYv38/zz//PDDykpySksIPfvAD7rrrLjIzM9mzZ89wHy+++CIvvPACTz014oZrs/3rlRlORmlpKRs2bCAajZ7WSq4oCnfddRcXX3zxCdsMhg9/pi1dupTm5mZWrlzJ22+/zYIFC/ja177GL3/5y481/gQJgHh5mU+y3b/I7NmzOfvss7n99ttZvnz5Sds8/PDDfPe732Xp0qWsXLnytJbi0tJ4OFxdXd2/nIG8rq4OYPhe9K8ybdo0nnzyyeHlH/3oR1x77bV88YtfBGDs2LH4/X6+9KUv8YMf/ABFiRtZVq5cSVbW6LA8vX70u9Dp+HfcF/9TSAjyBAlOQfdOFfcxFWOKk2gwiDO3AFGjwZmdy57fqLS+q2JKh/IrBdpCEfZ5AyxNsaNtPEz/2tXsTXJw1hXXfvQDh4IQjYIsI2k0FEybhSLH0BlNpBQUE3QPklJQjCUFyq8Pc2jHK+x4XcuUCy4luQpAwFkm420FrVmg6YVCOjeD75CKtzUeew75jP+GTO3TQCz+3OrcquJrVUmugoKlApJOYMZdI66hhefLHF6zhxTxEny9RaQs0IBWoudRle6dYMlWhwW5udxOYHeQ5Glm6PQSCwk0rlQpWCQTXneEvIz4C+qe35RgyNIy1CLh67KAKjD+qwLjvwr9tQqBbpWoX4doNXJ4/0Y8BwYZJ1mYeUkpvvQp7PhFDDkIhWfPZNLNGSx/rYV/rGti9a1zmGBU2HG/SvgDiVDH/TDI0SufJtKQQtOjMfQuK0p0Mf5+I02709GbU8n7MoiSQCyg0vQGFN+iUKCXEDVaxGAGXlWg13yAKRMnoDePfjBoq3ORPWF2/K+e8IBM9ddEbPmnmak2msCVTrDTScV1AlKKBTUnCTF5ZDZYjqgMdsg09fkx6iRkRUU065HykxGO19qO+FQEow5VKxI29uOSXOQfj73uqT9CV1c9GQXleLpiBL1hIlEnU67+AoIocmzjWg6KffTHYnSEWocFuSAIpKTMIhYJ02LsQFYNCKLA0Q1ryRIzCbcfRn9WCUFBpqVpP82Zebyz6wgXKn7SunW4G4MIYSv29gY0xU6M9vjkQIM3yGAkRgdmKKjCmF1EtV3Ly51PMuTtoub3/0DjD/PmEgUBgaXq2WiCKs72DPwZmTzV9icyDTksdV1CtTHMwZdeJNeZRPF51xJTojh1ycQiESStFjU1i5DOSEsgxBwjpB57D5MpmVj1DGS3m4HsHPqFAcStdZRm5CL39+KnD501BVGRMWoShUg+MyyuD2/zUdqdIUlJSZx99tk8+OCD3HzzzSfEkbvd7g+N3fztb3+LKIrDgv6FF14YFTO9fft2Pv/5z7N+/XqKiooA0Gg0FBcXD7dJS0vDaDSOWvdJc9VVV/G73/2Ohx566IQEUTByrhMnTuTw4cMfayypqaksX76c5cuXM2vWLL797W8nBHmCTwbdGQqyM233Mbj33nuprq4eFtP/jCAIPPzww0iSxDnnnMPKlStPmTW8urqayspKfvWrX3HFFVecEEd+JveiBx54AJvN9qEZ1T+M3bt3k5Exkk8lEAicMB5JklBVFVVVqaysRK/X09LS8rHc0/8d98X/FBKCPEGCDxAcctOwaT29Gyro31GAEoGq28xEAn6atm4AQSAWDlN5nRVzJhScExdb36hrZrPbz6Nj8pl8zgWIGi3KtHn88Ggbt+S5SNWdPmZvFBdeDLEYGOOCKrNqpGSONS2dyrOXDS9bxtVC/Q4ad0oUl12Muz4+pln3xoV0NKAOZxr3dYApDbyt8XDN7X/djqVyNar720iiEUkPbe8RF+Tniij9PtRgFCk7LqTCbtD6qtH6qtl5P1jSBbberZC7IJ5YLnvOiPAUk8xYFsRfPOXyJNYsBVQVUSew93elTLmiHW2KnqOvjtyCnOXQvl4laxZIOgGtRQBBRWeHrlYnUcGMqg5AyAtNTRxZM47Wd+Mlx7p3aAg5CimdPkhNfny8BeeIuCarGBwjlzaqRgjpvIhWDa1H5jLrkhbOO1tEMqez55dBnFUmurappFaDwaGQXj7EvW82cunhalAFjC4XqCDvGk+f2E8O8Qd+WFZo8YfItxiIRI20rI7PFu/+g8Kkb4nUPalSdIGAs+SfxLlej3DhRaQAx6vYoR0zenZ5051hevZGeOG2ceRJHuS9rUgTctFWxDOBDzWovP0VBVeNA/8319EUrGdGXzVZ6fGELEc3r4dIiHr/MVICRQyllVFq0yFK0vB3KmdvMuVl5ZTaJxCWFTzRGKmG+LXV6PRMufJqVEVFlESyq2vQHBtCUEUQBZ56ZR1VwVYEbYxloT6QoxiTU5GnvopjegqZE3IwJyWj0cX7m5nmYGe/h45gBBGYW5CFw6iHDgG0Wnb95QoKTS704iCCIJKcWcjEy69FG5TRaPzs9u5FOV7apta/n5ikEJBCvNjxOBE5QoXpWgIxkfLzLmeiSU+TP0yqQUebez/t5W30RMdxpNtDRbALdPuJGfqI5mZRmjOFYNIg4YCfaTXTkM4gm3SCT5C8GfFs6p5OTh5HLsS3533yrs8PPfQQM2bMYMqUKfzkJz9h3LhxxGIx3nrrLf74xz8OW50AvF4vXV1dRKNRGhsbefLJJ3nkkUf4+c9/PvzS+L7ofp++vj4AKioqzigx06fF1KlT+c53vsNtt91Ge3s7F110EZmZmdTX1/OnP/2JmTNncsstt3DHHXdw3nnnkZOTw2WXXYYoiuzbt4/9+/dz9913f+hx7rjjDmpqaqiqqiIcDvPaa69RUVHxGZxhgv8TOPPj2dRP57aut8fbfcqMHTuWq6++mt///venbCMIAg899BCSJHHuueeyYsUK5s+ff9J2jz76KAsXLmT27NncfvvtlJeX4/P5WLFiBatXr+a9994bbu92u+nq6iIcDg+XSXv55ZeHyzG+T21tLZFIhIGBAbxe77AF+n0r/AMPPEB+fj5VVVVEIhGefPJJXnjhBV544YXhPpYtW8avf/1rJkyYMOyy/qMf/Yjzzz9/uMrDt771LW699VYURWHmzJl4PB42bdqExWIZzkdRX1+Pz+ejq6uLYDA4PJbKykp0uhNLyP5fIvHGkSDBB3C3t+LuaEHWaRCEAoovAnsSDHULKKgIgL9TYvCASsXVAhqjwIoeN4d9IaosBtK7Wggjs/ALN3HD/kZW9Q2RZ9BzY07qhx5b8fvxvLka64L5SHb7GY136JBKZkE8Rmrvc2/Tt2YBgtFN/jwnx15RGTyqMnD8XTKpAoI9kFYNxlTQo6O44lI2+dz01xlRovF63rYC6NuvYuluIdAvoJYaSZ5gwFEs0L5ORTKAJRP8XSrBXjjyLJz7jAAqRLwqOuuI6FRlFUUWGfeVGLGggBwUiQQkur15GA0jL92SHqLuKFvv1jL+JnAVtxH06Dn7sVS61wXZfKee9AkLmHKnjM49iJDkpLRNRekbQDKKtO83o8PAyq/OQmMYOb4pdbQAdmiTuCLz8/S36Em/2wiphcSnPSSm3GFh/yMKe/6gkD4VUlL6mXx+D9c1agkcEhC1EOwGXVoU47xBdl+dy9C5MpkzRI6keDk06CPa106uNYWar6XTtlVP8UUiTW+qNK5UUWWY/N0TreVyWKV7F7hq4hMRH8Td0YpnYICUs/fgb5URXJNRhNHZigUxnhxP1EKhuYzgwACp/Ra29rzL9KxFBPsnMVS4Bak/GXdFEf0WI3WtMvLdMuNuEnGVVeAqHXlZfqetj45ghMWZSWSZDbzcPcgfW3u4vyyHcVYTqYUlUAiqoiK3D3JuUjZ17X0oooQ/yYVtqBd/fy8pxcUk5eRzdN3baE1x7w45GqF+wxp8ehu6rALSDDrSjXEr/0UZ19Aeaub17ufxG1WuSPsCITluJTdabUy2qPTW91CccjXNYgtvdL+IyzgO9yI/1dqxuAPbUTtjhNrfpqeshoGwjc8VplNkM+GNRtgf3Y+IhKRpQZb9GEI+UjqG6C0woneWkJSTDzn5Z/S7S/ApIErx0mbPXkc8UeYHRfnx38WSez/RhG7vU1BQwK5du7jnnnu47bbb6OzsJDU1lZqamuGSQe9zxx13cMcdd6DT6UhPT2fatGm88847ozIS/ydz3333UVNTw4MPPvj/2DvvMDvK+m/fM6f3suVs7y1bsrvpnfQQWkLvEBFERYpSlN5EAUGx0FRQQZAOoQRIgCQkpNdN3Wzv/Zzd0+vM+8cJG2JC8Sfoq577urjIzjzzzDPlzMzn+TaeeOIJJEmisLCQs846a/SjedGiRbz99tvcc889PPjgg6hUKsrKykbdVb8MtVrNzTffTGtrKzqdjpkzZ/LCCy98k4eV4H8JQYyXNjtelvVPKT3lG0vo9vfce++9vPTSS1/YRhAEfve736FQKDjllFN48803j2vFnjRpEtu2beO+++7jiiuuYHBwkPT0dKZNm8YjjzxyVNtPywhqtVoyMzOZMWMGW7ZsYdy4cUe1O+mkk2hraxv9+9OY7k9DacLhMDfccANdXV3odDoqKip45513OOmkk0a3ue222xAEgdtuu42uri5SUlI49dRTj8ozce+995KamsrPf/5zmpubR71tbrnlltE2l19++VGTCp+OpaWl5X8++aMgy/9oldx/HrfbjcViYWRk5L82FiDBfyZSLMZA0yHUyiw0BiN6uQ+Wv46cnU1swSJEQWDjXQLdn8TFa9HpIvc0dvNYRz835zmY8NFrAEw8fxm7nSP8ZecezpW8KJz95E+eQXp51efue+A3v2XwscewXXghkem3sOUBmfE/FMg78diXiizLDDQdYtv9BtQZdehyWwl1FeLeW0HN9QPoNTWs/aGELhWQQYrELdyCEgQBFv9VoPMDHzr24dfrCPZWUXQGGFJF1vwwxsAumHa9hy2PGYgGRBb9GfQOkY4PZdKnCrgaJbY+AOGRuBCcfBts+TkotXDKiyLeHtj3p3hpMdchGcdpy1GoBHSRJTjGCzgmCAQGYc8fZJQ6mZZ3wJbpZaRPT/bcAH7PR5iUFeSfnY3gD7L9NwpyJ7jJLncRqM7hd9s6Ob02kzSnmXU/kSg5R2DMBQKiKv7hLksSsdYhRLvhmNhtWZLZfJ+MoIBJNwtHJT9ZfnqM8Eh88kJy+ald2od+XAqf/MLI8CFAgPHXC6hNAhvvlNAmQXAIrAsjjEzp45SgG1mGnkMm8i5zIJp1BF0yja/L5C0SMGYKSFEZUXlkn3VPStS/IFN+qUDFsr+rp+4cYt+7y1FoNPR5I/y6PZVLZpdx4ayjE9XEQjKiOv7S7x1uZ93+daTmpHJC1gL8fTIDdTLZcwUGwxEOjvhQvWGg80UF+Zf4mfAt01F97Rxy0+wJMD8jCYtayTUH2nip18VPizNZlmJGEEUUKhV7m1pQdYfI9UZocTfh9PdgnDyHA6IOCzEW5GeiUKn4+MNnCEoBZs67hMjAMHtXvIGkN1G69DxSdcfOiA9HnGiiKjZt2kprVhlVNiMTks0MtTVz8IN3CVgk+qdo8ERHUIbnopJSMI4M4ti78dNc3PSUTqCispIxVgOeSJRX21oJKV4HYFHq6aRrs+jdtZvOXdsYScslmpLBaZPGHTOWBMfyjb+/j1uHPDMuxr+hOuQJEiT4D+TfVIc8QYJvgoSFPEGCzyAqFEdZC3FpkDUaJJ0e5eEkOEWnyyiNI3jlD+isK+SmirHMTTIxxWJkaOZcpGgUUaEk+sFbnB+LotTqiEoSw10dGFMcmFJSAfCPDHNwwzpSzPOIeBT4MpIRzlyCacECOttBCoN/4PjjHGptpmHtB6QtSMcWmIoiaTKb/2rBXBTCkOynZfNfyDonG1tGIWVL8qh/UaLuCZm0iVD57bjVdt/TenzqEGL1c8xf8htWnC9ReZlEao1A2C2jLTATDciATN0DbtLmm/D1KkidKLP+x0fGEotBy9ugNkHIBfufi1s1Oz6S0R12DBBEEfeeMjr3gqiE9CkChjSYdLPMqitAnyZTMC/I9meMjDSGKFqkIt0UhOgQ2smZzP7ZENH9TpBg+Yd9PLWnhS5XgNtyxhH1g7+PUTEOIPV7iNb3Ilh0aKYVIcsyvm7Q2GDdTRJD++PjGP9DYTQxHIA5BwKDMOUOgfcu0bPmiVxm/TaMV7sSWEjp+ZAzT0CpFVj4lEjHmnguAfcaFfKqTHyPqjn4qI7ufSZMs4m7vtsEKi+Lj631PYmtD8YnWgpOjYvvlGqB3i3yMQniAAz2JCZdeBkAy3e04xjeT2m2BWe9jDkHlLr4NgrNkW1V3dlw27kwToCHQO8QyF0QX5+qU5OqU7PixAG8c8LUCQHkwREmJh+po1qbZKY26YjQujTVxlSFwDTfIJtXvgyyjCU9E6c9nfaUTPrUbtoyysk44CV2YBeBqhkoRSVKjYbH1zRR2u/DGARXbwcZmaUUTp+NzpaEWqVgk3MN9d59nJJ2Dknq+M0iDAZo2LaGcBTIlFGKAq7ONoIeN0KaiSHbIMWGWsxKO92ftKLs3kJv5VQMSSn4nIMgy+RqlRxsbcVYkkay2opWNBCLzUNEQZYuH6WoGJ0cS9UZyfiCOrIJ/sWUnxYvbda2IZ7AzeiIu6l/A5bxBAkS/AeTWhkvbeZqjSfCUZvjbur/Ist4ggRfJwlBniDBF2GzcTArDVdrPWMHq3DWJdG5RibvrEFatvbh29pHxO9jxpR4vfFPxbwUjaKzWBBEBeWLTmW4q51Da1bhdw0x/px4orcNr/yN3SvfIde5EDmqJPW0GKbasYwYteQu9pI+xYQp+8hQRlpkdjwiUXKWSPK4NGxZuSRZbDh2v4HstxO74WySKvW4Bl1EAj5QH8Tj7wCWYS0UEEQZU46AtTDuXt70pgSDMyipKogLbwn6D7ZS/T01xecm0XtgH2UXV3DwWRXuPi39vxeIhWRkKW4Vl6KADAptPCN551qof0HmwDNQcIpM5RXg64WWtwQUQycjBiF3IRQuEdj+sETILWNIA3criGqB7LNTcUYaGBCH0WalIKNBk2sFQEwygF7NQIcZ/mJlbn6YKydlklUqcOIzIoYjCckPtzeiyLYjpsStvwefk9n7lIx/5jDafRaUJpk5v1COCtpPmfPrIx/9C5atw+jeT+9QKc29j+Io7KD++W/jbomXY7MUCFgKBCovA9chmYgfksakkzxTQrDLWIuP/SiI+OPnLOI/six9ikD6lC8XG+W+RpJNTXhe8fDhijNInx4j54xdOErL0RjiSeAGg2EOaP2oMg0YM47sX5YkXF3tmFPTUWo0DEUjIAoI6PGElciyTPPWjai0OnLGHl2ipM0TICgoOVS3G/1hh6poJMyUsZXkdHVhLUwm9v47qIN+0iuriYR2U5BXiTsY4Q8f7GWcxcbVE2ykpRUiCAJpZRV8sr+ewT37kEudBCU/vZ2HCPq7UWk0uPt68PT3UFhawcwMM3qjiQ1vPocci1F9xnmMMcjY1MlEJZmeaAMCMlFRQWZVLYfWrMSWnYdzzxZSpBgrdQFOyDyFc/LLWNGhYCQSYygUw6FToNbpyR0/+UvPe4J/A6Liay1tliBBgv9SBPEbLW2WIMG/ioQgT5DgSxAVSgRBRBBFmt+O1/3OnJVP9rhJdOzYgoxMJBhE9ZlyMKJSSc3p543+HfS40VmspI054rJePnM2XucgWXoPYtRO9inT8Dn7aNm8Hnd/D2VzTzxqHP07ZAbrQO+QyZxpoHzRKRAKgduDkJFFfmVcgJmyJ6LT5bDpLhP2sjCBkWF6Ot8n52ITBQvnADqsRQLFZ4jUvyCTWZOFt1vGWHEQRe4aevblo7cn0blrG5YUD0VnzKLkTA3vxQ21tLwHeYuh9b24FT91HNjLRIyZEoN7YWgvNC2HU14S6d4o066V8XYqGG6E0nMFdEkyratkpIhM5oXDoLRiuyCIymjkxuEuWpx+0tp1iGE/75cV0vJ7iZFmFVPuKEGhBJMgsbixjCLdp8d7RFQPN8bj5vNOFI9Kjqa1xycRolYXA6c1kTM2G3vpkQyiAB1rZEKueK10AHNaBDwy6QWFzP/WlYgRM82/j6KNjBDr16JIPWJFtpXExxAO+NEW7aF2cSkqg/WYe6n4DJGsmTK6lGOt4X9Px0dSfAKl6HDmelsSgkKBqAyhTY4hGjvp2LmVaDhM/uTpRGWZOqeXtliQspsj9N5rY98zMjkX+PA2tNO8YS324jKKZ8xhSU4K3f4QZpWSFJ2azsEhevfsRBYEsiqrj8qmekKajT11daQnJ5MycTKCSokxKZm6N19FVCgwLlpK37jZZMSCGIotNPY8R+tgK5Ma8vltfie+5Hyq5yw+6tiE/TtIHnGSnDWbibYaWt9eyfDhdUUz5qC3J5FaVEZPRKKx30lMlIhalOjMVppG/Hg1QfSiQEvJBFTZY6iKefD0D1N8wgJcnW0IkkRYKyMpBQJRHd5IjIgMYUlmj8uDQ5f0pec/QYIECRIkSJDgX0FCkCdI8CWUzF5Ax86ttGxeT/X3F9GxT8mbBUOck1nD5IqxdO7ewZbnnqJ0zkKSC4qP2nbPHyQ61siYJh9CNAxjy84ZXZdRMoalN97+mdYFmFKTCXpGSCutOKqfkf4+DBXDTL6tGMf4z4g5jQYWHi3cBVFErUkjNCgR6NHR37AVT7eHvteX0P2agtNel/H3QtYsgfTJAutvldCngK++AAiQXZJH2LsbkyONvg/H4NwFKdUi2bNk2lbFrdot78QTtmkdHtKnGnn9ZJBlOPFPAiOt8ZJhuhSBwtMECk+DoDOeXE5QSLx5FkgRGe/Fq2id14UpbxpKZz09O6czQ5FJVqGLnQ0jSDFwNsi0fwCBgbhbesZ0gVNeEgm5wZQj4OmQWX+LRGpt3BV/888k3C3xZG6OCfHz4ayP11Avu1CgsEgGtw5VeTyuXI5JSC4/ot3Alp9JSBFwTJQxZQlwwmyYPAW0OoafbiamGmTGTw5icIsQzeZ49B7YS+eubYR9XopnzUOWZATxaPH9ZWI8Ikkc3Bbm4L0qjJkyi/8at55nVFaTXl6Fd2iQ0PlDKFUWBvaVkVZazppeFx2+IDMdNjSRIJ5XtuLvXURj3QDrZz3LHNM8dEkp7Ewvpa61n1lRF7mOdHQGIyGvhy2DHigZh97rIhoMoNYfKf20wfkx3Sl7GRQXcmZOHsLhSgMhnxc5FqNr1zYCqYU0KTUYvTo0wSLe2OzDHhskFcizxuPEdzs9jISjTE+1MmbyNJxdHeQVFiNLMs60DDx9vWgtFob6e3EeOoDX5WJrWglhSUZVqcFnd6Jq2EyDIg+DUsGZWTbG9DWiUWsIth7C6/VgSM/C19MJgFWXwmnWhawYCLJfOUip2cBel5dyq+GYc54gQYIECRIkSPDvIiHIEyT4AmRZJugZYai1Cb/LSc44F8srZR5t66c3GuH7oQG69+wEQDhOjKPzQDx2ubRsLqb8EXRm6xfuT2syH2MZB3jx7p/gGRrkW798HI31y+NdrYUCi54WQeVhZEBJWnkpno0xdHYVsZDMysvjrselF4C/F6J+yJmnpn9nLXJskP7mg6g0Rsac46AvX8YxIR4f3v4hhL0gxyBl7hZUGTtRp5xO1B+vDfz+t2QWPyegtR3trq21C6gtMquvYTR5ck6JHc2q8SgjB4gpu2lc1cDYd6fwrR8JqE+I4m6TyZ2sxHSvhLsNdpvcBPqiTBy0cuhpD2UnB2hvSsXbCd5O6OsPk3eOiHuLAlvZkX0HBuIJ7TztoDrRgTToQUw2EnTJDK7oI9k+iJyRiqhKRu8A46eGdVEEvR7Xdh/9q2eg0IbQT2hBJkZUC59e7aH9Mt4umdwFIqnFZYT9PtLKKok29RM91IdqXA4Kx/Gz5q/7SYyRJpj/exGtLS7Udwx52K/1kzbVjlDSwju9dSxMXYpKVCOIIns2redQ8UQ0SplzZ85FFATkbicyoPQOUxz20JbXT/pVdfimBhiIKjElp1JwWi2Nbf3I0QhN61djcaRTdfLpdNbtxDDgJJCWg6G/i8HmRjIqq0fH2B9uBCHCSMRHMCahUypQajQUTZtNw7oPsem1VNuN7HZ6EVAy2TKPD10bUGXHKBs/HVmWcXV1MPzROwzm2PHYTseWnYstO5fAyDC73ngRvdWOLEsYk1NpdfswAG0jXiZWmhkc8TA0GCUWVRPctYP0fA1l5eXsXbGc2GA/9urx7C6uQRpx0a03UYaMHIvi6e/D39GCw55NtLMVYU8bF5129pf+dhIkSJAgQYIECf6VJAR5ggRfQMeubXTs2EJW7URyxk1GYzJzlkGkMximWg7Rtn0zsixTOH02SXnHxjFNvUfE1wO24jQg7dgdHMa3aTP1H3+Abc5ccsdPYrirA0taJkNtzQy07ia7vAJnVzdKtfZz+/gssiTRWf8O3qFBIgE/BVNnctKzccugHJNJqpCJBuJCXKEHxwSY9BMFbSslttyThGHMVCKuVMynylRdES/vVrhEwOzwseZmLWqLzITvFeEZMKOMpAEyan0UhV6BQhWvjb3mhxK5CwVqroqLc1ERz/AeD0MWiP6lEDI3MbB7PGkzrfSuLiZjGmTMENDa1MiFMrsfCdK9AbyDSqIXvkUyPvb1nY0/OkS3agOdm+cCGUjWGH3LhnAhMt6ViuozRtDMGQKL/iRiyACF2ozCEXc171gt0bNGh3Ghkmi9h1g4iZRcH9KgiCLlSOZxc7mW3GkBTHkiAUWQqNeHr95N/tR43oANd0oEB8GcI2MrNVM0I17+KDjQiTvowh7JOOb6SNEoCAL+vniC2GhARlKFiOzrJt9hot+qpPZ2WDnwIYGgH3/Mh0WMW5pH8sqRFfGT6ezs5PUnfo156lzOXDiPuuf/hCxJOJbMotBegSAITJanxq3a4TBn5CQRDQZpyc4jKT9eKzmtrAIpugtNihnv8ER23lfBwAkS1d8VkWUZnUIgGK7GrMzGf1iQA6SWlJFUUIRCqSQHqLAa0ShEIuEY300ageFBDq3pRIpFiWTm4UvKQe1vQKeMASqC7hH66vcjRaP4h10o1Gq0JhMpRWPZP1RGoSOJEouBEosBcq4k7PfR4viE5DQbSSYddYfd6mWgtqSYzYNuzAoRizqG1mTGnJ2HzqCnxttHe+Muwio1nd4AMSDXqDvmmiRIkCBBggQJEvw7SAjyBAm+ALVOjyCKeHp72PDaS/S3tXDJg7+h3KDj2b17+Ukshi07l7SyiuNvbxRQFx931VFsv+E6tmYmYa7fy8LvXUvn7u2YM3MZ7D5I1kyR4kwTb/+0mdcfuItLf/G7L+0vFo0y0tONLEvYc/KxZefRs3MYya8nc7qaEx5SsOHOGIdegJofCBSfGRc3KoOAIAoogtVoBSd7/iCjEMIUn6/F1SAjOJ3k1mixVWtp27YZ72A/NafnMelHInJrHyklIWLefLb/SkHYLdD+gUxgUKLgFAFLPqTUgrMujChIuA/ZSC70M+bCLjwN45DCMsVniUQ8sPPXEhkz4NByFQgyGpOM3a1CrRXJmqIgKLWgSh/CWNJFamkGfQcFFCEVwUMie34vkz5ZwFIQz2ru64knnRNEAXe7jMERz0qeu0AgOGgi6B3AaA+iNUWpmN5OZBuIC8oRDgtPpU5B0cUGpChoMvIYqNtOVumRElml5wiMNIMiK8Z7ncPkGnWMsRroHGygz7mfnGEL2VlJn7k2EXa8/ByCKDL7Nxcy6IzwgWuAiU1+krxhrGolp9bGQxtOSz+fYCyARWUb3b62KJ89Ti/jk810fPwB7saDBLUGogsX4CgeQ/PIAT4ceZeDoV4K9FMot8bd0ne89jf0Vjvd42ZjHjuNMQ4rEM/knjx5FsvbBzBjJ9YrMHwo7sYgCAJnZ17Ghn43zZ4Qvf4QSRrV6FgUyvgrJBIK4unuRJWTj0Ipos7MJdjhhGiUqMlEny2DiM1OSsRIvzdKtgX2vruckNeD1mQhWFaLNiOb7CQTB7qHCOsMtPsjTAGC7hEa168mtbgMrdlCx44tGJNSsKRnIEsxMqtqQJKZPNyBxmiiYccWNGYr9bVzyF37BgIy1UvPQW0w8XxH3JPg3Hw1emUia3eCBAkSJEiQ4N9PQpAnSPA5hHxezI50smsm0L5jCyGvG0EUERUKigwanrSm4hpTyNTc/3vJpM4De3ntgbtxaFVowlHQaHj9V/djTUklumsHI/196DInkJaXhc5kxny4ZNqXoVSrqV56NiCgt9rwDPSx4WYDUkjBor/ImHMEipaIKFQymTOOxDRnTBc4c6XIAd9uNL/vQL+nhMwqG13r1Wy4Q0ZtTOfkXzpR5OqpWxEkGpRwrRhioM5Cy/ocShe6KZEOkZ6rZGhvCdEAdK6RQQaNFfq3g04XpqJqGy5XMsl5VtLnliHODlJyjgZLvsD+ZyU618oodQLlF0vseVHiuTF7mbtxIUlOHYX3qMkdU0vrC16y3H4Kfqog7kCeQlu/hG8ZNC2X6N0hE+gTkCKQNVvA3yez/maJrBMEpt4VryVe9R0FoZ4s1v1EomxaH74RDZZq46gY90ZirGwdInaNHaICthIrxWfMR6kQaHhFImeBQMnZ8cmMdm+YnkAYSYYxVgOqFAfhzg52SWqOF3He/8EMtuyApOsjuMIKGkxqUvNTUH7GOm9V2UF19HZpOg1pmRoALHMWENPoMGbn0ffJaiKBAAOpfhCgz5/CgM9NjkFLNCYRlWRGJOgNhHGGIkw/LMgBNAoRs0pJao1A5R9FDPEIBCKSRKM7zFibmWxDlFzj8T00drzyPNFgAENBGZrxDvYXbSOcHaBcUU290IYgN5Pc2UZ3+iS6+tpJDewludiCsVOHPTufD3U2ZJeXLL2aHn84fpwte9m58yNAwO8aQpYknKEIcsBP0ONmqLWFwIiLoHsEZ1sznbt34CgpJ6OqBnWSgwOyQKC4ihK9CpfGyIaeYbINGgxKJTpFoixOggQJEiRIkOD/DxKCPEGCz6HurVcJ+31ozVYQBIoqx2JJz4RYjJPTrZycYgUgEg6x+/33KKidgCX1893Sj8e7v3uYSCBAZ5IZR34RfS2N6LU6/D29VJy6lK6D+8nOOoOMkiqufOIcoqEgrs42rJk5CEJcSHv6exGVKgz2ozNH66320X+rtDpM5U0I4TQMjrioTx0nkDpOYP+7e+ja1c3c6xeiUAsICoEWfwPOU9uYc1YqmowSNp0cAxlSKmIoi+LbV568lJZ3I5iFJlJSJQayjNhqVEhSDHV2K+NvziKpxEDPpngSN3MODOwGd6uR9pFxZIwLYx1bQrQvSNdbHlp32ShcGMKUa6fkXCg6OUpMUrH+dQ+b6aVUcJCiNLPjEZm0iUlMOLMadEdcj2UpXpIta7ZA059HmHlmF1tfy6Hf4mSn6QCVkfmoLSKmbJAjMcIbGhF0ajST8nFMCpKZ7wZRQFl2JPu6LxpjhCiWqWHM/RpcB6HrE5nhRjj0soy/N0remQN07NxKzoQpzE23jVqQU4tK2aJJwq45WlErlCqUQxfhaxbwtcAElQFjikhSGux+5xWUWh01S8855l6RZZk9b79GLBJm7Glno1AqUSiVjJs1m+69u2lpbkCp0ZLbq2XMKUtoEU0MhyNEJAmfQkPTlJMwaFQQlY6xDuuVCs7IOzzZ4ziyfP+wjx1DHorNeiYmm5FlOR538Pdjk2IAdHl9OAd9BMUAqYZsNOoaKuUsvFIP5t4OZLmZkKGTLnUHmqwyXh5OJ7O+kcKaJJwKDc3e4KcpBjCNDOJ3OeP3r06PZLHR7ChBjEWwblrHmAUnEfJ6MKU4UKjUBL0eUkvHYD78Gzw3JqEoTEMhCNQ5PfijElaTivHJ5mPGnyBBggQJEiRI8O8iIcgTJDgOkhTDmJyK3zWEZ8SFCKg1Wty93Rxa+wETz7t0tO2+1R+w4Ynf0l0znpPv/NkX9+v3M/j440SLi2j0OKldfBr1G9ejUCgYd/ISDm34GJvRiKJ/kIaPPuC0+395lMhv+mQtgy2NFM2ci6NkDGG/j7q3X0NUKJhyyXdGRTrAe489Qvve3Zx3z4OYk1NY+Mvqo8ayY8VyVCo1H/3leaKyi9Q38smcosZoT6a86WT6VvuwLwgiZsvkzgzRv0uga7OajffEKLmkDXNaOtmzdDQ/l4c6zYdzqJ6mnQMcioaIDKVQdo2fbQ9pkUIi7lYJtUUg5BIw58FQm5mSbwm8f5WMNV9JYbWbSWe2o9ZKrP6NnlBQRUlOPdqJeZz9CyPWrePJXKyl2AwfXw/DTTIUxGOgtz4gMbhPpvxiga33y9hKZcoXx9j6Wg5DnXpCF75PvbeVsuTxpE9Jom+7TNQvU1YSwe9S8MnVMQb3qhjIyWHag3E37f4dMqIaHJVqTs1Oxni7gkgUPljhQVktkhUy4Nk1RHZgE0MHNIz0dOHqaDuqrrVOqeDsfAfHo+MjASQY9xMXg62tZFbVIEWjRMNx67Asy0ddy8MLCbpHiEbC7HzlOYpPWIAlPR6f7igdg6uzjeGuDuy5BURHvHSoVbjCUTp8IbQKkdPy01ALAnv6h8i2xOuWB6IxZPhc9+0cg5aBYJgsvYaXW/vQKUTOzIsfkyTLNLncZJqNFE2fTfPeOlw5pQiyiYX2JXiCyWx3BckzpjEhauCApx6HZzeSIKOfO57+ASuisx1P2XicCg0pWhWFBjWqrWtAo6V84cmE/T7CPh/ewT7qW9vBUQJyvMyg1mRGZ7ECoLfaUKjU7F3xBlUnn44pxYH6M1bwSpsRh05NilZ93ONMkCDBP4YgCLz++ussXbqU1tZW8vPz2blzJzU1Nf/uoSVI8B/B7Nmzqamp4ZFHHvl3D+Ub46677uKNN95g165dACxbtozh4WHeeOONf+u4/n8k4beXIMFxqP/ofZxtLVgqa7kybzI3ZtVSedIS0sZUkTNu4lFtc0vLmd3YTcHy95FCoS/s1/vxxwz94Y/0PfQQW998lVgkQvX8E+mq38/aZ59iwXeuRgyGEIecuF1O1jzzRwbbWwl3dND/y19hNJoxb9xGbMX7hHxeuvbswpyWgTUzh/rVKxnp6Rrdl7OrA69ziKDXc8w4hnt76Ny5FXd7M2WTZpOeeiLmojB/ufEHPH/D7ex+ADo+tNO/Jcr+P0fRpGlRmkWQBQb2hFjz/WQ+uqsdjUVgzPdNrFl3F/6cB1A59mEu6if/e1ms9L7C0EGZkQE/WRUjFI7rR1TDDlMPPxm7khUHm1CoIewX2b82g849Rpw9OvweFRG/iHtIS/c2FR9+T0Z8OoX++/Rsv9uDygTjfnjkWFwNMt5O6N8pkzYZTKkhtv/RyFC7AVElMLNgJnOST6L9D0m0vQ/OA9Cw0cM7f8rhk1czGdwLxmzwXrOBZwN/pKO3h7U3SKy+WmJov0SyVo1WqcAnRxmu8tPi6cJ9aCUTTu/DWGgmp6yKoplzyayqBeKhDq7O9uNe/5gsU+f0UPGzKCc8LOKPfEz7js0MtTah0moZf87F1Jxx/qgYD8UkGt1+IpKEIIrUnHEeyflFhHxe/K6h0X4VKjVZ1ePR25IY7mqn4eMPKFZBvlGLTa0kVaemNbCNFZ1/ZtPd32f7k48QlWReb+vntbZ+Dg6N8ObWXTTv2n54nFHWD31AT3g/8zOSSNdrUAoCkt9Hw8cfEgqFeXfnHtYP+Vje3M2APYPqeScy1jfAXLOa1k8a6Ny9nTyNSL4KDqx6BwRQJ9twl6iQtnVh27WTpSNdlIW9qESBaalWLMiE+rrxd7bx8cEmnG0tJOUVoLclofO6yOxuRONzI1RPZk3fMO90b2Hd0CpkWSYWCSNLElI0duR8RyJIUgxREHDoNIjHse4nSADQ29vL1VdfTUFBARqNhuzsbE499VQ+/PDD0TZ5efGyf4IgoNPpyMvL45xzzuGjjz46pr+tW7cyb948rFYrNpuNhQsXjn6Ug0ZsTgABAABJREFU/rPcddddo+P4vP9aW1s/d/tXX32V2bNnY7FYMBqNjB07lnvuuQen0/m1jC9Bgv9Wli1bhiAI3H///Uctf+ONN46dRP8SXnvtNe69996vc3jH8Ol4P/0vKSmJE088kbq6ui/d9qs8ExN8fSQs5AkSHAdBEAGZvk0fQ85EosRdjQunzTqmrTUjk5HyClApEZTH/qSkqEzdEzLmPMibdwJJ3/kOkcI8aob6qDhhHrFIBAD3wAAKtYapV99AwONm5IVnqPvgPXQmM1VdQwy/9BJWrxfl+k2MbN5OYFItvQf2Yk7LwJTqoG3rRsKhAKk+H2lFJZx56z0E3G6saenHjMmUnMJgfz+uwQFmXXw5+T+aiHuwH0dhNsnh8/F4NCSVSzhOSeLtyxUgwYnPqhlpBrczzL5fm/A7k6n7Y4zej4PIw0WoCzvJrJmALSMbIVmPqU9NxzUfwNMTkHcnYU4NMv+Kg/RGwoR3SrgDfaQospFjKgJDIvtWZ2FOCVKyuAXRVkTqhUUM7QOlXkJvDeDu1uJzG1Bo4cPvQun5EhXLBE54WGTHIxKt78LUKwfR4aJ3Wz4A1d8TKChOI+x1sPw9CYCqK6FhZ5jglmQCyIy7XsB1UKY9HLcWK4wx9I54OThfN5jzZDbeJTHSpGTi9+y4nasZjkpkZJahyM4miIWO5WnoZrswZIjU7/gIT38vlowsUotKSS0+UoOtyxdi+5AHm07J0rJUVKkTcLa1YM/OBUCl1RIKRNi9qgFLsoGhLAP7h324I0bGJZlR6/QUTp9NWmk5Jkd6PGX9wQOQkoIlPZPaM86ja+8ugiPD5DuSqFAcsXy/1t2IS3QhOoz4PDICMqIgIAJ7Blx4rans6WggORwlKA+wz7MTvcJAuakajUJkscNE3Quv0gc0KAy4DBaUbicho4U9QyNED27G09uNXo7SkVeJIuingDCZJit7qqYiqDVYM3uQtwwQHokCICqUJLWuw55ShU09G0Gjwj7vZHYOBzH1ttHT10ruhCmkFJaQXFDM5gOH6FKZaIkE8XqDyOjpCn/MZNsJlMyaT/7kGah18RrzYb+PHa8+j85spXpJotzZfxIxSWJbXyMDgRFSdBYmOIpQiN+c/aC1tZXp06djtVp58MEHGTt2LJFIhPfff5+rrrqKgwcPjra95557uOKKKwiHw7S2tvLXv/6V+fPnc++993LrrbcC4PF4WLRoEUuWLOGxxx4jGo1y5513smjRIjo7O1GpVMeM4c9//jN//vOfWbNmzZeO94YbbuC73/3u6N8TJ07kO9/5DldcccXospSUlONue+utt/LAAw/wwx/+kJ/97GdkZGTQ0NDAE088wbPPPsu11177VU9bggT/diRZojfYiT/mQ68wkKbNQhS+WVujVqvlgQce4Morr8Rms335Bp+D3W7/8kZfAyeeeCJ/+tOfgLjIvu222zjllFNobz++4QD+sWdigq+HhCBPkOA4lM5ZyKG1q1CqNWydUIkQiaAzmmjdupGgx03JCfMRD4sdQa1GffvNuAb6iETCqBVHl1QaaYKGV2U0Nig4RUfqj+Lm3czPtDn1RzejVKlRHv5Q05nMTD3rArRGE2XTZtG2fjXKq67AWB23zhtmTmd/ZydDvT1oTBaSC0sRBIG3XnmJ4b/+hYtu/ymZpeWEvZ64hfDvaqSH/D6G+3sBeO2Bu5lzwaUoRZHF132bzp2HUJLG+Kuy0eWbmXa3TCwoYcoSGdor0fw3E2mLYpR8y8j6iyFl8NfkK7MoPGMBeeOPuMWfn3UFw/ooqx6XAZnUAjcrf1fKuMphlk8RyE620XeeiqzZAlF3FO/eTuRwD0GLi5JTSwAw58ssfUtEiGnofrEZISud3j16mpZD/d9kgkPxuuGFE/oReiXstmFESaL6nGHUxckoDfEZa7VRYMJNAoIAeSeKGIstbN4bJXWKRMyvpuUdkFeciEU7h5ZaLVWXC6gtsO8pmYMrYrhaZMRhBbEGNZMuOwuQUWriCc7a/yrRvTZMZWU3kUGw5+RDOIbOLdBTV3eUIE/XqxljMZDe2wE7OrCNG48tKwd/NIYoxwVycCRG0B2lO3UrI8MyumAtqZ+5fgqlEnPa4VJq7e3w8VqwJ8HZ8bhzW3Ye+krrUdc7JsdYkHIabe4+Bqafglb04B4ZIRCTEIC5diO7mlsZyi5mba+LU3PSKdWfQLLGjixJtO/cimC20V05DUUogCclnqZOEQlh7mvH4RnE3duNJSOLtDFV5PWPIO5czYAgMrDwTAatcTf3QmUG5kk2LJ1ROrdvRWuxsq+inSZhG4GVXUxecCE7YxqiBhWDBZVkllfRd+gAkYCfaH4ZMYMJfVTAq9JiVkB6TKJLPo9uX4w8kxq1Ts8+lxdPJEaNQQEkLOL/aaxs3cnPNr9Er394dFma3sotk89hYV7tN7LP73//+wiCwJYtWzAYjtRMrKio4LLLLjuqrclkIi0tHkaUk5PDrFmzSE9P54477uCss86itLSU+vp6XC4X99xzD9nZ8d/KnXfeydixY2lvb6ewsPCfGq/RaMRoNI7+rVAojhrX57FlyxZ+9rOf8cgjjxwlvPPy8liwYAHDw8Ojy9566y3uuusu9u3bR0ZGBpdeeim33noryuNMOv89LpeLH/zgB6xcuRKv10tWVha33HIL3/rWt/7xg02Q4HNo9h1ig/NDfDHv6DKDwsg0+zwKDCXf2H7nz59PY2MjP//5z3nwwQeP22ZoaIgf/OAHrFu3DqfTSWFhIbfccgvnn3/+aJvPuqzffPPNrF69mk2bNh3Vz9ixYzn99NO5++67AfjTn/7Egw8+SEtLC3l5eVxzzTV8//vf/8LxajSa0WdDWloaP/7xj5k1axYDAwOfO3H3VZ+JIyMj3HjjjbzxxhsEg0EmTJjAr371K6qrq4/X7TG88sor3H333TQ2NqLX66mtrWX58uVH7fN/hYQgT5Dg74hFwnTs2k40FEKlM2BSqdm1ehVJ2bn0HtxLLBwmNGEyOrMVgKDHzbblL9NQF3f5PfWHNx/Vn61UYNx1Av5IM807XBR8xuU9Fo3Ssa+OgtqJfPLyX9m39kNO/N51SLEYQ80NTDr1DCRJIhwK4YmEefq3P0cbipAz3Mf+rlYAWg4eoLFuJ7nzFvPTmWeRXNnPGYODdEd2se+Dd+lqa8PjclJy/Z08FFJxW34axk9WUj5hMrFYlL7uLkIjwwQiYf66Pp1l8yrpb/0b295VccLlP0Cb3cXBD99FrJtCx5pqAv0QeF/BtB+JzHoQdt6+hBFvGQ27DzK+1cnEvCOzvl3vD0EwGUNmgPSTLDRtAVkl0PLsGA4FFZzwoIQxQ0nEO4TO5COSmoKuKn5+BvfIrLlOwloCc+4KYE8KIVpdpF9tIm2CzKFXJLo3yUTcMOGcIGIwQKylCc2Zc8hLMfHOeTH8fRILnxKxFAjkLxZpelPivUtjTL5Nw5nvCDS/I7H9oXgasdRqgYE6LT2boHuDTP4p4DwoI1lk5Htd1NSnUHCagEKtOer6FpwqIEXVxNIcaOwiWbnJOFRpxNqGiDl0eCNRREFAr1SgEkWmWLR4X/+YLQoZRzRET0ESB1xGUjxDZDS00v7cSWisxQR/tglfdJDCllQsWanIssxwVwem1DSU6ngsdCApGTm/EH1uDpFAgA+fepR969aw6HvXUT5zDn6XE6XNyEtdT2NQmphkOYcWcS3qzkaaRuqZtvAMDvb0sm/TVnKNerTZ+WQZNAwGw7SMZNGrEMkJ9tG5axtqvYG8eUtp8waYYjfR7gnQLQiEdUbcrgFsKjVlcxexrddJk6gm22AhptHRP+hCrddjVqvZu78B0ZZETmYSE8dUo1KrifV/THPLLjReEAXQK0SCQCAm0Sw3EFi/F2SZTkmH32hFJcdAEIkEQwx19OItSGZ1r4tJ0RgVNiO7nB7CkkxWKIpjxjwk+1erTJDg38/K1p1cu/r3o4n9PqXPP8y1q3/Pr+d852sX5U6nk/fee4/77rvvuB+BVqv1S/u49tpruffee1m+fDk33XQTpaWlJCcn89RTT3HLLbcQi8V46qmnqKioIDc392sd/z/Cc889h9Fo/NwP+E+P9f333+eiiy7iN7/5DTNnzqSpqYnvfOc7QHxi4cu4/fbb2b9/P++++y7Jyck0NjYSCAS+tuNIkKDZd4hVA8uPWe6LeVk1sJwFLPnGRLlCoeBnP/sZF1xwAddccw1ZWcdW2gkGg4wfP54f//jHmM1m3nnnHS6++GIKCgqYPHnyMe0vvPBC7r//fpqamkYn7Pbt28eePXt45ZVXAPjDH/7AnXfeye9+9ztqa2vZuXMnV1xxBQaDgUsvvfSYPo+H1+vlueeeo6ioiKSkpOO2+arPRFmWOfnkk7Hb7axYsQKLxcKTTz7JvHnzOHTo0Jd6APT09HD++efz4IMPcvrpp+PxeFi3bl08eez/IAlBniDB3zHY0kRX3Q4Ahrs6GGxrZt1rL6E1GBl3whzSp5/Ivn6BMlUUo06J1mQmf+JUutvbSCs8/gsg7+QYv7nkeiRJ4rtPPIOzu5P6DR+jNZjY/MZLFE2cSuPWjUDcbbl03ES69+6iu34/B7ZsYtGVV9P2+GNERRGvToNbpwFBiO8vEiI7v4BIw37EwulE9EY2PvcUUy5cRntjAyODAwDs7u7le427ca10Ya6diFavx+V04nU62bR6Ne/nnk5Do4slFcns/aCOFPeP2a+WSDshDLJMYChG7bUCB5+HpDGgUAtYi2RwlBEzhfmN2MW0tf6jBLm13ImhpAdpOIehPRK/m72JX5ZZ0HWWEgkqWHcbTD2nEXOKE01xDuocO+JhsSkTz5ruOgjtz3yColBE4wuSGssmfapA+lQF234h0bJCpmFLNiOtAvpSG5WHy4ZlzRYYbpTRfyavWt92GU87tKyQaBXAmhUGQU3hFTHsC2IUH1RT9wRYCsF1KIKu4iDSKXrS0hzYRYGgEwyHjVBhj8xwQzxbfcUyATgi/BRZNuRwFPKSeamtH0mGZMNuxljyKTSUEa6pJrJ3Fx6fizr3IZTMI+pz43MOEIsEiUUkTko7i+HgMPbkVHRGDT0H9tK8YS2pxWUUz5oHwBqXn978SuZn2JEP7sHT1wNARFSwZs9+FHWbKJg4gZg+SlSOkG3Q0t7VBMTrjw+98SxiRiHO7BIyOvayMDP+gt7jjOcdSNWpMaVYyRk3GY3VzhpfCASRErMBs3uInrBEwGQn1e4hLT0VpUaLXSGgCvrxW9QkdfVgGOoBk4W82om0HdiC35rCoaKxxN5bT0pBMROmn0CNbQqDlRLvdQ4xKcVChl7DgZ6dtG1qYrCoACmmQzKYMbn6GOdIZsRoxOMK055VhIgM4TDewX7aVUqyDVpSNUra3/grLePmEo6OYFArSdMdPZGS4P8vYpLEzza/dIwYB5CJ+zr8bMvLzMup/lrd1xsbG5FlmbKysi9v/DnY7XZSU1NH47ZNJhNr1qxhyZIlozGiJSUlvP/++1/JwvxN0dDQQEFBwXFd5j/Lfffdx09+8pPRj/yCggLuvfdebrrppq8kyNvb26mtrWXChAlA3AKfIMHXhSRLbHB+cRzzBudH5OmLvjH39dNPP52amhruvPNOnnrqqWPWZ2ZmcsMNN4z+ffXVV/Pee+/x8ssvH1eQV1ZWMnbsWJ5//nluv/12ID6BNnHiREpK4t+V9957Lw8//DBnnHEGAPn5+ezfv58nn3zyCwX522+/PepR4/P5SE9P5+2330b8nOfoV30mrl69mj179tDf349GE3+/PvTQQ7zxxhu88soro5N4n0dPTw/RaJQzzjhjdKKyqqrqC7f5byYhyBMk+Ax+lxON0Uh6xVgEUUH3np1EvB6qFywm4nEjKpR0e2Ag6ifk7GX6pFIAqhaeTNXCkz+3X4VSxfiTlxIOBNCbLbz/+CO07NrOuJNOw5aRhaOgcFSQ71vzARNOWkJqOET91k24errwuUcYe/FlxH73KzTz5yMbDXQ21pOUlU1OcSmtO7eiNBgJiwqcOiPdHjfvPv4IS398J4c2rseckopWLeHVaogq7GRXVpNy0hLWPPMHmut2UlRbxWlSN5XnnUfM24YqmokmXEHHxwHUAy9j8Oupe7GG5iyZRU8fcZ8OOmGkGQwpKi4/MY8pyTEi4TAqtRopIpMxtozgKSPs+KWJns0+MtPMpHiNlH+7jTV/ysfTqyEwrEAf7sTd6SHjkikwMAIpqSQXx6hcPEjHNiW71k8k1f4i8oDItjv0zPpLOaYsYVRsCxqBojMEVI5UwjvbiQYClF6QicZkYM+TMqERmfE3CKRUQdfH0L0BCip7SS92kjUmg4PZMUKuKIaXrQhdGvRpEFW0Yav9BFV/KoYVZ/DRnyV0qXDKiwoCAzLrb5EYboQptwtkzz36xSaadYQyNXTt2YwmoxSfHKIrtBf/cA92l57WzjYyKqvJGT+ZmG8XstzDmPRqhh3JCIpnMaWlE+qfQGbGkQrmxuQU9FZ7vPTeYbL0GiKSjFWtpDerkLQlFzI/I5X9CiNtbj/JOaVEPX6qD6RQOGMOAGXzFhMJBlDr9DjbWkgTJcbY9ORXnQ5A5+7tRCMyWDLI0msQRJHs2glEJRna+gGIhkMog36ye7txp+UwacpUjKr4fZGsNKLzr8eb1k+G30osEMSSnExSWjo9KWnos/NJ8vQRCIcYaGukcPoJKNUaejxu+oJhOnxBMvQa9IMiJqcfxCA95WPj95vNQa9Wz7QkM+8GwkTkwzXLOw4S7Wpm28T5jOhMlFiS0JSPJRz1IxmSsam/WIAk+Pezra/xKDf1v0cGen0utvU1Mjn967N8fWqN+UcTMh2vn0/7CAQCXHbZZUyfPp2//e1vxGIxHnroIU466SS2bt2KTqejvb2d8vLy0e2j0SiRSOQoV/SLLrqIJ5544p8a1+eN8YvYvn07W7du5b777htdFovFCAaD+P1+9Hr9F27/ve99jzPPPJMdO3awcOFCli5dyrRp0/7p8SdIANAb7DzKTf14+GIeeoOdZOhyvrFxPPDAA8ydO5frr7/+mHWxWIz777+fF198ka6uLkKhEKFQ6AtdsS+88EKefvppbr/9dmRZ5m9/+xvXXXcdAAMDA3R0dPDtb3/7qFwR0WgUi8XyheOcM2cOjz/+OBC3fj/22GMsXryYLVu2HNdj56s+E7dv347X6z3G0h4IBGhqavrCbQGqq6uZN28eVVVVLFq0iIULF3LWWWf9U3H5/8kkBHmCBIB3cAClRkPdW6/Q09qCoNNROWchlowsYs0tpK5ag/2eu8Bm48DKtzFFwS0IcFiQA7ywez9v1rfwk8VzGGs69oNl1oXfwtXZzqZn/0DJxCmkFZVSs/BktAYTCkFErdWiUKmZeeG3SM7NJzk3n5zxk6k9+XQyS8fw0Z+fZGdwhAUZ6YyZMRu91UrhuElo9AYyyqvQ2+z85N33IRQkI7+QlNx8ggN9VC2awPM/jn9YXfrAb1CoVNgysw+P6TLGzl+M+4c3ULJ/PwXnnUrQnoO5QCK2a5jhnmF6puhRGMygCKLUq5Blkf1/llEaoPQckXmPi2gskLevhZX3/5bdVhsX3voMH1wpkVwBmbNNTL4hjC5FzdKf1LJtj8xpT/uYcV4zzl4juoH30JRNR/Yp4J23YHgYzjoHWaUnv2qQsC+Zho/t+PeOIexNJRpW07ddxpQlkFItgCgjR2GkSabxNci60cPevo1494V51F/Ghe+cgBSFissEMmcLtK+RyZgKekmJjIAi2U9q2Ehvq4AhrMA+1knndjtKQy6irprIUDbWw3nx9OkR3H0DbL8vheFG0CbF86ptvFui4lIBc96RF1jPvjqGmg4xzWQiUjgGV/QEMnUZdK3eTmDYhds3RNr4WqotR0IYHCVlaIxGXnvwHj547o9MvvEuZmRkwOoPCTqKUaVNRaER2f9JPZLWQDDHxOKsJJSCwCfDQWRLGpkmK+5hPzkGDROnTaN3w2oCLhcBpxOD1Y4lPQPlYbf7CedeglpvQDg8Ux7y+WjbFo9hO/P08zFbjnw8KEWBM3JTEYDm9R/R33CQwapp+NUG6pubGV9aDIAl2cC4gZkY7HpSqk2jL/Uef4i9Y6ZiVSupSerF0yzjzD5SlaDSZsR82MIdlST2mBwox4ynsKAAY3MT0mAPMYUSYaiPwJKzSdGqMakUZIU8dHU1gyCQWb+N3BkLSdWqESdPJ/8ffxQk+DcxEBj5Wtt9VYqLixEEgQMHDrB06dL/Ux9DQ0MMDAyQnx+/455//nlaW1vZuHHjqBXq+eefx2azsXz5cs477zwyMjKOyrr+2muv8eqrr/Lcc8+NLjObzf/n4zoeJSUlrF+/nkgk8oVWckmSuPvuu0ctcZ9Fq9V+6X4WL15MW1sb77zzDh988AHz5s3jqquu4qGHHvqnxp8gAYA/5vta2/1fmTVrFosWLeKWW25h2bJlR617+OGH+dWvfsUjjzxCVVUVBoOB6667jvDh0qbH44ILLuAnP/kJO3bsIBAI0NHRwXnnnQfEf5MQd1v/ewu7QnH8sqWfYjAYKCoqGv17/PjxWCwW/vCHP/DTn/70mPZf9ZkoSRLp6enHTUT5VUJ9FAoFq1atYsOGDaxcuZLf/va33HrrrWzevHn0Wfq/REKQJ/ifxz/sYvfyl9CYzJjSMvjknTcBaNtTx7XPvELbJZfSW1VK/9ZP0JosCIBOKTDt7AuP6if32h9wa18v9TnPMnbKeLpuvIlIRwfZf/wjCmNc2IT9PqRoFL3RROX8xTRs2cCGl5/DbE+ievosimfNY/3Lz/PxX5+mbPos5l32PTJLxwBgS8tAoVTRuGUjVXMXUTVnIX3NjQz39ZJRUkbr1o1MdHUTCYc52NtFX3sLakFG1tkom5+PwZBPcl4Bsiyz56OVpOYV4Cgowp6RhT81FaG9ndf+8BtQqjjr1vt566wgomRApzNitphIu3krRdNmERyC/c/EE7UNDb5HUk4Ru4r7WD+0kywRBFnE2y4jRWHoAPRth+n3abHXQMZUCRB4/xoN0y/WkD5bi5j1bXwftYJFh6xOR47IEAYxSYeyJpsyxzCp82T2/mU6RSd42d9tZecjMmkTZGwlEsjxxHm11wmozTJidSHKTXvxDg4zHIyhscuEXAKDe+Kzvs594O+BoCuZmhskIjmv4QhmMu/EJQzawqy50YbBHmby5YOsfngKckxgyg0SSdMP4BzcyM4XDAzuOR9BhJy50LNJpnMN6B0y1d9VEHTKiCrIrp2IbDDRaMukSqWiwDQJAOWYEMPdnQTMEluHP2FW8sKj7iM5FkNvtOMzeOmKKsDlBK8XWRhgRG/CfWg9B/c0Efb2kjv/VOqyJ1JWkcakFAvBWIxOX4jeYJgajQZ3i4vcSTNIKSrF5Ehnx0vPAjD+3EtQKJVojCa8wwG6GobIKk3GYDaQUljCQNMhtq1/mZ5aODtzGSpUCKKIUoyLa1tWDl7nIMW+Ifr6OhBjATgsyBVKEVtBEmv3Okn3SVQXmpFlGX80Ro5BQ7peS7a5nM6T+yhSH4knUIkiheb4RFYgGmMoKqFy5LHIkcLg+68jRKMYrDa60gs45AmwJxC/npPzM1FPnkHX3l2EPSMUq0Xe6xoiU6+h2m76p58PCf41pOi+2Mrzj7b7qtjtdhYtWsSjjz7KNddcc4wFa3h4+Es/Ln/9618jiuLox6vf70cUxaMsTJ/+/emHtVKpPOojOTU1FZ1Od9Syr5sLLriA3/zmNzz22GPHzab+6bGOGzeO+vr6f2osKSkpLFu2jGXLljFz5kxuvPHGhCBP8LWgV3y1hF9ftd0/w/33309NTc2oW/mnrFu3jiVLlnDRRRcBcfHa0NDAmDFjPrevrKwsZs2axXPPPUcgEGD+/Pk4HPF3pMPhIDMzk+bmZi688MLP7eOrIAgCoih+bl6Hr/pMHDduHL29vSiVyv9zWIogCEyfPp3p06dzxx13kJuby+uvv86PfvSj/1N//8kkBHmC/3nUOh3GlFQM9mTyp85k68p3Ge7tJjM3j579ezDdcRvubZtwB31Ew3GLXkbFWPTmoz8MM2fOYKi7k+qQi2goiG/TRmJOF7Hh4VFB7igZg9mRHk/SNjRI3thxjD95CRnFY0jJzkGp09O+tw6Qadi8kezyKkqmzACgdNosVv/lD7Tv3U1X/X7smdk8f/sNSLEYSZnZFI+fhC07j6gM/rUfkVZUisJo4v1HX2DaBacz8aRlvP3IAzjbWxno6sCs0XHFMy8TjEnUXXcjU1JtDF59GSCj1Ec48VmZSAgMlstZ9dMWpAwL+RMU7H5MxlrZC5Y9dL06jy5JwaOX/4n+8DA/Sf8Bhl3z2XhPPP674lJwHhRIqoC+bXGBnj0bujeoaKgvZMKpceuR+dS4p0G0WUc0mITY50OVZkceCSD3eejfZWe42UDAacUxAUSlwJ4/SHRvBGQwZELREpGiJSDFRHKKzqFgYYTZksCqMwXkGHSulZl4k0jxmdC7TSbohM6PNOir9egtVgRRQJeuRmuXSKmIYmCYaVdpiRiTkHUtOPvWodLpUVCGQiOjToJDLwvYDr9fg04IumRWXCihNsPiZy2M5JTT6vai8wRI1sZj45PzCilYciI7QluPm3TGlp3LafMvRgxIdDr7GMkdg2XJUsx6C1URGG7zsX3NB0RCQbSDnQTVZfSbtJRXxoPbB4Juwn2N+OqG8CuKUGmzcOTmIMViyCjozSrmnS4nCzOT0CoVdDd0M7jnQ3xdDsYtXRJ3o49EOGhvIySF8QwNcGjFOyQXFFM8c278GAqKSS4oRpZlBhrrMSTFM7X6XU5EpRJEHUIsTKS3nVelVGSVmrAkU2M3Um6N/xZmJi045tgD7hEUKhU6nZ6l2SkMhiJEJBmdxUZg2Im5ajx1gglPCKanWlAIAiqlgozKapILioiGgoxojPQ5h4hKckKQ/wcxwVFEmt5Kn3/4uHHkAuAw2Jjg+PoF62OPPca0adOYNGkS99xzD2PHjiUajbJq1Soef/xxDhw4MNrW4/HQ29tLJBKhpaWFv/71r/zxj3/k5z//+aiAXbBgATfeeCNXXXUVV199NZIkcf/996NUKpkzZ87XPv6vyuTJk7npppu4/vrr6erq4vTTTycjI4PGxkaeeOIJZsyYwbXXXssdd9zBKaecQnZ2NmeffTaiKFJXV8eePXuOa1H7e+644w7Gjx9PRUUFoVCIt99++wuFSIIE/whp2iwMCuMXuq0bFCbStMcmW/u6qaqq4sILL+S3v/3tUcuLiop49dVX2bBhAzabjV/+8pf09vZ+6e/gwgsv5K677iIcDvOrX/3qqHV33XUX11xzDWazmcWLFxMKhdi2bRsul+sLBWwoFKK3N15Vx+Vy8bvf/Q6v18upp576udt8lWfi/PnzmTp1KkuXLuWBBx6gtLSU7u5uVqxYwdKlS0dzSHwemzdv5sMPP2ThwoWkpqayefNmBgYG/mefFQlBnuB/HqVGS/VpZ+MbdvHklZeQlJXDolvuoXnjxxzctJ4d77+DzmzBaDRRWFmFoFCQUVVzTD85997DyDuv09tYTwzIf/FFYh4v6qzMoxsKAjtffZ5oNMIJV1yD3mLjg6ce46Qpc9ClpXPOj+/Ec/V1DDd08tbw/Sz98R2Efv9Hop2dnH77bfR3d/LinT+maOJUklIdDPX1MtTZzlBnOzPOu4T82gmc8/iLDHrDGHr2o9IZMVkLQJZp3rmNSDBA2rCXDFvc9fD5lWuYeP01bJo1m0sfehSQUWt1qDMBTOx9tw7bmDX0tTjoOXAGHatF9OmpjPteBtsbZAL9Aj8ILcOd34H+mdmAACLYS6BwqUiJOm4lcrdJhFygMggs+ouAu1Xm0MsxYiGBzJkC5lwBMduGUoDBXgvrF0po7SmMu0hL+fd1tG6C0DB0fwKnrxD45Na4Fd4xHnLmx/cx0iKz+lqJiAfGXKyk8jIRURkFjRdroQnXIaj5gchws8TuR2XcHRYGd1xC2VMinnaZ4SaZU14RIaQl2pZCisOMyirSsjKDQGshUVUK/oZqYiEBtzlESpGS4hlKDkVkMqaJKNSgtYHaAm+fI6FLNTDxAZFCU7wUXtOafRz8m0TVpXZOmRZ3RfM0NdL/4UeMpE/BMSaDzKJktNV59O7aT3/zIVw6gYlz5qH2BlErJMzjJjFtyRm4OjvImzQNlTmN1Jx4zFV/0MP6vW+Tut+DEImiz3dgT4uLUlGhQJU2Ha9dQzgcZWBwEPfOzVhzChkgikKIAKA1mUmdtQBjNESyViQ65EaKxYiGgqO38EAwTESSydBrRsu6+VxOdr3+AgqVmskXfZsKsY3eht3YQiX4isZiUAo4viCxWtDjZuerz6PWG5hw7iX0BsNs6B+h0KRj2uIlAGx98Rl0ZRMJGa1sHXRzTv4RC7tab0CtN6AHFmbYsagTr7f/JBSiyC2Tz+Ha1b9HgKNE+ad25lsmnf2N1CPPz89nx44d3HfffVx//fX09PSQkpLC+PHjR2MvP+WOO+7gjjvuQK1Wk5aWxpQpU/jwww+PEtplZWW89dZb3H333UydOhVRFKmtreW9994jPT39ax//P8IDDzzA+PHjefTRR3niiSeQJInCwkLOOuus0cRQixYt4u233+aee+7hwQcfRKVSUVZWxuWXX/6V9qFWq7n55ptpbW1Fp9Mxc+ZMXnjhhW/ysBL8DyEKItPs846bZf1TptnnfuP1yD/l3nvv5aWXXjpq2e23305LSwuLFi1Cr9fzne98h6VLlzIy8sUhN2effTZXX301CoXiGHfxyy+/HL1ezy9+8QtuuukmDAYDVVVVo3Hmn8dnnzsmk4mysjJefvllZs+e/bnbfJVnoiAIrFixgltvvZXLLruMgYEB0tLSmDVr1qhl/4swm818/PHHPPLII7jdbnJzc3n44YdZvHjxl27734gg/xvyy7vdbiwWCyMjI197jFSCBP8Xhro6cA/08+Yvf4YtLYNLHvwt0XCI+o3ref/xX1M+eRqhvXvJmDqNnFmzcZSUH7V9/cZ1fPD73zEtLQd/UR4ao4kJ515yVJuAx80HTz1ObsVYhlsaiMVizLrialb9/nc0r3yXmYc6GNZp8Jy1hLyXlhMoLmCDFlR6A9M31aEMhtD88he09nfTuHUj1QtOIqekDO+wi0DAT9fB/fiGXbTV7WRj0VK2S+ms+uEsilKPWAn/cPXluPt7OWvZ98iaOh2F1cq2TzajufJyAhWLaXf+nIk3CQQGIWNqPCbaM9DH3+68Fc9QHxf89CEi7cWYcgRsxQLudpmWtyVKzhbpWCOx+zFQaCEWhNprBIpOP/JClCUZVz1YS8A72MfKi+zI0XjskyEDSk+P0vlukJEBHZVXKkfLkRUuFRh3rYi7TWLP72VMuQJjvyMSC8uEhmWaloO9LC7q9z4e4MBLahQaKDlXQKWDmGkDrt7duNbPJdJXwukr4vsc3BsX72q9xOyfh9jyax3DjZB3IkSDEBwCVwOovudhMC+A8VETNByOn1SA/yoXZUYDk+cfmy8g6JJ57xIJXQoselpBk9uPOxLF++gwvaszSZs5zMx74olQtjz2CBGNCmWzm9aLLqHcYabKbqJu+1aG9+xAqJ7KzNqxBFftg6iEZnYpHreTvoYDoNaSnJGJOS0dBQJvHWpi/Nbt6EPDtDuSqDz5zLjF+tNx+cK4PEEUFi2B/Tvp3LWN9PIqMseOQ6nWoDgcV/rXph4ikszZeakYVUrCfh9KjRZRoUCWZZ5t6iUmy5yT58CgUhCLhGn4+COGWpvQmizYc/OItrYQ0uvJnjQdhT2Z/cM+Six6rIcTrElSjOGebrQpaejVKiKBANteegZRqWTS+d9iz/Zt7NVYqDRq8K17H1OKA0N2Pmu0KfHAfUHgwoI01Ip/zUdXgjjf9Pv7uHXIDTZumXT2N1aHPEGCBP95HL8OuYlp9rnfaB3yBAm+CRImhAT/00hSjJad23jnN78gFoly6cOPYrQn0dzexlpZzTnTZ/PDmXPwfvwxnU/+BX1IwHH5sTVcXT3dxNxu1JvfQRhbSf5DDx/TpvvQAQ5tXMdIXy/n3/sggiAiKhRoDAZITmKfyUJX2I+24QC++dPJKBtDqcfDno3r2Vaay/gp09m65n0G2lpYcuNtFI6bNJqMC2DsvBPZ8PJzOLs6qSjOQw7oSTEdnYBn3Imn0nVwH2knzEahj7sOT5g+GWnLZg68oEF+Fno2ynSshoHdMkLN8+z56H0ySsoIBzzsX72BtNI+copn0bprOwYnlBZqGNqWR/uHOvQOSJsEyVXg7YTXFseY+YBIylgBSYox0PsR3oCVsN+HuVZAHc1HqcuiZwPs+r2CoEZA4ReQ9PFa06ZsKDsfutbJpE0WmH5f/Hgj/hiC10/wUJje1Wo61ujJmCFS/2r8kTbnwTCf3Kcm0A9jf6JDEERSx2nRpEs0ukMUmHREA4AsY0nxsepaI/ayeEmz1vfi58pw2LHBF4uATiaqEVDKAsYsicEfDSHpJVQHRWKSjBwJ01u/j+T8IrQmM1qbwOI/hImKYQaa+tgkGQgjsPDbaRiTwuQsVI9ek+TcfFyH6tGetAC/UqDbH6LKbsIYDuKJRclVS3TVH8Bg1OCPSQx4A/g/WE3zrvX0treRXVRC7ez5ZLV1YBeitCvVjNeaqJw2l/YdW1AajWSMqUIUBLQGNemG+L6jVbVoDEaS8gpR/V2ipiKTHn80hu5wshi13oB7yI/fEyI1x0KpRU8wKqFTxq/Hp2LckJRM4fQ5dL37Jv5wiJSYhMWRxo4hN4d6+gi7lMwoKQCgc9d2OnZuxZlTwsxZszEqFMgyhMMRdg2MoBrsIbd7K+mzF9J4eFx5lWMZM9DLgZG41TQhxv/7WJhXy7ycarb1NTIQGCFFZ2GCo+gbsYwnSJDgP5cCQwl5+iJ6g534Yz70CgNp2qx/mWU8QYKvk4SFPMH/LJIs8/KqlbQ//TusyanYM7OYeOIp9OyvIxoM0hqMMJCayVytQMkJC4jurkNTUoLK4WDL8lfoPLCXk35wA1qjEVmS6G9rwTjgRFSr0NXUHLWvaDhM/cZ1BL1ecquqsWVkolCqePVnd9C+rw4pGqXmxFNo2bGVcCCAFIlQUFHJYE83A91dlNSMIy2/EGtBMS27d9KxZxcIsOzhx1AoD2fLDYVAoSDc24cqPQ3hSzJvfpZDr7/C2hf/SlbmFOxjiwk3zCd1iodtHz5Nb/cWFn7natSxVHb9vJSYqofTX8rm8e+exdzpZ1JaNI76XTk0rDSiMkDEBzprhJSSMO1bDIw/u4f8bzsI+N3sfO0F5IgOk+IsrLZPSNI5UE2u5KPrw3jbdexObWd5ZiN/WlxM1++ysY8BUQ39m2PULAuQd66Z4Ub46KoY5pQAMy9uJRpT4UkuofV9iPT70SfLjLvNQOc6GG6A8kuhZxOkVMOaIRc9cohpKRbyBD2RzhFGdnrY+Od0cqcHSZsIWx/VEQvCuB9B5gkx3H2DfPJImOj+bJR6maVvKhiJRul3RdjsHYlnDXe20b59MylFpZScMB9p2E94YxNBQuzr3ox10kykrAIqrQZ69u+hZdM6csZPJrvm6BirHn8IgyzQsL0TbBpK0lTUb1rP2r8+TWrVHKLnno9JpSBnRx39jdvo6DhIVnEh2bWVVBzsZ6cS0GioOvkMQGbzW6/RNn4eqSYDi7OSj7r3Dwz7cOjUo7HtX8b2VQ0EBxsRgq2MWXAytqx4OZmuPTtp3bIBpVZL+cJTMaWk0rNjK807t2CzJVF+xnn4IjF2vfAniISZcM7FaIwmnB2t7Fu/lv78SianWnE3HUTIL2O7X6Isw0G1ScNgcwNJeQUolEpEhZItw+vYPdxFkmISk5Myceg1qBJC7V9K4v2dIEGCBAkSfL0kLOQJ/idZMTDM9Qc7cKkczJm9hB/np1M470ROX72FSZKGef4hYi3NjNFq8LgluvftpmDmrNHt9635AGd3J4OdbWSVVRCLxajfuI60wmIseiOCx43WFP9Ybd64jp79ddTv2kFmxViad24l5vOSU1KKFAkjIHDK1TdistkYO28RL975E1ILi7EWFKOyJiEpFBjtdpRqNcWTppFXM54//uDbQDxzp6erA8nrxbZ+Pb27dzO88kNsF11E2m23fuXz0brmI9xyFF/vNmyVuQzsknC1hsiozUY7NA936y6gEUORkkBjOXWPwdiCs2l+90QMFxsp+baWpCkyQ/tkmt6UiYYEsot7KJqqQqv0M9KSgqi3E+tahHO3AZ/ZgOnkOdR9ItD7OwWxoA51WgcO+4v8KOzBcPU1pEz6PV2b47VrC6aOkG7tJdaejiwnIUsw0qtjqM+MY44BbarAhrvCIOk49bYgke0tZFal0u4Z4JUnXCjerEJjBV+BFtOZEgMrldS9IlE8PUTZ9GFO/qUS9w4PkX41VSdqaN9uwlIYY9cbL2K2O1h88Vha9oSwj9OBACZBiWAQmHDIQ2o4CrkWVDo9Zkc8TkvQqhCMGgSliIUsCnNz0ZqNDDQdonP3NhAEVFrdMdchXa/B4wrQZFTg0wrYtSZEAVRqDWaFn0I5ii7kJpxrw55/KbnGYXZoPqIiqRLVpFzkl54lGvCz4403MOTMIHPseNoVSv5+2rXDF2TLoJskjYrTclKOe09EwyHqV6/ElJKKICqQhxshOIwsSbh7u0cF+afkTZyGKSU1fhzjJhJMSiVqiP8GDCoFKdm5hHxelIet8fbsPGacl4sMHProfVztrRRk5nBmeTlahchQaxPNG9biam+hfFE8+YxBaUIpleOO6WnzhVjV42JSspkKm5EECRIkSJAgQYL/RBKCPMH/JNvdflzRGHoBjF2tbN2zAfWEaexT6ujLGkN10x6GswpYnZTLeQYFv1bYqOoc4FyNxEh3FydfeyPugQGyyiqQAgH2rHiTrctfIbesgvScHGzZuZQvPAWAwZa4w21WUQl5NRN461f3k1tahixJZGTnkOJIY6SticH6AM7hYUJ+HwqVimlnXTA6XikaHXVPV6k1XPbIkwAolSr2v/82CkliPCoiooAkiiiTk/6h83HC7feQ9te/UHTe+YRDNjqfUxLzyPj2zkATzkGhaEAiSMVSJfUvyaTWiqRxLls2Ktj/N0ArobOL1PxAJHuGl49+qGPzX5M5+ZkI712VScirxF4u4dyfT+ZMiAZg+6MqdKkQC8VdxcuuVGNqtTEmaGX4QxFXg4hgjGIoq8OxwIKg0iJa9ditAvP/IHLoJRntpByUuQKH3u4g7ay3sWdWIXqLibr8RNqG6PAcwlfbQ7FiPyObZqDcnoPO04SYbgCU2LLiicqUOpFPXswnFhTIqHJjTA6BLCLLMkmyHVxe8nL8aGvGsO7HMoN7wVwgM3Yy6JNjDPaPEAn4CbiHgbgg18wsQQNYqBg9z57+XiKBALkTp5FWVnHMdRjYJYOgpSjNTHs4jE2jRFtQxPjZ8ezm1sAgrTs2I0gSvqzpJA0aWFp5Bj2b6qgrNuAaMwFt/S6U6lTCwSihPdspkGJMOPMCkCTwuMFiJU2nIUMW0Pb4CKVY0eiOrUkcGBlhuLOd4Mgwgqgg5HaNrvt0sgkgs6oWQRDp3LUNvdWGKTWe7X1DVE3YFcCn7KTJv4MTpp5IssZBiyeAMxSgNsmEKAgIQP7k6Vgzs0ktKkVUHs4rkJSMMTkVW3be6L4qzePI0ETo9odQHs705Y5EebdzkFq7iTT95yeNS5AgQYIECRIk+P+RhCBP8D/JTflpzLaZGKeCl99yEhEE3vvBpTz6vRvp+WQ14UAAY2yAxbW1eLo7eNEXo621kzH18TpbWdXjKZo4BYD93/kOH4WcqHU6ak46jfCwk5Si0tF9CZNnY+lpY8qUGYgKBeWz5hANh3GUjKHv0AEMFiuWjCz6W5to2r4FgOyKsUeN97OJuQA0+iN1ITOrxxENhVBMmoq8by85d9yFyf7FgjwWiXDggxVoTWaKZsxBk5zM2OuuR4rK7LhDwlEepGiym40vJKHL30WmdRKekTJ2/k5m4k0CjkIPohRBm2Qj6IRdvwFEiTNXiljHGEjJbkFnciNGMxFFCZBxTBDImewl37GTISoQFHYqvwWuQ/GEbBprBvnRK4ge6sW++DzC75pRpH/MyOA+FPrJKBx5CIa44DKmC9hLQXfYuNvwWgzLNAlZjiDYDidZc/pYmpRJg5RCyLQLjyJuJlbbhqm5NkjZBVoMpmSEfhFFXhLpUwU6V0P3PgtIMPLj/eQHXqdlcT6lOcnoTFEiezqRIuk48t30N5nY7tMz/rtZpNWKKO0mUgo+vyTTUDBCZ14lBdkFZGZkHLM+4pVZe70EAix9y8o4XVxxeqMxAOw5eaSNqaDTF8Dp9pCdqicnO4O+fRsZam1iAA2u7GL0xTVkN+xE8DrRW+1Eo2FUKjVs3AB798DceWiKS0jvDeJ1BXCmeOhpdhIrsKC1aqk6XCrMlJJK+aJT0BjNCIKA3+VEisVQG/RY0o6uHOBzDhL0uPE5h0YF+VibEXckxlBkJ4PhfvpC3SRrHGwZHMEflcgyaNC4BmjdsoHcCVNIK6ug1RNgd2sTurZ6KiZMonrJ2WwZGKGxx8n0NBuiIGBTK2lw+wE4P9/BvmEfvYEw7b5gQpAnSJAgQYIECf7jSAjyBP9TRMNh9jU10WROZklGMgpBYNnDj/Hh04+za+UKgiuXE2w4SEhUEJNl1uzaxZWDzdyvNlI7djwBtZpIKERSXuFon0ZHGtbGftIn1lA0efpR+9sx4uPU9hGqjOmsOiyqF18VrxcpyzKZY8ehs1gBSC4Zw+YVbwGgNRwR3D0N9XQd3Eft4tMY7uqgq24HBVNnYUyOq9Hc8ZNH2+ZWf34W4uEmmQPPSpSdL6LLCDDS3YlPq6VoxpFyPREv9G6REQU14xZ6yF16gCDNDLy5GVlzDgPKdlY9lMnZ3ylCpZaYfb+eSExL16oQomcEeVCHwmHhhKdyQSGCLLPotyNgVaEyK2B7A2w7gNEaQze1nJ52Hft+aaJ3q8y0exRIQ15ibUMIJh9jr7QQ2pSFX61H79QQdfYgByMoCtNoeE1m7x9l+nfK+PvBkp6NXbeMshN1RPd3j9ZJEgSoqCwhmpSCr8LIQIuAOXcq718kUnK2TE5aNyo5SFQhUDt1hMxkHY270xg6pCEqG0hbdgOKmJrda/SMP9GNzqBh+lUuYo199HTJDBkOkDLpbARRJH1MJVFJxhOJYlId/Wj1RqIcHPHR5A1itJvJOk7cs1IPeYsFBDGeqf5T+ur3x49FVKBUa1B2NGHxekAK0txXz8ZX/0ZxVQ0G1wAG5wAanws5FiUc9JNeMYGs8sOTQwYDfr2B/UoDJeEoZROzCPjC+D0hfP4wjdEIDEXIMmiwaeJx5bas3NFxfHqffsoep4c6pxdBgIyiGgpMZkZ6ujClOjDYk0eFfSg2j2xlHi3bB4iq1jKtdjKuUIRktZLmpkP4hgbY2dWLKSYyqNCi6GrB0NdB834DGQ4H+10eZARKxTCpjjQiUjz+HaDWbmKs3YhZrSTHcHRiugQJEiRIkCBBgv8EEoI8wf8Unbu2cdNAiN36EIJSyemOeP3mOcuuZPeqd+lpOIjBYiWkMxLp76by5T+gmjWX4rAX13tv8VQ4Rnn9DsafcxGde3bStm0TORedx4WFt4+68UaCAbr31ZFSWEKmzshYo44ZNhOyJHFo7QcEfV5SSsrJKClj//o1qDRaxs4/EXt6JmfcfDeyLFNQeyTZ16o/PspAazO2jEwCQwN8svwVPnz+GRZ+9xoqTpj3lY+9/QOZzrWgTZKpvdrM2FPPpOfAXna98RLlC05GpdSgsSopnOqkq87IgXU2CqZ56BoQUQ26MFytxfvHFSgw0VH/CDFfDKlNQ/V3RUy48exwse5uC+Y8N2WVLYTEMLYTJ6I6XCMbgPIKevYb2PFcGn6PGfHnb6GzLEItRAAzYrIRZbEDwaon6pfAG0Iv6kGrQlArEVMtvLdMIuKHtHFRbOZhutYlo7ANUv0jBX1b9DQ8Y6Fypge9NYqQZkGRYkKRYkID2CdC58cCUb+Euz7E3u020ks8JMdGUCokUvN9pJ4q0bJWoG1VLgfatAycGkVMbadbcpBfkEJ7jwtjkp6RCjNjMyuOynT/ca+LNl+QRZlJZBy21h441MwmQUul1UCN3UiZJT7ZEvHLOA9Aai0IooAgCky4QeDvyZ0wmb6GgxRMnYksSRiKxhBrOIClchxrXnuJgNuNZ2QYh2GAoMGMRqUiqNGjCHhxDUTJIj75M2g20jpzLnsjAiGXl+kOK2qdCnOSHp1BTfvQMBKgk48dw/EYDEUIyzLIMi6fn44dce8OlVZHwdSZQDx5nErUEAqm0J1lw+MeYuLB3ThMZt7rUeLWp1KeH+OQPQvCcGKGgX0llYR0OmpqaxEEgcrBNlx9vWinxfMJqBUiCzLso/8GKDYfW3ouQYIECRIkSJDgP4GEIE/wP4U9N58Frn3o9SrGf+YjXhRFskrL6TiwF797BHlkGKUgkFteSd7kqXR8vIY/T57PKllFSmExyx+6j97GQyhVSuRYjN4De6hZei7Oni58A3307N1F0DNCalkl740vQhQVhAN+BpsbkGIxVr/wLMt++ThrnvkjAGUzZqNUqRjqaCM5J++oMU8541za6naSXlxGfU83fo8HAPdgP7sfj+HrkZl8mwKF+ouFVOl5Ahob5M6PtzOlpnHg/dVEwk761m7BKlswzCqnaFGYoHUdIWsjkczpVC35HtKl3yUcCjBfDmPoiaDyBtj6fhYVlwm8/8RvGF47HrFvMiAQGJIpGSMQk6MAjDTLdK6TiQUga7aG9U+XoDTKKE49SFo0k64RNa3rVYyTJESFiLIolY13xejeABN+WIjBIZA8Li5uY14/ypH9+PzlZJcNkZo+xKG+FbS0rGb1r04mUL+EVZourvQaqLKOEOsdInJIHRf5Qvy4s2YJnPisSP9WBTt+Y2Og08LC23vwtUVp78impFbJmIsEVAaJxj4L/foRtLoimv6Qgn+ql12BEIYUI75QBI0nyBjrEW8GKejHUb+TIcaQUVzE4BNPwCO/xvH96zBdetGoGAfY8qCP7rU6HPN3MePH1ceEJXxKcn4RyflFeIcG2P7yX3ElZ9E3bi5dUZHowrOZMHMeJTolfZ3t0NGKPjsPQyzGSMCDI8dM56FBQiO99NatRZeUQumkuZToj8SMC4KANdXImLpeIqEoYkHa595DA00NaAwGgpZkWr1BDAEvqXWfkF5eg1Ojw5ycTObYcQCEwhHe6BhAqVCwMCOJvsgQ5q56Ogf6EJRKhqacRMykw2LTU+LqRaHWMBAy0RETqSivIdrXzbYVr1M0Yw7G8eNRao5YwDMT1vAECRIkSJAgwX8JCUGe4H8KsyOdGxalc8Nx1p36o5vZ8/5b6Cx2mut2kpyTx/RzLgTgk/feZuxLjxO95IdcMK6atcufxZyURHFVDRqDibDfy843XmTdG6+QU1lN7Zz5uEdGePra71C7+FTmLrsStU6PUqMlGgpSMXMO7j0pKEgihpMnv3cJNkcGfS2NGJOSufKxP4+Oq2TydEomT6d9xxZ8vV1MPOk0sqpqya+dwMsLvAgxPUNNI6SOsR51PLIk0bp1I2q9nsyqWjQWgdJzjoj2/l0yHX87Gdv4Q7TJm3FqbVSJFZhmZKEf2oB3EIaGOrF5q3nvEomIX8JQ7OCESyyIsRhnXCEgqkXWXrkdlTsdiwg1V0PdExre//UY5j4uI0syH14lEYvnTiO5wEf6FAPWYpHiM8v55LcfYKzcgSqWQnhNAM3MEgSVYjQr+JaHVAgCLHlTRqUX6L37LrIb30K2PUTb/gXUvZ2CaNOTYfXj/2Qhn6R18UFWE+4DyTzwyXIcS5YSaxpAkW5F+ExNdlOWgC5JjX9QJnN8FE1VJvvXCTS9IaNQy4z9rkDR6SKFsp6GTzqxR6NIV9tQGnUMhaLY/MN0u72k2NTAEZFtHOwm1teOT5ShuAjRZAJBYFpBJtbPiHGAkLwDpbmcmKqZaGQM6sOC3N3XQ/PGj8kZNwl7Tj4ArlCEuoERZKUGEzG02z9CFQ2TP/90xpRmo1WIWDOz2eLzU29I4YTasZQQA0HNtpUNyLEIKr0BEVCvW0FTJIz17ItRajREJImBYISxJ+SDDEr18cvleZwDHFqzElQKKs+7PL5PpYBBq6XeYyZjyplUFFlG2zdtWkcoKR9ZrcKgUjA/x8GuHRIRQSB/4lRalUpikkxydg55BfHa5N3+EGaVglStGu/gACGfF/+wC+vfZXRPkCBBggQJEiT4byEhyBMkOEz/oQNE3CPk1U6kauFJR61z9XQTG3Hy60IH5pRU3j/1fFoUasr9/YgaNf5+D9GRESypaWSUjqFoxhxad+9AqdZgsifTunUjQy2N2LJzCft9TJ63mP1/EtAEy4lZ9xGNeJGBmkWn4Mg/Ep/uH45ntu7euwtzWiZmRzo54yZhzcwGIFT6KP7BCHrH9xlqbaJ+zSryJ88gfUwlQa+H7r27EESRzKpjY8st+ZBSaSCprIjGNwpwSjoqzlQjAsWz5tO2vAWjJhskkKMghbR49lbT0+IhfY6VlvdkkiolbM2/RBR0yJLAcIPAuGuhbZVI+0dw4FkJjRXUVpmMtH5s0SGm3V5Ke10fb56VjLk8HV1eHcE9aXTX6ckpHEZItyOIUH66B5UqxvCwDeXhCmHaslL8W7Yw+b5sVMVKVn5bRifnMum00zn0DozvSAVdHxfUKPCvn4C7bi3WMy4gHBTRKCMIh7OJSy4folqJRh1BtXcD7b96lZyLrkQ4o4aCJUfOkSAI5DusEIqgLFcjiALzM+wcWrsDe2M9IfU0SD5S37u2uppGQSa3KJ7czX7hhdjOPRfhONbv0rNMeE7YRlb1bNS6I94aIz1d+IYGGe7qGBXku4c8tCj0iJMWckF+CttffYGwJDMciaA97Lats1hh6nxCviBqUUQURWKRMEZlK7IYxTcSIBLwo7NYkWU5HmAPbBlwc8jtZ0qKhTFWA7FoBFFUHOWKDyAZFDgzokT1MVSiQK5BS2G6DVV2Hn0HXeg1Rwt5k9lM8e61lM1bhHh4X1UnLyUWiaDWGzg1EiUiyRhVSho+/pBIMEDZvMWcmeeI72/SNJILikaTxCVI8N/M7Nmzqamp4ZFHHvncNq2treTn57Nz505qamr+qb7+FSxbtozh4WHeeOON/6/GlSDBN8WaNWuYM2cOLpcLq9X67x7Ov4W8vDyuu+46rrvuOiD+HfX666+zdOnSf+u4/n8nIcgTJDiMQhUXa4rjiKcLfvow4WAA8+FEajOmTOXWtkHmmAuwbPyQfVs2UXPCXConTsY1dR73NHZzY2UN1z77KgB7VrxB0OOmaOZcLOnxDNWVl8mkT72J5AoI+j2Eg0GeufEq2vbsonLOAnr276F548cYUxx4B/oQFQrGnnrmUeM6/1c/IhaNoNEb8PR2I8dihP3xhFc6s4XiWfOOW+8aQGMRmPWgAilkomU5RCMQi8iIahlpj5d8hxpn4wiqE1KYeN9BXGtj6KImWt5Jpn1fBwfab8extQyV4iZiIUCMa7yMaQJbH4zSv0OBoABBhEVPK5A7RAjZaNm/kzd+dS9601RS+DZZ8nR2tqWzvU0gKfsQkVIbnWug4NJ+LI4Q+WdqEVZvomlPLm2Ny5j8t29haN+Md/BDpjwpkZQ0C5UmHVtGG+FHU5go5JKp92N5+DR8QyLvXRljzrcOIesl+p77JbpTLsdiNoNWxVBDLtrBzfi3foyrx0SHvgJTpJf8C6wo0ix8+PQTtO3Zxdm3/RSTeMS7wFFajqhQ4iir/Lt7SE3FxMlHLTueGId4ubD+hoM0rV9D4fTZiColWyKbkDIkxlpPxHZ40gWgKslIXzCMRa1EpVRRdOpZrGgfIMM1RMdQJ5nVtYiighPSbEjRKDtefZ5wwA+yTFBvoqdsIuWlYyiymZEtdva6PDh9frpXvI4YCJKnUBEymQjOOIFdr7+IbLGTPWEKWZlHsqlbNHZqZp+GRtTS6g1Q7/YTiEnMTbdRHqtHNaiF7Imj7bNrJpBdM+GoY1ao1ChU8YRxnya+k2WZwdYmpGiUaCiI+nAFAVGhGK3rniDBN8myZcv4y1/+AoBSqcRutzN27FjOP/98li1bhnicJIz/DrKzs+np6SH58CTg5338v/baa6hUx5Yy/EdobGzkvvvuY9WqVQwMDJCRkcGUKVO4/vrrmTBhwpd3kCDBfyF//6zIzs7mjDPO4O6778ZgMHzJ1v//s3r1an7xi1+wefNmAoEAeXl5LF68mB/96EdkZmZ+eQcJ/s8kBHmC/3o6dm3D5xyieNZcFMqjP1KGuzrwuYbIqKgmq3o8GZU1iIq4pU+WZZxtLRiTU9AaTWiNxtHtZuXlsL6oACkWo8EzSP6EKfiHnXj6enig08nBYITJVgOLki3xclCDA5jTMnH29aI2mtCZzIgqgZTD1c10JjN713yAIAhodHEBrdYbEBVKknILsGZk4SgtP+bYlGo1SnVc4KSXV2HNzEZrPuI2nFpc9oXnRnL6CG9pZu4NdsTidD64UsbfB7MvD2GygXdYh3egj5Yta1AnGzCqz8To1eMKb8XvH8I5eIiLXxTp2y6TOg6cB2HzE5+QfsEeXB+fTM23szBlCig0EGodgpiEatiHSmkgpNzB3pE6xi34MWW6VGKeGPpJaRx4Nz62hk3J2DL89L0mMWNsK50bixnqA+cuP4aOXbgmhggFJPxbs0nNL8U4LhdLWYSGT9JwnC4gaES2/TRAxKumvc5GQW07LQ0zGXxiCuPOHSR7ephxP9bgbbwGLw40sQxCjUrcvWrkSIydv5EYeudsPMZt+IZdmJKOWMKbN36M3zlEUn4hw+ZkkrUqgjGJFZ2DFJn0THdYv9K96exoxTvYT9OGtYw4ezk0O4iAwPSc+SjE+HVtdPvpD4Q5My+VgMvJG03dCColSwvSWXHAz0BMw6KuLuzZcbduGZlYNIIsy4gKBSkTZ9IWU+E0aDEmWdnc1U99UEKu+xiGh+L3GgJ+3wixaISYIMBgLy2r3sZxyRWoPiNGsnVxi71VKRGKSeQZdYR9Xnr21SEIIlk1E0Zj9b8qgiBQfepZxKKRUTGe4H8bORbDv2070YEBlCkp6CeMR1AcP5Ti6+LEE0/kT3/6E7FYjL6+Pt577z2uvfZaXnnlFd58802UnzOx9q8iHA6jVqtJS/tyjxG73f5P7Wvbtm3MmzePyspKnnzyScrKyvB4PCxfvpzrr7+etWvX/lP9J0jwtSFJ0NsDfj/o9ZCWDt/wBNqnz4pIJMK6deu4/PLL8fl8PP7449/ofr9pnnzySb7//e9z6aWX8uqrr5KXl0d7ezvPPPMMDz/8ML/85S//3UP8r+b/j2nfBAm+QXoP7GWopZHAyPAx6xrWfUTr5k/w9PcCsOPdN9n06gsAONtaOPjhuxz6+MOjthl+4w0OVo3F9cKLiAoFpXMXUThtFhWLTmXiecv4aVkOP8pzMPtw2adYJIIUi9LT3MBrP7+TlU/+9phxuAcH+PivTxPyBzjv3l8AkJRXwNRlV5JVPY7cCVNGs7i3bF7PjleeI+T1HNOPzmL9yoJIjsaI9bvjccNaidbtq9BXvE9ytptDO7Nwkkva2ZloLTZMjnRSHPkYQ120fwjeT04gLXwD6bG70FgEcuaKKLUC9c/L+PslBEFi+n0S2SeIWIuE0TJkAKnWFJbM+Ck6bRp6qxX9wkqqrtJR8xMjqmwbhacKFC4RyJwxTP3HyQw16tnetJRIVE3u7DBZiw3Eps5GNTiLSGcNbz56Fy/ccheR3e1UVtcz/jsBVl8js/8ZiYyCIZJzfETW/pqoZhjV+AUIChllSoTmi09j8K6bSKq1UHj/5aRP1jDr3C1UXCwROjBA75YYQtjCKVfcTVLMhByKjh5DWmk59px8XFoTa3pdrOsbJibLyDLx/0ejRHp7v/QaBN0jKFRqTKkO1KKG+ZpFnJp2HhrxSD3tXU4P9W4/+7v72bX8JYJDA3jCURSiQERvImS08mFIyUAgRNv2zfw/9s47TIoq68NvVefck3POwMCQQXJGRBFFghgwYJZ1XXN2XXNc85rALIqCCqIoWXJmiDNMzjl27q76/uhhYJwBwdVN37zPw8N0163Yt27Vueec36k6eojozL4gSYQkpZKZGMe50UEMC7VQtGsbrnXLSfDZCQqPQKHRUh+VTF3fEfQ4fwaGgCAGXHwptpAoWiL9OeVdoVaI9A0yE6BRoTGaSBszkYyJ5521MX4cfUAgppCw37RuN/9bNK9axbFx4ym+8krK77iD4iuv5Ni48TSvWvWH7lej0RAeHk5UVBT9+vXjvvvu4+uvv2blypUsWrSovV1TUxPXXXcdoaGhmM1mxo4dy759+9qXP/LII2RlZfHhhx8SHx+PxWJh9uzZtLScGK9tNhtXXHEFRqORiIgInn/++U7HEx8fz9/+9jfmzZuHxWJh/vz5FBYWIggCe/fupbCwkDFj/CUrAwICEASBefPmAf7Q8OPhogAul4u77rqLmJgYNBoNKSkpvPvuu11eB1mWmTdvHikpKWzcuJHzzjuPpKQksrKyePjhh/n666/b25aVlTFr1iwCAgIICgpi2rRpFBYWnvE1f/3110lJSUGr1RIWFsaMGTPOeN1uuiE/Hz75CL79Blb/5P//k4/83/+BHB8rYmJiuPTSS5k7d257WsYvqaurY86cOURHR6PX68nMzOTTTz/t0GbJkiVkZmai0+kICgpi/Pjx2Gz+SMd58+Zx4YUX8sQTTxAWFobVauXRRx/F6/Vy5513EhgYSHR0NO+9916Hbd59992kpqai1+tJTEzkwQcfxOPxnPKcSktLWbBgAQsWLOC9995j9OjRxMfHM3LkSN555x0eeuih9rabN29m5MiR6HQ6YmJiWLBgQfvx/hput5tbbrmFiIgItFot8fHxPPnkk2e07v863R7ybv7nyZhwHq7WFoxBIZ2WxQ0Ygq2uBmNwKF63m/UfvQeyTOa4SRiDQzCHRxJ8Us1xAKnVBrKM1NqCrb6OluoKwlJ7ICoUiDodw3UwPMDU3t4QGMSAWVfQWF1NVWkp8V3UCjcHhzBs5mVojEYUio63pdfjobaogPDkVABaqqtwNDXisrWiMZo6bes4JXt3Yqur9UcGtIUJn4yvsBZfQS0oRXyyj/riAjQREn36RqBKjqLhx6+oWleCPHkULVUVCCEQHhpK5hwHugQ9Kv0oTLHgstuRJYm8L/TUZkNo/3Pod3F/dFYDLQ4vB2saSHFLBIxKpf5YPj5JQGVM4NprXu1SGd4QIZB5LeR8YCYp7HOq5elU11QQ2dND5qAa7DmxrH8qFVsFaOLKkSUvKosXJL/1qFE7QdChMkDitYHYnywgt/gJ5HVHqTgUiTkBQtObKPT5kBwO/zpWEc21EwBw7y4i/2czrWUiUcMlQur245OjEQQBZUoYkt2OZuc+ksaOpfHIYYJlNYlpiYTrNMxODEctClTc/wBNX31F5BuvUyX6sEbFEJqc5r9Om9ej0umJ6z8YWZIAiO7dj8QhI7r8HUeEWakqK6Nl1Q+IskzUgc3Ej55Aze7t9HM62R+SgE1WsLy0jvijR9A47fSYfD6CQsEB+15yyqrRiuOptLsYaglAK0CKXklg+ihsg4ezrKgatySz3SUyEVDpdNT0HIwkg3TK3tWR4MSUM2zZTTenpnnVKsr+dBvtqo5teKuq/N///SXMEyf+y45n7Nix9OnTh6+++oprr70WWZY577zzCAwM5LvvvsNisfCPf/yDcePGkZOT0+6ZzsvLY9myZSxfvpyGhgZmzpzJU089xeOPPw7AnXfeydq1a1m6dCnh4eHcd9997Nq1q1Ne+LPPPsuDDz7IAw880OnYYmJi+PLLL7n44os5evQoZrMZna7r9KQrrriCLVu28PLLL9OnTx8KCgqora3tsu3evXs5ePAgn3zySZeh+sdD4+12O2PGjGHEiBFs2LABpVLJ3/72NyZPnsz+/ftRqzs/c05m586dLFiwgA8//JBzzjmH+vp6Nm7ceNp1uummnfx8+PGHzt/bbP7vJ0yCNrHQPxqdTndKY9fpdNK/f3/uvvtuzGYzK1as4PLLLycxMZHBgwdTUVHBnDlzeOaZZ5g+fTotLS1s3LjRr/PSxpo1a4iOjmbDhg1s2rSJa665hi1btjBy5Ei2bdvG4sWLueGGG5gwYQIxMf5UN5PJxKJFi4iMjCQ7O5v58+djMpm46667ujzOL774Arfbfcrlx+/77OxsJk2axGOPPca7775LTU0Nt9xyC7fccgsLFy781Wv18ssv88033/D5558TGxtLSUkJJSUlv7re/we6DfJu/ucxBodgDO5sjAOEJqdBchrgz1k979Y78LrdGKz+2tmZ503vtE7gZXPRjhiGJiqag98to6WmCpVWR9AvDPeTUesNhMYncPnTfwfA43TSUl9HYOSJnJwhF8/utJ6jqZGf3nmNnO1bmDD/FnqPn0zGhPNoqig7rTEOUHnkIG5bK9F9+mEMDu20XAgxQ1EduH1IlW6qlk9n8KwiFKISUSOyfckEzOdvRpmfizksgoievdEmJJPeVvrcVimx++9e9pXdiCy4iGl+B02ImsSZEs5qHQ1HJNbtbME1yUNh7lHO9abw4eN3ISqUXH/fywjeEOjipS13icT+t2UkdwAIlxKcVc6x0vsoOKIjpfcjtBaosFWAygBKdyRRtYsYPNvLwS88JA+xYdZUMH25GaVezY/fHGO9ykt/i4eoGelIeicpfStx2SPx3LCVsMs6pjD4qpsRowOIPc+NR20nOLwShdqE7dAuAkdfCkDjki+peuIJ7Lt348g5SkJVFZFPPQUTJqBViLhaWxC0GgSNBjsSNceOYq+vIzQ5DZetlaqjhxAVCuL6D6bPBZcgST6Uar9HXLLZaN34M8bRoxC1flV4x9ED5P+wHIvJiN4ahM5sJjAggL1r/S8jyZVl2EdOxVZZTnBICBFJKVgjo1HGBVETIyI69QQLdjySiODzET9oGI6mRrwuF7krl5GkNVCcNoBAlQJnSzNak5npcaFIsoxG0R1E1c2/Btnno+qJJzsZ4/6FfhHCqieexDRu3B8evn4y6enp7N+/H/DnV2ZnZ1NdXY1G479nn3vuOZYtW8aSJUu47rrrAJAkiUWLFmEy+cfoyy+/nNWrV/P444/T2trKu+++ywcffMCECf5JwPfff5/o6OhO+x47dix33HGiJsjJ3meFQtE+ARAaGnpKAamcnBw+//xzfvzxR8aPHw9A4mkMldzc3PbzPh2fffYZoijyzjvvtEfGLFy4EKvVyrp165j4KxMnxcXFGAwGpk6dislkIi4ujr59O09Wd9NNJyQJNv98+jabN0F8/B8evr59+3Y++eQTxo0b1+XyqKioDvfwrbfeyvfff88XX3zRbpB7vV4uuugi4uLiAMjMzOywjcDAQF5++WVEUSQtLY1nnnkGu93OfffdB8C9997LU089xaZNm5g92/8eefIkXnx8PH/5y19YvHjxKQ3u3NxczGYzERGn12159tlnufTSS9sjcFJSUnj55ZcZNWoUb7zxBlrt6UuSFhcXk5KSwvDhwxEEof2cu+k2yLvppgPpw0YBUHEoG6VGQ0hSaqc2LfW1LHr4LgKjopl49Q1oigowh0ee1X6+fekpCvbsZObDTxLTI7PTclmS8Lpd5G1ej6elGZ3RhLVtHx6ng6NrvveX07rqxlOGCWdMmIKrpaVLYxxAVCvA7QMBpNQ4DAFKWn1Wwga4UYSYUEboceT1Jv6iGkJSkjCHRdBSKrPzWYnE8wSOfibTWCAgBRoRdQocLhctj7/H+n3paN7yP5xUIVo8qkZasg+xpnEIkRlZKJpEKKzH0WrHMNDvWXXUyJRvkYmbKNBaAZL7+IUQSDgvhJJvMtGZjCjPSSNQBWmzZZKmiSjU4Kgzsf91L9V7RZQBDST39uFYd4CNOT/yWG0/Krxu+o9oJji+F8FXidhWZlP52HPUyvMoT7qK+Mltu3J58ewqAkAD9BgkIFj0SHVmtAPTEXT+yQPjmNHYd+7EfMEFNN98M6IsQ7z/oVJfXMDhH79DU1uJIjODkNoGEs8ZhSnE/xtoTWbSx52LUqNF9ngQVSrEk4bhmtdeZ+uKpdiWpnDR86+hNRrZtfIbCvfuYvTl19B3ygWIot8YSR4xjpK9O7BGRjMwPIA9W36gub6OqLQMAA4nVSH5nCi8F2La8gMVxgDKGioQBBFZllColDibm6GlhQtHmTm6dhW7KsqIHzycqF59fq0Ld9PN74p95y68p0vzkGW8lZXYd+7CMHjQv+y4ZFluH2N37dpFa2srQUFBHdo4HA7y8vLaP8fHx7cb4wARERFUV1cDfu+52+1m6NCh7csDAwNJS0vrtO/fQzxt7969KBQKRo0adUbtj3vmfi39ZNeuXRw7dqzDeYLfI3jytTgVEyZMIC4ujsTERCZPnszkyZOZPn06er3+V9ft5v85lRV+T/jpsLX620X+/kJky5cvx2g04vV68Xg8TJs2jVde6ZyKCODz+XjqqadYvHgxZWVluFwuXC5XuwBcnz59GDduHJmZmUyaNImJEycyY8YMAgIC2rfRs2fPDtEqYWFh9Op1QlBWoVAQFBTUPsaAPwz+pZde4tixY7S2tuL1ejGbzac8p5PHudNx/L7/+OOPO6wrSRIFBQVkZGScdv158+YxYcIE0tLSmDx5MlOnTv3Vybv/L3Qb5L8Bp09qLzXUzb+XPc12djXbuCoqGMVvzF/9Ja7WFvK3bABBIDghuVP5JwEBQfD/C0lK7dJo/zUCIqKoyj+G/iQBtpM59vNaqo8dJbpPf3qMGM15Q0agMfhF5USlCgSh3TA7FcagkC7D9NvPQ6dGNSAeQSmiDdAw8V0ABX5zFCZ9qEP29aa+NI8jP32HVhdHUOAUavdD3QGZhPMEJK/I0KtfITBd4uBCG/ub9fgaVICMPkxgzMsaPJKJjWuvpXZBIwRdT+DTZgqzS9lb/TqzB74IwP5/yBSvlvE5IWIoHPsKECEwHeLH6RCsF1C6dydNtfvJXZhJzR7QhcikXCSiNsnoQkVCBrhYt+9xAmOuRKFTolepuMgXyaFyActPK6iq+o7Ip56mZc9apOZawkJXEjn86hMXRK1AEROIrBAQPBJolSgTQ/DsLUF065E9PgSVAnVMDNEv+yMdhHGj8bS0oImKwuWTkJQaBEBwOPBZzNTmHsbau0eHSZGg+ETK163mwLdLCGq2Ez3vGqpyDtNaU0XcwP5U7txAa2MdDZVlRCSnMfrya8jv1YfeE87FU1hE69p1BFw6h7DUdNQ6Hfm7tvJtXhmmhJ7ERTRhifR72iK1sVTb67DmHGSnMYiXrbE8pFQyNsCEJPl4WzCj6z+OHsVH2ff1F+3q/4XbfiY4Iam9v3XTzb8Cb03N79ru9+Lw4cMkJPjFDCVJIiIignXr1nVqd7KH+pcK54IgILWlp8hdRQCcgt9DtflUYeynIjXV/zw7fPjwaUurSZJE//79O7yYHyck5NTPneOYTCZ2797NunXrWLVqFQ899BCPPPIIO3bs+H9bLqqbM8Ru/33bnSVjxozhjTfeQKVSERkZedqKBs8//zwvvvgiL730EpmZmRgMBm677Tbcbr/XQaFQ8OOPP7J582ZWrVrFK6+8wv3338+2bdvax52uxpPTjTFbt25l9uzZPProo0yaNAmLxcJnn33WpVbFcVJTU2lqaqKiouK0XnJJkrj++utZsGBBp2WxsbGnXO84/fr1o6CggJUrV/LTTz8xc+ZMxo8fz5IlS3513f91ztog37dvH99++y2BgYHMnDmzvfwGQHNzM7fddlsncYH/JW4+WMTymkaW9ksmWqPGoBTxyfB2SQ1TQ62kGbS0en08VVDBmEAz44L8M1IP5pbyaXkdl4QH8mRazK/spZszodjh4saDhRQ63cTrNIwPOvXs32lpaYFdO6FHDwgNQ2M0Edt/MEq1ppMxDmAMDOL6N9/vpNh+Noy5cj5jrpzf5TL7rl20rPgOITWRgOhY4vp3LKOlFgQGzbgMhcHQaUazKucwKq2WwNgEin+SyF8h0/92EVNM15MVipBTh73LEvx8n4TkCEVIDMJ5NJS+D3nJ+1ZB/SGIHiXQ/3b/9fHm19E7qxLrtqmUF4Yw7FsBldG/rLHQRLX6RRSbUlGPOIeIQUp2NmzA3OfE4B03UcBjk4kYIqA2S0QOkwnNEomdIHDkUwlDUiAKtRqTS0vmOYVsyoki7xsVCefKVO2SKVoFhkgN/S6cRKWhFZNDJC0ii6Ez4qje0ohPOIJ58mUIooDp3LE4C44SeOc9bHlEInqEQNI0EUEQUCQF0rphI8aRI3AeOIBz3QFUYhS4veD1gUpBa20NolqNzmgi49XX/ecvSXxRWA2IzJh3I57za7AdyCa3KJfan9diiYjqoH7vcThAocChENn39ef4fBIVhfmEXXUDM//+Jk1VlUS0pVIERccSFB2Lw+vjx9wSTIdyyPr6G6yzZtJQXkJ+cDytPmg0BjOqT6/2PjFCNxp0II1Tk2J3sXbDThQKLckjxuCWJD75+QB3RQRTldQbVfER+g4dgbO5CZVW16Euejfd/CtQnoERdzbtfg/WrFlDdnY2f/7znwH/y2RlZSVKpZL4+PjftM3k5GRUKhVbt25tf4FtaGggJyfnjL3Yxzmep+3z+U7ZJjMzE0mSWL9+fXvI+unIysqiR48ePP/888yaNatTHnljYyNWq5V+/fqxePHidnG734JSqWT8+PGMHz+ehx9+GKvVypo1a7jooot+0/a6+X/CmUZR/EHRFgaDgeTk5DNqu3HjRqZNm8Zll10G+A3a3NzcDp5kQRAYNmwYw4YN46GHHiIuLo6lS5dy++23/6bj27RpE3Fxcdx///3t3xUVFZ12nRkzZnDPPffwzDPP8OKLL3ZafvJ9f/DgwTM+/64wm83MmjWLWbNmMWPGDCZPnkx9ff0/XR3iv52zMshXrVrF+eefT0pKCi0tLTz88MN8/vnn7UqfDoeD999//3/WIN/XYuer6gYA8mxOztuVi0Wp4I6EcJ4trORgq4OpoVZ2NLaysLyOTQ2tjAsy0+z1sb/FTqsks7C8jsnBFkYFmalze1la3cBFYQEEqrqDFU5Fi9fHWyU1TAmxkGE8Mds/a18ehU4346wmlvyYR0taCNP7RrOpoYVVtc38JSEcs7KjF7mxrISa/FziBgw5YXQcy8V5IBtHQz0B0/11vn9ZPxmgubaaljp/SLBK03WejNfjYf2H7xISF0/vcZN/0/k6jx5F9/V3hM+cifPTxfjCI7BefBGy1wuyzLFJkxEUCpJ/XAUn5VI6W5o5tnENgigydN4NlKyXqdkLtdkyphgB56FD1L7xBkHXXY8us9epD+D49upkavaDQqklUUrBrY+h/ttCRj2TiLNJpLUUvA4ZpU5A0KqQBYGgDEhZ4Ddu7Y0NHFuzl9xlJnyqg8xMn4jQWEdV6F7U0SZqIwVK18tEjxIIHyQQPkiB7PLi2pjDgMkqNMNTWP6nnTj29yV2QiQRtUepO9qAImIGHq8LV4mKdbdLmC2thKdIREwykHyx/6HnOViG1GBHbdUQc2E0XHhCUdhywQVYLriAsp9lGgqqwFpKwtS+HPtSoO6117BWvYtl5kyavvwSfD4SV6xEYTDS/NMqHImx7Fn5NYd3bscYm0jojfcyNioYndeNWhQQEFCIAqrQMPRjw/AcCMFlt2FvbuaAS8aiUZOkURAaHU9Qz17IGi37Nm+k9thRSvNyObRpHWPnXU9Am7fa63bz9XN/w2ANoNeVN1KXmILnYhO6+HB2ff4holKJtc9wWmWBYaGWdmPc5/Wyd+ln2A0WinuPINpt54V7bkEZGQHnT0QtivyjVwKF9S34EKgKiaE65zAt1ZVYo2K6nIjqpps/Ev2A/ijDw/FWVXWdRy4IKMPC0A/o/4fs3+VyUVlZ2aHs2ZNPPsnUqVO54oorABg/fjxDhw7lwgsv5OmnnyYtLY3y8nK+++47LrzwwjMKMTcajVxzzTXceeedBAUFERYWxv333/+bap3HxcUhCALLly9nypQp6HQ6jMaOkS3x8fFceeWVXH311e2ibkVFRVRXVzNz5sxO2xQEgYULFzJ+/HhGjhzJfffdR3p6Oq2trXz77besWrWK9evXM3fuXJ599lmmTZvGX//6V6KjoykuLuarr77izjvv7DIn/mSWL19Ofn4+I0eOJCAggO+++w5JkroM3e+mmw6ER4DBcPqwdYPR3+7fTHJyMl9++SWbN28mICCAF154gcrKynaDfNu2baxevZqJEycSGhrKtm3bqKmp+dXQ71/bZ3FxMZ999hkDBw5kxYoVLF269LTrxMTE8OKLL3LLLbfQ3NzMFVdcQXx8PKWlpXzwwQcYjUaef/557r77boYMGcLNN9/M/PnzMRgMHD58mB9//PGUYfsn8+KLLxIREUFWVhaiKPLFF18QHh7eHRXDWZY9e+SRR7jjjjs4cOAAhYWF3HXXXVxwwQV8//33f9Tx/SHUub08U1BBgd11VuupBQGNIDAlxEKaUYcMNHl9BChEZoUHoBQEbjpUxKJyf23fVL2WXJuT3psOoBRE+hh1aESBUI3fs/pycRUP5JZxdXbBKcPYihwufGcR4va/yBeV9TxbWMmV2QU0Njfja1OzHKU0M8hsYIZSx/d7y1m0qRCAZwsq+UdpDT9s29VpW2XZe6nOOUx1zmF8nrZE5YweLMnJZuHiRVQXFbS3dbY0n2gDLHn8IT576E6qCrrOjyvK3stH9/6JvT8sZ/MXn5zx+dkaG2ioKGv/HDB7NnEffkDA7FnUvfkPqp56ipzhIzg6cBDlTz6FbWAW7rjoTmIlGqOJqN79iBs4FEEQ6HebyJAHBeIm+Y20oiWfs7TsGGu7KLv2SxqOynx/pUxwL9CFKWhSpVK4J4iCfSEotCIVm2Hj3RJ7/tqMr6YFRaQVt02B2NBA1Rb/Nas8cpCWhkMYQ+2Y7XPxeZV4fHYqGvII3BqE6a4rURXm4inwq/36XDI7noWCbRY8rf4+X+1Yhk2zkYDIfdi/W0HL2u/Ysi0fyWVEVIE2EOKz6hk4vZRoQw7u/SVIjXZUPaPQDE9B0Kho+uYbKv76V3InTKT14EEAPFXVhGfZSLA8RNC3N5N/zdU07CilwTMEMbYnvupq8PnQpKejjoum9q03KL/zTlwbNqLUaJBlmZaiPMq+X0rl4SMcGzSYoYveYHpcCOJJUQuRvfqg1uvZu3Ed2Y12ttU0UfW3v1F4ySV4d+5BERRCXq9htAyfQo8RY8gcO6nD7+BobaYoey85W39GKDjKmPAAxg/ojTI4GJ/Hjc/tZlxCFJcmhpNoPuENEEURY3AoKpMVWZap1RkJe+hBv/hcGyMDTUyJDsLobCG+rhhLfCLh6b0Iik9i39dfUJuf+6v9pJtufi8EhYKw++5t+/CLiJ62z2H33fuHCbp9//33REREEB8fz+TJk1m7di0vv/wyX3/9NYq2fQqCwHfffcfIkSO5+uqrSU1NZfbs2RQWFhIWduZl+5599llGjhzJBRdcwPjx4xk+fDj9+5/9RENUVBSPPvoo99xzD2FhYdxyyy1dtnvjjTeYMWMGN910E+np6cyfP/+0ZYoGDRrEzp07SUpKYv78+WRkZHDBBRdw8OBBXnrpJQD0ej0bNmwgNjaWiy66iIyMDK6++mocDscZecytVitfffUVY8eOJSMjgzfffJNPP/2Unj17nvV16Ob/GaII5ww/fZtzhv3hgm5nwoMPPki/fv2YNGkSo0ePJjw8nAsvvLB9udlsZsOGDUyZMoXU1FQeeOABnn/+ec4999zfvM9p06bx5z//mVtuuYWsrCw2b97Mgw8++Kvr3XTTTaxatYqysjKmT59Oeno61157LWazuV2Yrnfv3qxfv57c3FxGjBhB3759efDBB39VDO44RqORp59+mgEDBjBw4EAKCwv57rvvftOE5P8agnwWCU0Wi4Xdu3eTlHRCTfrTTz9l/vz5fPrppwwaNIjIyMjThk+BP7TdYrHQ1NT0m0Od/hleKKzkmYJKpoVa6G0yMD3USqS2o9rz6pomtja1cmNcKFalElEQuCq7gD3NdnyyxIRgC59U1Le3H2IxUO7yUOx0MynIRJJex1XRwXgkmfE7jzLMauQfPeP5qrKeSSEWQtQq9jbbOX93Dh4ZfhiQSh9Tx/CaLyvruflwMfOjg3kspeNsc4nTzQdltcyLCiZKe/ryIv/tVLs8jN5+BI29lVfK92IKDCbAdDHbHpOJnyzQ706BxTtK6BdnJT3czM6KGn7atI1bm6swXH1Nh23Z6uuozjlMxeFsDIHB9Jl2CQBfPv4AJcdyybriOkaPGUdrbTX7vlmCKSQMY3AIIcnp7Fr5DRW5R7nwrgfRmTr32+9ffY6DG9cR17svg6ZdQmyv3l2ej8/rZfPnHxESl0D6sFG8fcvVaNUaxl93CxHpHV9G6j/+GGVICGV/ug1vUAD2sSPwxsVgCAom68JZ/u21tlL3j39gHDsW/SlUamuLC8nftpmNSz4hITOL5D/dR4ZBh0rs+OIr+2TcrWCrhDW3SAT3hJp9EJgBwb389cGNUQJ1e10cXegkLLaR6LGg6RvHmqtt1BVqGP64QMRQBfZjpRRvy8Ze3Z++C0JAhG1/q8Ul7KRhfx+whTDu2hy0yRZUmdHk/LibnE91+KoSGTs/j3pNCrKhGaWhmFA5gOzNm7EFhpMYoEcR0p/gODfSkVKESCtSeSPY/RMBNWoNtYKCpMwosu/cT+DWK5FVSgSPl0N90pn62PPYV27FWXKE1tx9eI/mABB0+10ohs3DnOzDV1ZC05IlBF5xOarwcFp/3kTt668Tds/dCEolm+dfxcGYMAZc/yd6G0wUX3U1lgunEdlW1qjDb1hcxKEfl9MYk0KvocMwL1tKyYa1mKZPI3byVL4vq0OvUDA2snO4lttuY8eSj3E0NqC3BhB4wVxCtGqCtCq8LicIIsqTlOqLWh3Uuzz0CTQhCgJbcxspq3MSGqEmMVjPwQYb54RaMKpPROS0eLwsLarBqlZyQWwIP23ajO7IHoKT00gZMYLa2g3o9XEYjWevldDN/x5/9PO7edUqqp54soPAmzI8nLD77v2Xljzrpptu/sPJz/errZ88uWQw+o3xf1HJs266+b04qzhpjUZDY2Njh+/mzJmDKIrMnj37tIIB/0lcEh5IqdONCDyWV06+3UmQSsnuZhv3JkaQadQx94DfU/paSQ3DA4x8npXMUZuTSrffO7uloQUF4AMEYGvTiQHBKck8lHxCdfvQsF6oRYHXi6v5W34F25ttvJwRR5ZZz4vpseTaXfQydhZeCVQp/R51dedc5X+UVPNOaS1uWebR5F9XkXylqIo6j5eHkiI7ePD+GwjVqHgvM4F1X36N6HJhK1UTNgTUZjDFgkIUuHSwPxfPZbeTJLsJlJrw9s3qtC1DYBCRmVnU5Od0KBs2eu7V3HCggKcI4tPaJhblVjBHVKKVJCoOZeO22xhx+TVsamhF1huQZZlPK+vpYdCR1eaZDI2KwZXZh8EXzyY8/dSz/JV5uWz/egnGwCDSh40iKiUNi9FIye7tnQzywLlzARA//YRdWzeiVIk0q/X0Gnxidrjlhx+oe/sdHNkHiFvkrwPpdTlRqNTtoceLH70Xp62Vi+97jNXWcCbuzOG66BD+mtKx72x/WqZktcyoF0SmLRMRfS5a99SjkVpQD4hDNPlD9Y3NhfSb7DeAW4rMeCNkHHYtCjXorF5c63JpyNcQHxHNvh0KnA0yumARQ0QQZYsnInlh8P0ChoEJCEYtjuYmaoq3YD1HJLjaiL1Rxfb3RQTRyvAbHTTa7BR/dxEhGS4i7pJRRKjwFjUj291Q3eI3xtUKRKueVruMZ9PP1B8zUFU8HqVhMkLfBo401SMmxpHvU5I7Zhg9DlhIuGcB9t27KT+cz1vWTEZoaxC/r0Vh0XDOXXe2Xxfj8GEYhw8DwHHgIJHNDlLDk4ge41eTT928CdFkwivJKNsmOTxeCZVSJDA2jn4Xz0EQFehMBqRL53DY3cQPzQ6EY2X8JSW6wz3p83rIXb8anTXAL8rn8RAQHol+8Gi21DShd9k5L9zSZSm/bTXN2Lw+IvUadAoFSgUoBIGMACOrq+qx+yR21DUzJuKE8a8QBBSyDA4bkhREbVg8SoWGPpkZOBylNDdn43RWdhvk3fxLME+ciGncOL/qek0NypAQ9AP6/0tLnXXTTTf/BSQm+kubVVb4Bdz0en+Yere3tZv/Qs7KIM/KymLt2rWdQqtmzZqFJElceeWVv+vB/VHEaNW8kB5Lrs1Js09iZICJ6w/5BQ/O232M8JO8RxJg8/mVCxf1iudPR4rJs7kodHqQAZUg4PlFkEGly0Ohw0W8ToPN66PY6SbDqGN8sJlPKuoJVJ7Y/ozwQHJtTm49XMz1MSEdvORjgswUjeq6/NC8qGCqXB5sXh/P5FcwKtDEYGvXqsiyLPN0QQVeGa6JDiHmX+BRdxcWoggORmE8c6XmnU02wjSqLo9viNVI0Ptv4a6u4VjIckJT6pj2dUeDxNbYwLt/mk94dCxRiUlItmZO1jC3+yS0ooDGYGTQpSfUtfN2bWPlqy9gnjYPlcdFzvffsDehLxsShrClXyLOI9kExiXwyA9reFsTxJWRQUwLDeD2IyUk6TRsGuLP9UkbOY7wlHRCU05fvzUyJY0Rl84jONZfKmvSzX8hf8sGDIHBXbb3uF2s/uFr8LgJSe9FQnAQR9f8QI9JUzEEhdAYEYLyhvmEjPALArVUVbJ/xVeYwyJwNDUSFJ9ExojRNFVVEpXRg+RWN0GqOlINnfPglRoQFDK1RUexpsXj2ZyHxtumDtzihDaDXAw04HN4kDwyFXtUqOwy9iqIGAa65jKObTBxaG045lAHLTValB9C/z9D5rUiMWNkqvfIRI0UENX+/q41mvyh9j4ddVsjUA+UiTgKFVvhyMYQes+yM27e6+jMLbj3nAsNMahTwlAZNSCDZ38JuLwIejXJGYEcu+FpHD4fY94bhFp3D3KUQD+rBbm+gR/2HKYuOY0cs0Tt6pUExifyVsQQvtpdxmFZYJ5WS5PX235NfF4PB7//FrVeT/rYyeh69SRly2bEkwRjFBYLtU43K4prCPM6SA6IILuolb6JZiJaK3Bt3461TahIVChIHT2Bq0rsNJfVMTkiiEyT3l86xOfD1dJCXWEeKp2OiAtnkzxiLOawCESjmfxDOYiFOdS5wro0yJO+/IxGpQrNZbNY2uhCI4pcMjAMhSiQ6tFztMlOT2tH5Wa9UkHq7p9wt7bQYpnOtPgwfHGhGFVKZDme4OBRaLVnV9bvTJElifwtG1DpDcT2HfiH7KOb/z4EheJfWtqsm266+S9FFP+Q0mbddPOv5qwM8htvvJENGzZ0uWzOnDkAvPXWW//8Uf2LiNOpeSo1mj8dLm7/TgQavR1D7s+xGrn3aAmLyusYG2jk2b5J/CWnlFybi8khFr6qakDEb7wbFSJH7S7+fLiYpf1SmLkvj13Ndj7KTCBJryXf4eLdsloeOckz+WVVA19VNWBUiPRJ01Pt8jBldw5ZJj3v9Ero8tiT9Vp8MnzUFjb/Q10Tqwd2NAS3NLZyxf58poVaGWo1Uu70YFaILK6oZ7DVQLxO87tcx1/iyM6mcOYs9P37E/fRhx2WNXm8+ACXJBGgVLaXjzvY6mDq7lyi8XHT128xZOqFhKdmEBgb375u3McfsemVryjJWYlr0Ubier2Au7SU8jvuJPjmm9GcOwmtTkdUYhIycLUilLsr6xirU1Cu0jJ+Rw7DAoy83iOOcpuTnbXNDA6x0FJdzdr0gbhkgRs/fp6MieeydlA6Lp/EsupGouMySCs6TNnGn9CPnIZCgN4mHTPCAugtejn4w7fE9huMKSQUQ1DXRvXJCKLIoGkz2j8rlEpSRow9ZfuKnCMc270DvdlM2jkjqMvz5/a6bK2ICgVlh7MRA42ktE2UVR49BLKMvaEer8tJbcExUvr2JzA6HpVaw6hADQeH+0XdnK2t5Gz9mdShw9EajPT/i4iYsIz6mgoqjwwmLCyM8h1KTD0NBEWeCE9VRAXgK2lAUqgQQixog2UsiZByMTirBFpq1YBMc7UOpR7cTTIb7vRxzl9FrEkC2tAWZDSAhuwJE/BVVhL03ttED+xHVF/I3bGFYsfPxI27mr7zA9CHBeCollCqZI5U5dJSvhv3wosZ/azfKBVHpuKrbEIMNCLVtRJ0/fXUHNyP0FSJokkDzWp8iiZaSncR++LfsVx9NUqDwL4N6/B4Pdz45DsEGdTMOSeOta02poYG4Gtp4cjHyyjsPRqdQ8TQeCLP/+SJppaaKrwuJ76gcCRZprWhHp/GiD92Rqbyr49h37oV0WDAN3Ey35XWkmQK5dkeMkU2F3WtTooEAc+erVQfO0LmedPJmHgePo+HnYvfxxIZTViqf9JnYkocdSovwYlde6s1h/cQUlGF6uJpWNX+KhCKNo993yAzfU9RiSC270Baa6sxBoeiOEkIURAUWK1/jIgW+Ptw5ZGDiApFt0HeTTfddNNNN938v+SsDPLp06czffr0Uy6fM2dOu2H+n4Zbkrj2QCFGhcjrPeMBuDK7gE0NrfRrCzkeF2jiufQYNtS38KcjJQDEaFVUuNwsqWoEYHV9K6vr/QaRUgBBlnmnRxy3HSmmVZLJNOrY0mTD2qaanmNzAlDm8mBUKhCBAW37299ip8btZX50CHqFyIywAABeLKyk1Omh2dvCD7VN/PVYOX9LiWLMSS/TeXYnR20OojUq+hh1zIjonH/6QmElLT6JjyrqsShFWrwSnx7J55FaO8OU8FBWKovKarktLox19S24JZn5MacvKVPp8rCorJa5kUGn9LQrAgJQhoaiPklrAMAryYzcfoRWn4TTJzEy0MSnffxtIjUqBpoNBBXn4LHbaCjKp6WsGMvf3yLwiisIve1PqGNiiLt8FAvK7PQ8oiblpRcw9uqJt7oax6GDFIQG8vW8e2iqKybSaiXH6eHjA0doqMilx4gxyMjYfT6GbD3EYL2OIQYdNxwuJjAig01afym6Bc+8ycgw/7U84nbwSF45BoXIsh5pfDduJggCiysbeCI1hld7xJG/dSMVpcUYg4IxhYTyRxDdoxejr5hPWEISSoVIU3kZsf0HExTnz5FKGDIcjeFE+L0+oK0vCAIqrQ6P00Hxzm00FBfR+/yLO2x761efsWvFMhqqKxl16Txs9bXYGyoQRJHghGRcLRZ2fCQhKGD4kzLhA/3GnRhgQNkvDnl3MQlxBWRvtTPwXA2lK6NpccRSlg195ks05EPsGL9Ym6tJYNsjLjKus3F4/WIMgUFkXTiLIp+WhoAEBtbVtR9X/vbdKPbdRDlaYoZAbBgU5F2O3OpCTvoZBJnAiFbA318FpQJldCCew+X4Cuswjr2AY2YVQlMByb2GIlU0UdlcSmlzNZGzZ5A+eSKqmBjCTfGEaILR65Tcf14PABIDDMiSROMPa6krLMedpSYmaxip4Z0nsCSXi6ILL0JWiCR8/TUTFXZkq4bopHAS4iTUSpHm2bNRWK3oBw+mXpLwSDI2r49pkUHkNdvZUNWIwyeRJPmQZRlZkgiMicfe2IAgih3K66m0OsLTTyjke91uSnZvJyA2Dp3ZStM5AxEEEX10JNPOIjUlLDWj3ej/V6I1mUkbOwnlKaoWdNNNN91000033fyvc9a1tr744guWLVuGx+Nh/PjxXHfddX/Ecf3uNLh9/FTXjAQ4pAIWZibgliQEYHtb/rdBISLLUOP2MjLAyPSwAOZEBPHosTIEYFqohWXVTe3bTNNr+LK6kT1tJc2CVQo+7J3Ae6V1rKxt5N6cUq6JDua14hr+XlTFI8mRSG37c/gkLt5zjBafxGsZsRy1Ofm2ppG5EUH8WNcMgFWpYGeTjTyHi13NdsYEmTnc6uDFoioyRJk8hz+Ht9Tl4bw2Y97m9XFfbilHWp3Y2sT1ojUqXu8Rh1uSuX3HAYJtds4tzmFhcCCfVdYTqlLx9+IqAC4MsxLSRc660yfxdmkNX1U1cNjmpNHr46nUrsuaqKOjSVm/rv2zJMvIgCj4r3GL1x86LskyyRv285f4cG6MDeXrnjF40yIoSwin4dhRRJudv0+dSYNHzWubt1CnkMjft5vRgbHc8N6riG43tvIyUj77lD0H9rBu4T/Yd+U95Jqj2De4F+b6Zm44WMDGqN7sNRm4PFLBO6W1CMAOu5N5sSEcKq/B4la0+TIh1nAilz9Vr+Uv8WHoRZHNDi/xagUGtZobY08Y3jFZA9FbAwhOTDnjvnicZqcHk0bZqZb4LxFFBf3Pm9b+OTytR4flkT37/OJzbw5sXIMKEWuABY/TgSUyuoMh136OQ4axtcnG5RFZ3JhfwT3xYdh2zcJVZUAYK2GIguA+ULsPji6WCB94wnuqCDXhCzFRd8ROQEopOkMK0f1ttGoCcTd6aN1fT/G2EKhu5JwrmnHVytQ4Sqje0w+13oBaa8VeJfPomFupsXn4qd9IwF9Lvcew0Wz52ouITEiW//qkzzfjq2pGMJyLu6IBbY8T/a+5ppqKYznEyWHICCgDAki2hFH36qs477ZgGjUWTa4E246hmzIedZw/XSAqJgWpqhnZ6QHzid/+0A/Laa4uITlMQ7K6lojkHl3+Tj6XA4XDiaRUsqSihWFR0aRY9GCzod63F9LTMU+ehHmyXz09DLgkPhRtWz5svFGHS5KI0GmwRo0jccjwduPU63ISltYDQ2Aw2cu/ImnYKPQBQe37tnt9HDx8GPfBfbTUVBE2fipSYhpxVsuv9qmT8TY0IKhUp00vOa79KQObqhpRiALnhFrPeB+nIzjht9cz7aabbrrppptuuvlv56wM8rfeeosbbriBlJQUtFotX375JQUFBTz55JN/1PH9Uzh8EuvqmnmjtIZKlwcJf0h6s9fHj7VNbGr0G+ICYFGKrKtvod+WQ+hEAYckc3FYAFUuD2pB4IcBqfQ26bk22sbWxha+rGyg3OXPMy1oM4xviwujxu3jiYIKALJbHMj4hd/UgsDkIAvnWA0YRBGNKJCg07C/1cGq2ia+rmlia2Mr4zUWyh0eRAEGW43ckRDO8AAT57Tlhy+pauCb6kZ2KAWmblnHoZQM8oPDcLbluX9aWc/iSn+t9IFmPTjcyECwWoWMTJlaR6CgYO3Qkeh8PlSCwGCLgXGBJqI06g7G+NP5FXxd3cj5oVb+XlTVfl2mBluYF+U3DHY12ShwuJgR3tlDD+CTZUZvP4JDktgwKINhASY+LK9jQWwoKQYt6xtaKXa68VRWkn/+BWhSUoh4/TXKd24BQWDlyHG4RJHdufvY/92XFE+aQXpFIY4RQzCs2YBm5152rfuR9Xt28MX06xiqgmf7p3HA5mBikJnJIVaUgkBgYBCuwkN+D6QgMMCs57WSGmTg4rAADAqRzyrrOWpzkt4msCcKAncmRHDZ/nx+qmvmpppcZoVYWOUK4JOKOmaHBpK3VE1gek+U6hMGUJPHi+VX6spvyavjsne3MXNADNdFNVGTn0uvc6eht/qvo8/rpTr3CAHRsWi7UHQ/HR63iwMb1oIsc+3f30byegiIjj3xm3jciAolgigSmZpBv8BI3NkF1Lm9fhE4dwA9hpXBoSa8TVaG3xvIsZ90RAz2n+O2xyXs1TK9rxfY+Gg0wb0hfmQtrToPQedEEaAUiMryUv11K/WlRtRGL2W5RlRRG2h2teDa05+sKcPI+cnEj695GNQzipZYO5FWXXstdVmWKQ1axfS/PIEuuBf7v/+OLUs+ZfL8W4lLGYQyMqD9fFxNMt/fUkKtcwMjL0gjITSNXc8JpCdXQ1k5ebty6Dl2POG9MgnN6IHYZgx7XU6kJCsOkxdNiKnDNZRlCVRKLFfOxtFYj8/jRqk+4SEvsznZcuQr9E2ryVryIvW1JoLX/YT3kosBPRw9Atn7wemEseNoKC1GVCiwRERhPKlvKESBHidpP5zsKS7ZvYPG8hKMwaG01lbTWF5GARqCtCrCdRoONto4qAkgJaUX8WmpXHWkhE0E80FMAid+7dPjbWggb/wEFBYLyWtWd9lGcjjIP/8CBK2GyK+WktfiQAAGBVvaBezOBq9PoqbVRYSls5BlN91000033XTTzf83zsogf+WVV7j//vt57LHHAFi0aBG33nrrf6xB/nR+OW+W1qIAVKJAsFLB2CAzV0UH832N39N93DOaoNWwt9UBQJJOwwGbk+wWBy8XVZPncFHm8vBqjziMSpEn8iuR2vYx2GKgxefDpBC5JjqEZq+PHgYth21OvCcdy9d9k1ErRBb3SWZrYyteWWZ6qJX9rQ42N9p4vUccCToNYS1q7n0nhUCryNw3/C+sowJPGAs3xoSyrKqBMpeH/aPGs3VACrWIBKuVPJBbCjJMDbGQqNNwbUwIc/flk93qYGtTK5dGBLF+cDp3HClhdZONVJx4ZZlDNger61tI+kVO+e5mO/kOF1Uu/4TDVVEh9DbpuLDNG2/3SVy89xhOSSbFoO1Utg1AlqHVJ+GSJCRZ5ubYUCxKBVdHhxCuUZFl0pOg0yBXVYIkgc+HXFiI6bOlKI0mou8dS77dBdt2M6jFjZiSxlMeDZk9BnPrkNH0rKug1KDBqdFTYwlC3WrnlS+X8XF0Gn+OC+Pdk3LwL60vwvLBewSMmsgKxQB2+USsSgUXhFrZ3+Kg2u3lo6J6DO8aiE1WUjPBxvvldYwNNOFzu8iqdFBniOXx/AoUAowtCyD7LRljjMy5H/iNvJU1jVx9oJBbYkO5P+nUQliCAArZh7Z4Ly1qAx67HY/DAVb/8uqcQ+Rv2UhQfCLp405fj7Jgz04OrPuJUZdfjTk4FLVWx9Q/3YXk82EJj+Dnzz6guiCP/pPOo/roQTwuF5aIKHpOOh+AicEWdg3tQVjbZMzYV0Q8+XqobEUqa0RosJMxN619f5U7ZDwtYCsHTytUbIaY0cMIGiG0e2ZFq57wK5MJu0xixWwNjlqRzFvHIyqqkAPzkJsVRKR6SOhbw5B6DaVVevZdMQd3+BXIQVn4gncjiiJai/+Yqg8fobWlgZqDOcT9QuypcruMUJ2FVRVA0CAd6x+1oDd7MPYYyaGne1MXmkBkq4cwq6bdGHe2NLPnq08RRBGf200q4wlOTm0//oyR42lYuozavbsoLcglPCOTpHNGtu/T7pOQJTcg07R+NZaddSStXk14kAlmzYS0dL8xnpaOx+Hg0A/fIggiAy+/lvU1zahFkZHhbVEt9XVkHzxIWGIyCVEn+kxs/0HYDGYOWiNJjHOwWRdCS20zRqWIRa0iWKsiOcBMWvwQzFoN413V2HwS6V2I9Z2yH6pUiBYziqCgU7aRfRJSaysyULD2BwZEJxKSmPybjHGA+5Zm8/nOUhbOG8iY9D8mzaObbrrppptuuunmv4WzMsjz8/O56qqr2j9ffvnlXHfddVRWVhIeHv67H9w/y3Fvr1mp4IcBqRyxObkiu4AjNifFTr+R+VRKNA8eK203xpUCfNIniW9qGtEKIu+U1QL+UOsmjxedKGJSiASolDh8PuxeH/l2J2alklafhEWlZM2gdI7YHLxWVM1XVQ0MtBgIa8u3frmoimcLK1kQG9quzm5UilzUZuRihqtf0KPqKITcTrBayfzoEF4rruaBlChktZr1lfUk6rS8U+o/1rd7xHF+WAAP55ZhUoq8lBbDjLa86GS9likhFrY22TAIAluGZBCpUWGXJAaYO+70rZ5xFDjcZJn13JcYSaimYyh7vt2JU5LRigKp+q6NAKUo8POgdL/gnVKBUanggZMM1ZTjxkNEBCkb1iOo1aBUEjV7DvUffUxi7lFaYxPR7N5NmAh/HjGUnfvyWF3fwg6zCbO7nsT0Xig1GqZq3Uh338GBxBRCb8kgUafh4/I6JgVbcEgS29P6MyF0DZqPPqXmKh2HY3rS6PWnKMyLCsbm8/HhlkYaflRg3ynzfa96vqlupI9Jz6cDMmBABu+W1jC+rpnpYQGEBAikzICgnicMEwH/37UeLy5JYleTnV4mHWZlx5I9QxKDeH+oly2ffkGTYQI6swVT2Il7KCA6DkdcBbqkXy81te+nleTt3EZMz95kTZwCQNrQEe3LD/+8juaaasKiYsDjQhBE/yzUSZxcy16pE1D2DEZOD8R7uBzB0nGiZfwbIh4bWJMFbJU+yjaBLacVp7cYZVIwqlT/eRz9XEIbAL0m1dFQrCRunJnGDRI+l49vVr1PxpixJGnj0QSLiDv+jnXvAWoC3qRa9w0T3z2HUddcj1Ktxi258c1OYMCoK+iXPo1fEjEElDpQq+IISxcZ+1A5cnkDYqCFrMEpNNg8hFpOnJ/H5cR+MJv+LolyvRpHSCjGPDee5mLU/f2h7I2LP6fm2WfRT5yAcfxIAmPiOuwzxazHpO5Pzb0votTkYfzTn/D5vOiHDPY3MBj8tVABpSwTlt4TUaGk6lgODU1OnMGRSLKMKAhUFBVwOCyJIzaJWFlG0TYpYAoNxyNrcTXbqdEE0OLyEKRWolcpKLG5cPkkDLrtfF2Vw4URc7kxNrRDOsWZoDAaSV69+rQh7gqjgaRVP9BUU8XhdavQ21sJ69njlO1/jUCDBrVSxKT1P37ybEdp9jSSZRl0VqH23XTTTTfddNNNN/8LnJVB7nA4MJ6UZ6hQKNBoNNjt9t/9wH4Pro0JodrtJdOkI1anwaxUcHFYAKMDTXxcXsvWJjuHWu0EqpRUur0k6dQ8kxZDqEbFtdEhlDvdWJQiTV6J98vrqHJ7mBBkZkKQmWKnm+3Nbqo8/jxtp8dLtduDqc3wSjfouCk2lK1NNsaeJMbW16wnQaemv8XAuEAz54VY6dsm8pZrczJp51GUgsCizAR6efWdDDmAG2JDuSE2lAqXm54/Z9PolQhTn2h33aEizq9pZGVtEx4ZHkiK7ODNmhUeSK7dxVeVDUzZmcOmIemMDjBR5fZyf04pdySE81NdM6MCTCdqbGs655X3Mul5KS0Gg1KBTiHikWR+bmhhqNXYrp4OYOjiHLpCNJyYEDCOG0f1iy/x8Cdvk/TdChxvvkZ1Ux2l+3Zx49HDRGgCSNKrEUQFlblH2L3yW7QTZCxTzmOovZFrh2dy46FCvqlu4t3SGo7anPiAd/Znk1RZyRhHC+cnBXNIZWByW+jtVVHB7OvloPWGFsb0tJCVEE4fk465EX7voUuSuD/Xr7T9eKQZhUYg6+aOBsTkEAtPp0ZzV04pxQ4XmxptnB9i4X57BcaQ0A75sslZfSnevQ2FSo3k84Ek+3MqgDxRzRWKMPrUelgW3IJab2ivKf5LRl9+LbG9+tBz9Lgul19076MU7d/D+g/eITqtBxfd/1dExa/f+oJCRNWrs06AIcJ/zrIsk3GZgvBBMgee9ZGYKIPbh9NRR+mxbynZ34vGbVmce3s9IaESFevM2FYnoA8X6TvjQqqPHKAiw0J8ZjJpUTeT62olccY8eieLWBIEwG9EN3hqKXQdwxRqQdRrcNlsKFQq1n6xHp+zhrFzpzP1cy0IIKoEtL2joLe/ioEaMOs7nuuxLZsod1mJDUomOUyL3Gcg7s3HOHmWwjhmNPadOwmYNYu4YcO6vD7hfTKRJ11I4+ef05S9j4ohWdiPZtMjrqPxLggCycNG42xuYtcXHxEpimTMuaa99nhsRi8iC8sxmM3txvhxhoZa6BVgRKMQqXW6WVfRQJ3by6BgMzEGLVsa3UiyhE/uWBnibDgTI1hhNhNoNpMmCidEA7vgeK75L7dZ7iyh1lmL1ZvKBX0iuXtyWnubDXU/4JZcxOoTCFJ3e8y76aabbrrpppv/X5y1qNs777zTwSj3er0sWrSI4OAT5Z4WLFjw+xzdP4FPlnn0WDkBKgUzwgNx+CReLKrivBALU0KsfFHpLxfmkmH30B7saLaTZdajOcnoidSq2Ty4B2vqm3i5qJo+Jj1/OVravjxOq6LE6c9NHx9oIkar5oHcUtINOi6LDCLf7qLE6ea14mquigzCpFIyNsjMlqAT3qUBlhNG6Jq6ZuySDMhcvDePPiY93w/we0j3t9h5pqCS2+LC2td5LK+CxrYa0b0MeoZZFayqbUYUYXOjDZ/s9/jfcqiYzUNOKChbVEpujQ3lw/I6bBJM2plDsdNDkEpBnceHV5Z5v7yO6aFW3mhTpD8V75TVcqjVQbI+je9rm3i6oJKbYkK5O9xEQ2kxoclpiMoz72Z777mP6gOHCH7jDXqtWI5M20t+YgKlX2wCQUCQZS6226jYW4Cvrf5kVI9M7koagCcRvl32Aa8eK+ObNgE+hSDgAwTJx9b4CNZfcxN/vvBcPAd2k1VTBUGTQaPBolKyMDMBMo8fjYZ5UcE8V1BJf7OBySEWHtX7KC8qwHWwBkZP6HDskixR7aogRW8mWKWkj8lAldtLouzhmdI6phYXMzk2gcayYiwR0Wh1OmY88Bg+r4eS3TupLTjWXsPcqlQQrlERK3vYufgDQlMzTlkazRoeQb9zLwBgW2MrERoVsSelHwRFxaDW6ches4qQxGQUqn++Dr0nuxRfRRPqoUlYUzSET7bQaNET1kNNVf6PoKsncuoO0of1wOFWcnhFCAGDFDQcVOCohB5XJdNUVowpJAzfoQrEeic9Hn4aX6AGsLH+o89JGTSUyNQMwjSRDPGOwH60hDpfAUfX/oDWaKa5qZVwjYddeyqI9SYQcpK2nez1pz8IXUwkqcITaG40kB8QQUr/MASFAs24DFCIeLwSR8tsRIREE/PG66c+/5ZWHDvyME2cjqe0BP3w4VCa789FaGgArRZ0HXOkNSYzUb37odLpCDwpIqFCKsPj+5ngomjkiLEdjFlRlrGo/fdPtEFLr0AjrR4fsWqR7w4exeBL4LK+k9ApOqeL/BEcn1CSZbmT0e3xSvy0vw6tSmRMZscQ+LU1K2j1tWCuVvDkd5UsuXEoqWH+VJwRgRNo8jYQqDp9hYduuvlf4ZFHHmHZsmXs3bv3d9/26NGjycrK4qWXXjplm/j4eG677TZuu+22333//2n8fzrXbv69rFu3jjFjxtDQ0IDVav13H84pOZPxZ968eTQ2NrJs2bJ/2XH9f+esDPLY2FjefvvtDt+Fh4fz4Ycnak0LgvBvNcg3NbTQ4PHRz6znvbJaVILAALOBPx0uptrjZU1dM72MOiI1akZYjaysbaLV5+tU71uSZVySzNfVDVhVSjYO9hu0R21O1tY10eSTqfX4kIB+Jj1zI4NZUdPEO6W1BKuUXBYZhLfNW9Tk9fFKcTX3nSan+JjdycN55ZgVIi9nxHJfbhnJ+hNG1fLqRn6qa2Z/i50rI4P4S0IEl4QF0OzxcnVUMFUeL/ua7dwWH8as8ECWVTewrclGdoudFEPnck0xWjW9jVpk/PmwALPDAwlUqxgbYCLP7uKCNhXlVbVN/KOkhrsSwulvNnTwtmeadNh8PgJVSgaYDaToNQy2GijYtom6wjxkSSKiR2an/UtOJ1VPPYUuMxPrxf5SXCVlFaxrtDE2P5d1eUUkO5sou+02Wm9ZQOaN1xM3cChqnR6N0YzHaUN36CAHNqwltkdPLrjjft47VIb34AE0P/1IwuQp6A2hWL1uZgWH4vT5ULpdXH7jzaT1G0j59h0U/7we0WLE2dKMUXPCGMizO1lR3cicyCCOtDp5pbiaBJ2aySEWUmJjeNIuYgy1cGdb+1eLqghSK0nRHGZX8xbMR+HAJP/Sh5IjeTS3lK8CYtBZNPQ+sJeinVuxRsXQWFZCSHIaERm9qDycTV2Rvt0gj9Kq2X1OT5oqyzl0UIFa9+sGV3aLnWl7jpGs1/Dz4I4lrEyBwVz57Kvtn90OO0U7thCckEzASeHY9SWFuFpbicjorMh+MrLLCz4JfBKCIJBysQBo+KS8jq22WG6WmgiLzqSldRtHyw+ReMlAoiYMIna8jMoIuuAoBsy8HABfRROolXy76O+U5Bygz4Tz2ff1VqoL87nkgb/hbpbJW5AFyhTCHziKSqVBjQq7OJzVDY3MLItj82sSsWMlBt7kQgwy4t6Wj9ziRD0iBfEX/T85PRFtnROTTgFtOeWCUoGvtZUyu4LcCjsVuw+gjtOzLyicG2NCUf0iX7pi+y5C3YG4PB5i33sPgACPB7GlBb5YDBYrzJrdYR1BEIgfOLT9c53TTf2hfeR5sikLq0MobCLZM/yEeNw7E6ChEG7eBnq/VzqrTU+iurERu8GKx+NCIWtpsnmwGDpPPvwR1Le4+flwAwlhejLjTuhbSDJ4fTJuoWM+xOaGVna2JDNAaQeXmWt7VlPpcZIoGVGKAslGf191+7zMXv4Moijy2Xl3ohTPLLKmm27+WebNm8f777/f6ftJkybx/fff/1PbFgSBpUuXcuGFF/5T2/lP5b/FCDkVjzzyCI8++igAoigSGRnJpEmTePLJJwkJ6Z4k7KYjJ48VSqWSmJgYLrroovY+1E3X/K+Pg78HZ2WQFxYW/kGH8ftx2f58HJLMtiEZvNMzHrNSwd/yy6n2eAlVKXkyNZr3y+v4rLK+XdDtYIuDWreXKbtyiNSouDAsgO9qGtnZZMcuSYjABSEWlKLIlBAry6obidSoaPH6w0THBpm46kABWlHgrvhwBlgM3HSoiN1t5dS0okC/X+Th2nw+bj5URLpBxz2JEURq1ISqlQjAyEAzu8+xArC/2cZLRdWcF2Kmv0nPrhY7zxVWcXt8OGOCzO21yTM2ZtPQdjxNXh/LqhsocXpY2jeZodbO5YxcksxRuwufLLNpcAaz9+bxU30LPw1Io8LlJkZ3woP3bU0jmxpbmb7nGOeGWDoIpb2YfkLPOUyjap+4qE9Jo87p5GWXgquOHkYqLSJx6AjUer9333ngAI2fLca28WesF1+Mfdcubt20n62zrqJy9qU8MHwA8vp17OjRm7t6DmXS6q28P/GcDuegMZrR6fVU5edy/fYD7EeLNTIapeTDsXUbqmHjqFSoeKCwmgyDlrUj+wJwuNXBxFYlWfoo7irKwRh84qF7oMXO5F05eGWodHu5Iz6cGS0VxBRU4O2fQrOowolAndJ/fYocLv7WJvK2upcJqclF7e5CvGM9NJYWUZa9lzn9z6E1Moj50SGYWurRBwZhiYzG3tiAISgYY0gYCYOHo7MG4LLb2LT4IxL7DSS+Tz8s4ZEMufL6Dt7IFdWNXHuwkASdmo2DM9rDnKO1agZbDPQzn954/3BrEUf27mOKqgSXrbWDQZ6z9kd8HjfmsAgMgacW+lL1jQWPD0Hb0QhcWFZLdquTab0nkRZkpvmIv+KAqPEbaeb4zuHRiggLiggLvhUSPo+H/M/CiHS8QWpCub+BAEqtEqVWR3RkGlFiJJ6qRhJjPUi9E/A6RcrSJUKCa3Bvr0M9JBHZ7vIrCrq90MWEVJCkIe8zGdVUGX2oQN2771L97HMEP/0swc0iPl8tvj02UjQBFMbHkjL8RN/zeT2UFB6kRRtI5ODBJ85DpfJ7xS1WCD39i1y9y8M3JbWoRRMJh930jOhDXGZqByV3nI3gsYPP3Wn9UKuVibKAQR3A1qON1LV4GNkzAJNeid3rw9pFZMDvhccn45PA5ZHav/NKXtRKBZP6BiMKQNVBOPQNDL2J5TUtfFoVTER8GBe497ErJY48h4cEh4uYkwTo9lbnc6i+BLWoxCv5cHrdfF+4mwlxWVg0pxDV6OZ/EtknU5MNzjoZbZBASCYIij9WX2Dy5MksXLiww3caTeex4zgejweV6l8zCQbgdrtRq//56KZuOtOzZ09++uknfD4fe/bs4ZprrqGsrIyVK1d2auvz+RAEAfEUKWR/JH9En/tv71eyLNNcZ8ft9KLWKjEH6f9wLZLjY4XH42Hjxo1ce+212Gw2Zs2a9Yfut5v/bX7XEaWuru60YVL/Cm6JDeOKyCCiNGqmhlrJNOnItTkRAJ1CJN2g46qoYK6PDuGBxAgWxIayckAqrT4fFS4PO5tt3JNTyjG7C4ckkaxTIwHvtYm7HW4Tf3NLEi0+iWiNiiqXGwXglGRafD7idGp+qG2i1OVmqEWPU5I52uqiwunm66oGat1eFlfU831tM5+U1+LwSSgBjyRT7/HR2mZY/72wiom7cvmutombD5ewq8VOqErJTTEhyPiNx78eK6fY7mJckJl+Jj1GUeDD8jpcPpkHEiPobdTR4PF2uk5ahcjXfVP4um8KIWoVjV4vBXYXdx4tYfruXD6tqOfuHH94/kNJkdyTEI5KAO0ZPoQCYxN4N7YPCxvdFB7Mpq4wj6qcI+xdupjq3CPo+vcn/OGHUN/1Z4p2bkFWqxiVvYuM5gZyHR52fP4lpnHj6PPWm5jsNgLW/IQrv6B9+/kF+bz9wF18tGkLFcmZ/IgWUZI4X+Xl0H0Pcc+QsTSrtEgKJbEKgbkRgTTXVvPebdez6+sliAqR6tg41vboxa6qaj6pqGPo1kOM35mDiECwSsmoQBMDth5is1NC+cNXtNbVcmFYAFuHZPC35Cj2NNtRCAKPJEXyUnos6cF9mG6chfWCO7n8UDEHioppranC2FjLs2kxpBq0WMIj6Tt9NtG9+zFw9pVE9cpCEAQie/UhIDqW/D072fP9t2xZ8mn7uf7y4VLh8iADJU43LumENzJApeTrfik8nBx12t9m9eEqPi8SsEf3JGHw8A7L4gYOJTIzC701oMP3m7/4hO1fLzlxTAqR1i0/kzN8BE3ffkvO1p8pO3qYlzNieTE9hjFtntzo2Az6hA8lUHlq476pQMbnkpl+14OYQsIQtI0odTKRPf356yqdxORnGhlzRT6+7HIUsYE4vTIttWpqC45hTRYY94aCmHEiglWPoNcgmHSgEDpNGBwn5wuZwx/KHF3cVl9b8huXS8uruMmoQ+W1YTEYOdfWQFJRfod1FUoV0X36oU+OwZoU33HDOh3Mmo08eiz1JYW4HSf0NSSfj9wNqynZuxOdQiRArSRUqyJt9ESahD6sdqmpdpxkfF+3Dm7LBlPXgplRARasBj0BRhUGjQKtSsHqinqWFtdQ5XCd8nr/s4RZNUzqG0y/RDM+SabJ3cSHJa+xvOpz1EoRpUKENX+D9U8h7f2UyyNcPJcawU0xoUT36Ueaz0ZPk4aIk9IqJFnC5vUfs1vy8lXuFt7OXsUDmz7i9b3f/WHn0s1/HqUbZFbMkVj/Z4ltf5NZ/2eJFXMkSjfIv77yP4FGoyE8PLzDv4CAE+OgIAi8+eabTJs2DYPBwN/+9jeSk5N57rnnOmznwIEDiKJIXl4e8fHxAEyfPt0fIdP2+Tgffvgh8fHxWCwWZs+eTUtLS/uy0aNHc8stt3D77bcTHBzMhAn+FKn169czaNAgNBoNERER3HPPPXi9HZ/xXq+XW265BavVSlBQEA888EC7vkNXvPDCC2RmZmIwGIiJieGmm26itbW1fXlRURHnn38+AQEBGAwGevbsyXfffUdhYSFjxowBICAgAEEQmDdvHgBLliwhMzMTnU5HUFAQ48ePx2azdbl/n8/HNddcQ0JCAjqdjrS0NP7+9793aDNv3jwuvPBCnnvuOSIiIggKCuLmm2/G4/G0t6murub8889Hp9ORkJDAxx9/fMpzPhmlUkl4eDhRUVFMnTqVBQsWsGrVKhwOB4sWLcJqtbJ8+XJ69OiBRqOhqKgIt9vNXXfdRVRUFAaDgcGDB7Nu3boO2920aROjRo1Cr9cTEBDApEmTaGjwl6WNj4/v9L6clZXFI4880v65qz7X0NDA3LlzCQkJQafTkZKS0mEiKTs7m7Fjx7Zf9+uuu67Db3n8Oj755JNERkaSmupPi3z99dfbSxqHhYUxY8aMM7p2/07qypvZtSqXg5uKyN1VxsFNRexalUtdefMfut/jY0VMTAyXXnopc+fO7TK0u66ujjlz5hAdHY1eryczM5NPP/20Q5vT3SfHf6snnniCsLAwrFYrjz76KF6vlzvvvJPAwECio6N5ry1K7zh33303qamp6PV6EhMTefDBBzvcJ8f5xz/+QUxMDHq9nksuuYTGxsZTnvP333/P8OHD28eUqVOnkpeX177c7XZzyy23EBERgVarJT4+vr0C16nGwX379jFmzBhMJhNms5n+/fuzc+fOX7v8/7OcdQ75L5FlmVWrVvHuu+/y9ddfYzab/625On9J6PjyqhQEPLKMDBQ53dR6PKQbdDya4jdaXi+u5on8Cv6WEsWmwemsqmsmx+akzu2l3NXEYKsRu9RCusGfDxqg8odRRmpUGBQKSpxuPqzwD7Ai8FF5HW+U1HB7XCifVTRQ7/FxV3w408OsDNl6GJcs09+sp6RN5f2O+HD6bzlIuFrFjwPTcPikdgG142GyKXoNuXb/y2q1x8trJTWUujx4ZZkVNU1kN9vY2GQjUKmgVZJRSD6C1Equjwll0s6jFDrd/DwonUhtx1nQrJM8qbMjgnizpIYllfVMDrZQV9/MNZF+XYAQtYrb4sO5MTYUtSAgeb3sWbYYURDJmj7rlGJj9yVF0NeoJezHz3AatChUKmz1tTSUFROako50zmBK165CLi2kVBC45rH7cDb7+HtZHcE5hYyoq6NPcBBbKo/g1QuUVRRTtWUN9uZmFgbE07exDrtax/aweF4wadlfXsmiVgPFvQdisTnxuNzc8MnbGFpKUA4dxdLRk2moKCPiyD7C47Mo0pkIayjkaEkZy5QmChxuRGBeVBB/TYmm3OlGKUBEdAwX3fMIP4s63t6dy1Op0RxzOJmyK4c4nZqtQ05oAuQEhPPCkWIqXA4mxaVyfnwclqgYPA4HKl3XdZdrC44heX2EpqSRPGAwQ2dcSnyfvqfs49fGhJBm0BKjVaFXnP2c2rMz+pBd1siYtNBOxn5Xoer2pka2LPkEBIG+556Pqs2L687Px1dbS/X+fXy7fytag5Gb3/uMDOOJ81SEmVEW1iJbuj7Osp9lNj8oIaog9doqmqsrURq/ZNJT/QhMTEZqdOPeVQRuL6JJg2jVIwab2L+mF7XZAsOfOeHdP67uDqAenACSjHCK65M4VcDVIuEwr6EiN5aI+fMJmDWLpTl2bn7cQn3vczj/UQ0UFCCaO9eBjxswpMNn2e3GU9cA5Q4EnZomrY2ja1cREB1Lj7bycs6WJqpzj6BUa4jJGsCFcaFAKF/mbmZHfhVpEVmoT/YCqg3+f79CZpypPXQ8QKOixeNDpzizcG+XR6KywUVUkBZlFx7IVo+XCoebRJPOH4nh88KKP6M3huEbfT8/7q1FRkIKFJBkH3V1m2htzSVy6HWojGEcio1nU91X9DYPwKgcA8GhDAhuE26TfFB5iAWHtrCl4gjvTVyAXqnB7nVhUuvoGRzL/poCJsRlndG5dPPfT+kGmS0PS52+d9TAloclhj4qEj3y36fE//DDD/Pkk0/y4osvtovaLly4kDvuuKO9zXvvvceIESNISkpix44dhIaGsnDhQiZPnozipPsyLy+PZcuWsXz5choaGpg5cyZPPfUUjz/+eHub999/nxtvvJFNmzYhyzJlZWVMmTKFefPm8cEHH3DkyBHmz5+PVqvtYMi9//77XHPNNWzbto2dO3dy3XXXERcXx/z587s8L1EUefnll4mPj6egoICbbrqJu+66i9df9+to3HzzzbjdbjZs2IDBYODQoUMYjUZiYmL48ssvufjiizl69ChmsxmdTkdFRQVz5szhmWeeYfr06bS0tLBx48ZTTgpIkkR0dDSff/45wcHBbN68meuuu46IiAhmzpzZ3m7t2rVERESwdu1ajh07xqxZs8jKymo/r3nz5lFSUsKaNWtQq9UsWLCA6urqs/6ddTodkiS1T3TY7XaefPJJ3nnnHYKCgggNDeWqq66isLCQzz77jMjISJYuXcrkyZPJzs4mJSWFvXv3Mm7cOK6++mpefvlllEola9euxec7OwHOX/a5Bx98kEOHDrFy5UqCg4M5duwYDoej/TgnT57MkCFD2LFjB9XV1Vx77bXccsstLFq0qH2bq1evxmw28+OPPyLLMjt37mTBggV8+OGHnHPOOdTX17Nx48azvm7/SurKmzm6o7TT926nl6M7SkkbGE1QZOdn9x+BTqfr0uB1Op3079+fu+++G7PZzIoVK7j88stJTExk8ODBZ3SfrFmzhujoaDZs2MCmTZu45ppr2LJlCyNHjmTbtm0sXryYG264gQkTJhATEwOAyWRi0aJFREZGkp2dzfz58zGZTNx1113t2z127Biff/453377Lc3NzVxzzTXcfPPNp5zEstls3H777WRmZmKz2XjooYeYPn06e/fubR8/vvnmGz7//HNiY2MpKSmhpKQE4JTj4Ny5c+nbty9vvPEGCoWCvXv3/kujjv7T+M0GeWFhIe+99x6LFi2irKyMuXPnsmLFivbZ0v8UTEoF10eH8FpJDQDRGjUOn4RW9NdM/ntRFU1eH9dE+42cPkYdWxtbWVvXTJxWxaNJkdwa5+ODslo0osDaev8MdpNXosjpxqgQaW3LwZaAlra/f25opdztQeGGq6OD0YgigSolFW4PeXYnj6dEc8TmZGKIlScL/HXNv6tpZF19C7PCAzknwEiGQUveiEy0CpEql5uNDa28X1bH7hY7X1c3sigzniiNmq+q/AJ1MjAxyMyqumamhlhQiQJmpQKtKHTKgf0ly6obkYFn02No2rCBrG+X03zzLXDSBEeJ083KmiauCDXjdToRRMEv7nSKbSbrtVzns5H/1deIooB00SX0mDgVU2g4LTVVHPlpJSqdDo3RRGttDbIsc0NCBLqcI5ybHocyKIjyA/soFNyETxhNTV4OjsYGtDodpZYgSi+cT0Z8HJMDTUwIsuBBwJpfyfAAE0pBZLvbTc/CXAqCtPxc28Dyei+rHn8Jc2MtuflHOKqzEJuawVUtAqEqJ48lR7Kr2c4VUf6JiDKXB40gMjU6lITYUJ47VMS2JhubGluZERZAP7OezF/UXn+3rIYKl4fhLTXUPvgotnsfpWrNKhrLS0gaNhqPw05kr6z2etiS18vRNT8AYA6LQGs2c84ll/5qvx5xUm36syXEpGFsetgZt9dbrEy+6c8o1ep2Yxwg8Kqr0A8ciCo1hZ4L/0FAeGeNBMGspixpLVJeNYHZ6QTOnNM+geNxOKgtPYCozkJyi7hLo4gKuoSyui/49ME7SB44hPNm3ghuLy6Fl/KWIsLjMwkQBaxJCmwVMqYIHe7sUuRWF6qsWESdfzAXBAFOE+JqihUIGr+LZc/8naObAzkvNYuQ2/7EzUEmfmz2oT1SBivfgHOfOqNrVHbHnTj2ZBN930sIKiWGQZEYQ0IJiIk/cR2tgaSNndSetnEcnc3FlIIynHWNWDOu4tdwtPhn/3Wmzi8bQ0IsDA42U7JtE3WlJUQPHYEqqrNS/nEOFrdQVOPE6ZFIi+ps/G+taabE5kSWZVItBmgph90fgFILo+4DQEDk0ujrUCtUVJR9icdTjydyLKrzXyLAUYSlrpQwTRf6GeuewrbxBfYkzKHV56PJ5fcKxJtC+DJ3M6kBkSycfNuvXo9u/jeQfTJ7X+1sjJ/M3lclooaJf0j4+vLlyzsI1oLf0/Tggw+2f7700ku5+uqr2z9fddVVPPTQQ2zfvp1Bgwbh8Xj46KOPePbZZwHac5CtVmun0rCSJLFo0SJMJv9Yfvnll7N69eoOBnlycjLPPPNM++f777+fmJgYXn31VQRBID09nfLycu6++24eeuih9jDqmJgYXnzxRQRBIC0tjezsbF588cVTGuQnO1ESEhJ47LHHuPHGG9sN8uLiYi6++GIyM/16MImJie3tAwP9+hahoaHtOeR5eXl4vV4uuugi4tqqThxftytUKlWHHNyEhAQ2b97M559/3sEgDwgI4NVXX0WhUJCens55553H6tWrmT9/Pjk5OaxcuZKtW7cyuC2V6N133yUjI6PT/k7HkSNHeOONNxg0aFD7b+PxeHj99dfp06dP+/l9+umnlJaWEhnpH9vuuOMOvv/+exYuXMgTTzzBM888w4ABA9qvIfhD48+WX/a54uJi+vbty4ABAwA6RF18/PHHOBwOPvjgAwxtVWteffVVzj//fJ5++mnCwvzPfYPBwDvvvNMeqv7VV19hMBiYOnUqJpOJuLg4+vY9tVPg340syxRkV562TcGBSgIjTH94+Pr27dv55JNPGDeuc5WbqKioDpN1t956K99//z1ffPFFu0H+a/dJYGAgL7/8MqIokpaWxjPPPIPdbue++/zP33vvvZennnqKTZs2MXu2X7fmgQceaF8/Pj6ev/zlLyxevLiDQe50Onn//feJjva/H7zyyiucd955PP/8812Wsb64TevpOO+++y6hoaEcOnSIXr16UVxcTEpKCsOHD0cQhPbzgVOPg8XFxdx5552kp/u1k1JSUk55nf8/cFYGucvl4quvvuKdd95h8+bNnHvuubzwwgvMmTOHe+65hx49fntt2t8Th0/iucJKllU1sDgriQeSIvmwvB6XLLGtyca87AJmhgfwfHosC3slUO5yk9aWyzhjXx4uyW9k1nl8ZG4+SD+znk2NNl4vqeGp1Gi8kkxfk5aXS/zh5glaNUVON2FqJRVu/4xqscOFgN9It/skrColm4dk8PCxMnyyzMaGVh5LicKkVLDrnJ4oBei3+RC1Hi9r6ls4x2pgc6ONt3rGc0GolUithlkRGmZFBPF4XjnlLg9jA81MDrZiVAh8WtnApCAzX7apx59j9T9IPkuNoLa4gMC2Mcnuk7r0qr6fmUCxw83UUCvHVn+PZ+dm9MfGwtATg/LjeRWsrG1CpxC58pK5CNBuWAK8UlTFxxV1LOyV0O4l1SQnI112KS7JS2RaOmKbUJPOEkBgXALG4FCie/fD63aj0mrxeTycZxYxJffC5/FQsO1nAFy2FpQaDZbwSCo9PvLVBuISQ5iWGMm8AwWcH2LFJ8s0en2YlQo+7pOI2yfxafDLjDMbkDwi6sYmUhMSWLt4E7vNUYzy2hnZry9TDhWTbtSSa3exrLqROJ2GexMjKHa4qPF4ybE7KXO6KXW6uTQikCsig1CLIiv6d64R/mBSJF5JZrUsExyTiuTzolCr8fl8HF7zAyqVCqVGiyxJhKako1CpiMkaQOn+3exf8RUCENt/MGGpZ/cSIcsyeZvWISpVJA4Z/usrnCU9R3V+2AiiiK53bwAm33jbKdZUoNfH0fzyUm4YE83O9Xv5bmAGGUYdNXk5tNq2EzZjB3E9Lmb7Y8E0aJx4IiMRHE2odXoUMYEIOjX1lfnUby8ClYKA6Dj6LhDpuwBkScaV3QAyeA6WohmQcIrj6IgsSUQkp9N7/GSUH31G3fodmM+fiiU1lclvtqB+fyTsaIXxj4BK+6vbUwQG4GttRAhToE5JRDRp6XPBJe37Oj4JcXLZu+OMSejLvuxjhIfG/Op+PC4n7/35BgCue31hhwmS4ziamyg5uA+QcW1YTfqcK9uX2V0+fJKMSecf+qOCtDQ7vdTiIcbro6TKiccr0TPW6C/XZtIhyTIRxwUmrbEw+xPQWlEoRCZk+SevFG0TfhER5+PxNCKKamRZIkoXx+zoazsdoyzLCIGJfGvJoKbNY+SWfKy+5G+UVxzi4nULKWqq4r7BMzut283/JjXZfk/46XDU+NuFZv3++x8zZgxvvPFGh++OG5vHOW4EHSciIoLzzjuP9957j0GDBrF8+XKcTieXXHLJr+4vPj6+3eA7vq1fenN/ub/Dhw8zdOjQDkbGsGHDaG1tpbS0lNhYv6bLkCFDOrQZOnQozz//PD6fr4OX/jhr167liSee4NChQzQ3N+P1enE6ndhsNgwGAwsWLODGG29k1apVjB8/nosvvpjebWN/V/Tp04dx48aRmZnJpEmTmDhxIjNmzOiQAvBL3nzzTd555x2KiopwOBy43W6ysrI6tOnZs2eH44+IiCA7O7v92iiVyg7XLD09/YyE5rKzszEajfh8PlwuF6NHj+att95qX65Wqzuc7+7du/2TlKkd3wFcLhdBQf70rL17955RP/g1ftkHbrzxRi6++GJ2797NxIkTufDCCznnHL/GyeHDh+nTp0+7MQ7+/iFJEkePHm03yDMzMzvkjU+YMIG4uDgSExOZPHkykydPZvr06ej1/5rqHWfL8Zzx0+F2eGmus2MJ/v31R45P3nm9XjweD9OmTeOVV17h0KFDHdr5fD6eeuopFi9eTFlZGS6XC5fL1f77nMl90rNnzw56BWFhYfTqdSKSUaFQEBQU1GHsWLJkCS+99BLHjh2jtbUVr9eL+ReRfrGxse3GOPjHiOP9pCuDPC8vjwcffJCtW7dSW1uL1JbmV1xcTK9evZg3bx4TJkwgLS2NyZMnM3XqVCZOnHja63j77bdz7bXX8uGHHzJ+/HguueQSkpKSTrvO/zJnZZBHRUXRo0cPLrvsMpYsWdLeaebMmfOHHNzZ8uixMva22NneaCNMo6Lc5aHS5SFWq+buhHC0oojT60NCpqktT7uPWUdLgw+XJKERRa6OCmZdfQtXRQbxfV0zWxpb2dHo99wogDKnm42NrWxs9Ofk+IDBViPrU6OJ3bAfALUgUOXxYVUqGGo1EtRWtkinEHkmLYZR249w1OZkeU0jPYw6EnQankyN5t1e8bxaXIVVqSRco6TVJ9HrpPBfd2kZysAA7m9Ta69xe7jtcCETg83sOacntx0upkWSSdCpGWw18GBuKatLK5lSncdVPi9fmSN5Ir+CN3rEcWFYxwdjT6OOAoeLSpeHmHvvofWcoQTMuIhrDhRQ4/ayuE8S10YHY1SKTAm2oNJ0FgHZ3Wyn0OGmwOFqN8hvPVTEF8PO54X0GAacpJqsVKvJGD+l/XPT+x/gKS1BO/8aqnOP0FRRRnh6TyJ79sHrcRGa0oMDK75CHxhEjEbDZ60FxA6dSoNPIkytJMOoZVZ4IBNMGobcdRulgQH8ZA3hnrEXkJBbwpWOapaG96Bs9RamJmeyzSZSWV7A7QoF72X6jbgyp5sIjYrLIv0P1IvDA0kzaEnWa1lT38y2JhsKQUB9mjz6ZL2WTJOe1fUtjLhhAfHxUUg+H6vefwejxcI5F82isayEusI8JJ+XqMy+RPbqQ2XOIQTAbbdhq687fUfvAq/TSdXRQwiCSPzAoR0mSv6dCIJARMQF6K72scUSixeRnU02UptdBFarsYUkUFVXiDbGTsalArmrN6Kqb6T+6ts5d5K/zJsixERYQA8QIfAkjzOAIAoos2Lw5lShCLMA4HW5EETRL7J2Cg6tWkFzVTnDZ16GN6knnvJytG0vV8aUALhqISjUv2qM1xXmU7DtZxKvnkfaQw91St/I27yeqpzDZJ43HVNI11EJOouVIZd37bn6JaJCgcFi9f/9CxXy46XI1AY1piQvglLGrEtrX55faWN/kX/ciozTkmuzMzEqCDFQoLTCga3Ri63FPy4mRejRqRXEm3TEm36RapF+Xvufil9E3igUOmy2fKqrf8BiySIkpHOpvp/LDnHDj68xLrYPt1z5OUO2fY5ZpWOIwYh+74cEFP7Mx5XbCB7+7y+f2c2/DmfdmeWI+9v9/l4vg8FAcnLnCbNftvkl1157LZdffjkvvvgiCxcuZNasWWdkyPwyNFMQhPaX3FPtr6tyg8fDW3+rJ7CoqIgpU6Zwww038NhjjxEYGMjPP//MNddc0x6Ge+211zJp0iRWrFjBqlWrePLJJ3n++ee59dZbu9ymQqHgxx9/ZPPmzaxatYpXXnmF+++/n23btpGQ0HnS9PPPP+fPf/4zzz//PEOHDsVkMvHss8+ybdu2Du1Od83+meuQlpbGN998g0KhIDIyspOYn06n67BdSZJQKBTs2rWr0wTH8SgL3SlS1I4jimKnEP6uwp5/2QfOPfdcioqKWLFiBT/99BPjxo3j5ptv5rnnnuuyfxzn5O9/uU2TycTu3btZt24dq1at4qGHHuKRRx5hx44d/5HK+b9mjJ9tu7Pl+OSdSqUiMjKyvV/+0iB//vnnefHFF3nppZfaNRpuu+023G5/yuqZ3Cdd9fnT3Qdbt25l9uzZPProo0yaNAmLxcJnn33G888/f9pzOt4/TtV/zj//fGJiYnj77beJjIxEkiR69erVfi79+vWjoKCAlStX8tNPPzFz5kzGjx/PkiVLutwe+CscXHrppaxYsYKVK1fy8MMP89lnnzF9+vTTHuv/KmdlkB9XlxQEoctZ1n83n1TUnzC0TTo+7p1IhlHHTQeL+Kr6RJ73FZFBLCqv48rsfOK1Gv5RWsMFoRbe6pnAuCAzG+pbuDu3jBtjQni7ZzyDtx6m1uOlr1mPdJKIVqxaybBAE8MDDKgVIg8kRrC72cZNsWF4Jb9X3CvLtHh9KFUCOTYnsVo1jyVHMndfPq0+ie1NNrY32ZgSbKbO42V9vf+FWQZ2De3Rnk/uOHCQwpkz0Q8YQNwH/pILe5rtrK5vptHr5cqoYO5NjCDLrOeSsAAMSgXLqhupQcmrIancEBmLp8UvBub5xUPAK8kM23aYIqebcYEmPu6TxO6AEFaV1rOpoRWbT6LF62NYgIlhASbq3F52N9noZ+k4qL+cEUuuzdn+fbnTzRdVDegcNuwFxyDCb+hKsoz4i5u+7p13kFpaCI6JRllQgC86EpfNRsJJ3t4+02aiUKvZu2wxIgIRaiXRSiX7hp2YLbzEpCF3/37cOh3pcQkMDo1BExlGhaBA6fNg8rq5ou8QSr77nsGhHV+aQgWJi+uLMFjVoPZ7Rnq1haSfG2zhnZ7x9PkVBXOAuxPCuSoqmLC2305UKLj86ZfxeT0EtZU7c9laaK2twetyotRoSQ+Lo+KRR7Hc/idCTyqNdaaodDp6TDofUaH4jzHGT8Z60XQeK63lQKudORFBSDmV4PJSX1rOtvXfse2Hlfzpgy+xymNZ1uzm3KqSDusrlCoie/bpctvKcCselYVjq2Six9o5sOpjVBot/dvKqp1MU0VZm5L5iXvANLaLNJukrmu+H8fZ0kzB1p8RRBFXawutdTUExsYD0FBaTF1hHnEDhuJzu5ElCcn7+7wY1O1XMueh19BYOt4/tfm5HF33I4lDRxKR0YukgRcgikpEn5XmqgrMYRGU1bmQZTBqFdglH25JprrqB8I9VdS5p2Jz+8iINmDUKtGpf3sfUiqNiKIGlcra5fJmlx2vLPFD0R7MGgOLRl8N65/Gu/x2bmr10VdnYH78IOg59TcfQzf/fWiDjtc9OZN2/zlMmTIFg8HAG2+8wcqVK9mwYUOH5SqV6qzzhk9Fjx49+PLLLzsYXps3b8ZkMhEVdULMc+vWrR3W27p1KykpKV2+t+3cuROv18vzzz/f7on7/PPPO7WLiYnhhhtu4IYbbuDee+/l7bff5tZbb233tP7yHAVBYNiwYQwbNoyHHnqIuLg4li5dyu23395p2xs3buScc87hpptuav/uZMGoMyEjIwOv18vOnTsZNGgQAEePHj2tUNVx1Gr1r07GnEzfvn3x+XxUV1czYsSILtv07t2b1atXn7IcVkhICBUVFe2fm5ubKSgo6LJtV+vOmzePefPmMWLECO68806ee+45evTowfvvv98e2QB+YTlRFDt583+JUqlk/PjxjB8/nocffhir1cqaNWu46KKLzuiY/pWotWdmupxpu7PlTCbvwN+vp02bxmWXXQb4J3Jyc3M7pFGczX1yJmzatIm4uDjuv//+9u+Kioo6tSsuLqa8vLw95WLLli2n7Cd1dXUcPnyYf/zjH+39/eeff+7Uzmw2M2vWLGbNmsWMGTOYPHky9fX1BAYGnnIcTE1NJTU1lT//+c/MmTOHhQsXdhvkZ0JFRQVffvkl7777Ln/6058499xzueyyy/7wHI0z5cusJL6ubuSV4mqaPT72tNj5qqqBb2r8xrgS0ChEzEr/Q+mH2mZiNCqUwDfVTcwMa+L72iYO2pwAqAQBg1LB6z1imbUvnxKnm/STyvQUu70UVzbwaWUDq2qb+bamCY0okKLX8o/SGpxtxrtSgFithnyHCwXw48A0dg/ryUdltbxcXM3EYAt/zasgr00ZWQCS9RqMyhMPT4XZhMJqRXVSiMmEIDNv9oijT5vRGNZWim349iMsykxgad9kXi2qJkGnITgoiNuD4MrI4HaP/XHcskydx4NCgMnBfi/j0/kVbG2ykaLXMFWt4O9vf8DtsSEEXXAB1xwoYGuTjSVZSQwPOBFyZ1IqOhjp4RoVN8WEonvraZqK8ii1PkV+eByX7stjeKCJRb0S0LaFz0e/9hq+2hrU8fEITbV4tBqczU1o2h4qPq+nvTxZv4v8ERkKZefuqwwKInHpV7hycuDQAebGBLLAEkmuKoYNWjuRPQYzec8xmkMSuGuQP29lVW0TNx4q4latl4HZO7E3NpI+dpJ/v83NKMxmBEFgaltd9l9DEIR2Y/w41rATIUDWqBiK92ynNj8XjdGEISgYz8GDNI4eiquyjPDfaFAHRMf+eqM/CJ8kofiFd/iVoiqam+sIqBG4angqV0UHty+TU8NRhJlx1O0A/L+lrUJibNRA0oVt9B4//qz2f+RjmWNLZVwtAqJJiULlf0lcUfkFrb4WpkfMRbK5OPDdMhRqNYPnXuNPJ1Cp8bpc2BvqMHeRAw9QsmcnolJJVGZW+3cNpcXUFxcQEBtPrykXYg6LaF9Wtn83TRVlyDt2ExwWQfzsKzvljZ8ph0paaWj1MCjFQtVmgS0PS4QPhhFPdewjzQ25IMt4nH5xH4PBP7u++8tPcDQ20GfaJfQPddFQ8g2RvYYghfejubQWp6sBjdBCUqiHvGo1VTVNBBpbIDj9Nx0vgF4fR2LizadcPiVxAHqVhnezf2RAWBIvfHojtxctZ31of9boU9kkKrly5kuoFX/My1Q3/5mEZIIu5PRh67oQf7s/ApfLRWVlx7xUpVJJcHDwKdbwo1AomDdvHvfeey/JyckMHdpxQjU+Pp7Vq1czbNgwNBrNacO2f42bbrqJl156iVtvvZVbbrmFo0eP8vDDD3P77bd3CGstKSnh9ttv5/rrr2f37t288sorp/SQJSUl4fV6eeWVVzj//PPZtGkTb775Zoc2t912G+eeey6pqak0NDSwZs2adqMiLi4OQRBYvnw5U6ZMQafTcfDgQVavXs3EiRMJDQ1l27Zt1NTUnDKfOzk5mQ8++IAffviBhIQEPvzwQ3bs2NGlN/1UHA+VnT9/Pm+99RZKpZLbbrvtVz3Vv4XU1FTmzp3LFVdcwfPPP0/fvn2pra1lzZo1ZGZmMmXKFO69914yMzO56aabuOGGG1Cr1axdu5ZLLrmE4OBgxo4dy6JFi9rV6x988MEzcnQ99NBD9O/fn549e+JyuVi+fHn7dZ07dy4PP/wwV155JY888gg1NTXceuutXH755e3h6l2xfPly8vPzGTlyJAEBAXz33XdIkkRaWtop1/l3Yg7So9YqT+sBV+v8JdD+nSQnJ/Pll1+yefNmAgICeOGFF6isrGz/vbZt23ZW98mZ7rO4uJjPPvuMgQMHsmLFCpYuXdqpnVar5corr+S5556jubmZBQsWMHPmzC7D1QMCAggKCuKtt94iIiKC4uJi7rnnng5tXnzxRSIiIsjKykIURb744gvCw8PbIyx+OQ5qtVruvPNOZsyYQUJCAqWlpezYsaNTrvr/J85Kolmr1TJ37lzWrFlDdnY2GRkZLFiwAK/Xy+OPP86PP/74u80E/xZ6mfRcHR3MpGAzsyKCuP1ICa8UV+Ntm3T3ApeGB3BfUiTPp0WTqtdQ4vIQqvYbT4vK64g4KRR7eIAJp0/iugOFiMCoQBPOtrAQi7Ljpfu6pgkJcEsyfy+ubjfG9QKICO2lx3z4Q6ND1CoO2104JJn9zXb6W/T0NenpadCiEiDX7mJ1nV+8aUdTK/fZBRw//EjkEycEXwRB4MKwABL0J8KrDrU6qHB5KHa4SdZreSkjlj/FnxiIf2mMA+gVIiv6pfJ8agwtPgmnT+LexAiGWY3k2l182dDKuz378/PP/vCxULUSnSi0l9zySl17NURB4KHkSMyDRtCUNQRzaCgtPh9eYF19C0vbohZaqivZd2gXNVYjrgALUZPPI37QMDQGI0U7t1C6bzdb33+L0l3bAdAYTWiMpxY10yQnU/HoX5HeWUj1B//gEquOPyVEkDBgMC3Lvqa+vIIWt4cHckvZ3WSjwuXB5pN426XknaQBRPXye2LrP/yInEGDafhs8Sn39Vs49MNy7HV1RGZmUZa9h5y1qyi2avHGRmPXa05bnuY/kTf3raT3B7eyvuRA+3etXh9LSo4yQ/s9Iar1fJdd0WGd2oJcjuzawLAZl/KXxcv504dfsfomgX1PphEV0xdHXQ1r/76IFU+9Q+sZhPDHTxaIGSMQP0HLwFlX0udCf+5xg6eOFm8THsmDWqcnMC6R0OT0tpB2/72eu2E12SuWUlfY2SPjttso3r2Nwu2bOni5w1L+j73zDo+jvN72PbO9N/XeJVty7x0bMNh0h96DCRBqIJBf6JBACBBSIAECoSSEGnrv2NgYbNx7kdW7tL2Xmfn+WFm2sE0LJPmSvbnMJc3Ozr5TdjTnPec8Tx0V0+dQMXUWtvzCYaXqZZNnUFBaRfKRx+n//R++dTAO0DEQo8+fIByXsGUFsBUnyB0v0OGO8daaDlZueod31jQj27Zjnmhgo1TKpta91kmO4lIs2bnozBaM25+j8LPrCL3xC6LeXuqsRryG+eQUnktdSSFVeQaUbR+z6+MPiIdDXzKqf55Dikfx1wU/wajR84Rs5Pm8GdyqKwcETqqdlQnG/wcRVAJjL/3yR5Kxl34/gm6QtvXJz88f9m/mzK+nx7F48WISicQw8a093HPPPbz33nsUFxf/00JZhYWFvPnmm6xatYoxY8Zw0UUXsXjx4mEiTgBnn3020WiUyZMnc8kll3DZZZdxwQUXHHCbY8eO5be//S133nknDQ0NPPnkk0N2RXuQJIlLLrmEESNGcOSRR1JbWzskVlZYWMitt97Kz3/+c3Jzc7n00kuxWq18/PHHLFy4kJqaGm644QbuueceFixYcMAxXHTRRSxatIhTTjmFKVOm4Ha7h2XLvy6PPfYYxcXFzJkzh0WLFnHBBReQk5PzjbfzdT/r7LPP5qc//Sm1tbUce+yxrFy5ckjpuqamhnfffZcNGzYwefJkpk2bxiuvvIJ6MJFw7bXXMnv2bI4++mgWLlzI8ccf/7X6Z7VaLddeey2jR49m9uzZqFQqnnnmGQCMRiPvvPMOHo+HSZMmceKJJ3LooYfyxz/+8Uu3abfbefHFF5k3bx4jRozgwQcf5Omnn/5WInT/CgRBoHzUge1A91DekPdvTxbeeOONjB8/niOOOIJDDjmEvLw8jj/++KHXv+n35Otw3HHHceWVV3LppZcyduxYVqxYMUyYcg9VVVUsWrSIhQsXMn/+fBoaGoYJEO6LKIo888wzrFmzhoaGBq688soh4co9mM1m7rzzTiZOnMikSZNoaWnhzTffHJoo/OJ9UKVS4Xa7Ofvss6mpqeHkk09mwYIFB60o+V9AUP7Jp39ZlnnnnXd45JFHeO2117BYLAwMDHzpewKBADabDb/fv5/QwHfJ3zoHuLu5m/7k3kmCk/Mc3Dsirf7Xn0hy6vrdbAnHKDNoOSvfxW1N3Siks9rH59j5yBPCpVGhFgTenljD4k3NvOcJ8scRJRyf42Dip1voSaQwCBBVoN6kH8qw6wTYOXs0G4NRrtvRzqbB5Q+NLOXYXAef+UJcvLWV3ngSk1pk64xRqAT4Y1sff+0a4PGGcgwqkZkrt6MA0+0mzirI4pU+L7+uKSZPt3+PbESSeWfAz1S7adjkwldx6Ofb2RJKj++PI0o4Mc9JVJJ5sddLwu+ho7mdn9ZXYiwt5YptbTzb4+HmygLWBMIs8QR5Z2INlcb9+23DkkTtsk0owNYZDdg0ap7ucrPUG+TWqkJydRq8zbvZ+sHb2FzZhEMBUok46sYW9FMnExrow+zKJuTux7RmA6N/dx+ibn8hqy/ifuQRupZ9jHfeLGpOOotbm7pZlOtg5K9+Qe8HH/DScafw8NwFHJVt45GGct4b8HPOpmbKDFpetCvprPU779N7221k//SnBN96C9OsWeRc+ZOvfUwPxsZXnyfkGWDcCacy0NxIMhYlGYsR9Xqonj0Pkyv7W29bSiVZ+dI/KKipo2zM+H96rF/JezcTWPNXTnVO55LDruSoiklDL73W1UJ56A3afC6mNyzCbkxfj3JK4eM/PI/G3kdvTw9ZObmUzjmSnQ/mEesJM/32BJ72nSy5dxMB1fuMnHo8C67cXxjsi3R/2I9r5ZFoq0bBSY8DEJUipJQUFvXB7zOdm9bRu2Mrrinz6YlqGFVqwajbm6no3bkVUaUhu/KbKYB6n3kWTWEh5lnfXmQvGE0RjUvk2HXw3DPg9cJxx7MxZmZ3T4Q841oCiWIaCmXa/Va6fQbyHTqm1tqHtiHJCu0DUXJ1UZJv3UITuZgmmAimqhldszDtG77PsUjF45RMmPK9P8z88rNneWrbUi4bs5Cp2aX8fOU/SMkSr59wI8avIaSX4d/D9/33u+PjtNr6vplyQ3Y6GP93Wp59GZ988gmHHHIIHR0dX5qJzJAhw3eHuytA86aeYZlyrUFNeUPev8zyLEOG74p/Og0hiiILFixgwYIF9Pf388QTT3wX4/pOOLswi9lOC8s8QWpMekoNOrI0e3c5W6vhF9WFvD3g5+qyPF7o9aIAI0x6nhpTwZXb2vEkUzw+qpxJg6XYMqAXBcZYjKhFgUcbymmMxjkp10FEklmwZufQ9hNKWmjkpPWNQxnzw11WLtjaijclcU5hFiumjODkDbvpiyd53x3gkc5+2qIJ3plQi0urZiCRotygpTeeZIUvjCcpsT0c47icEEdm2UgpCha1isZIjM98YSZYjFy8tXU/f+yvosKgoyuWZI7Twlxn+kZmUInMj7rZueI9ppdXYRy0Mfg/l55D9FksLMpiycYgcVkhcYAsuSLLJCQZl0aNS6PGMliCf1qBi0lNG+l7by2u+UfTv2wp+pWrSXX3ol1wOGJzC8YPl+M48yzMWdnkVNbQff6FiInE1w4SXIsX41q8GICnuty81OfDl5K49IorOXv+SRz70duc3N/JiWPS9i2HWg38Y9MKrKWF7N7SgcHmYPyZZ2A7/jjiO3bQd++9xLOdZH9BNOXOpm62haP8aWQppq9Zal6/8HjkZBKNwUDx2Ilf/YZBkrEY8VBwqHT/QLRv3sinzz+Fo6CI8373IK1rVuJpbWLE4UehP4BN1j9N31asMS9/n3Eazn2CcQCr3oXd+SMaaoZPDG18UKH/9UVQ9RIJx3ZUeXns3NZC6GQL88dmYdKrcBTn07sqn8bNMg3z5rB5yfvklFWQnVuMHIgi5uxvZ7LxXi+Hj25B6hDYcyYMqq8uWSscNY7CUeP4bIePbm+cHJuW8ty978ut2fs98jzxdyKrVpJ/222obLYv3a7j1FMO+poSS6KE44gu80HXAVBpBJx7JtaqqqG7G+wO6rU6TNoIvmAB4/NycGx+AJWQi6HsdBpKLUQTEuGYRJZVS3NvhE2tIYpcesYcdyeWrUuR2Y4kSUgy7NMZQ+Gof53VjU2WuMy3ke2rB/iT2sHzM05hRO2X9+5n+O+naLZA4QyR/k1pATe9SyB7FN9bZvyfIR6P097ezo033sjJJ5+cCcYzZPgX4iqw4sy3DKmua/XpMvV/d2Y8Q4Zvw3daF5idnf2thQi+L8oMOsoK98+ofuoL8U6/j654embt7I1NTLabua26kA/cASas2MrTYyq4o6aIDcEI97f18auaQiQFZAUkFAIpicu2tVGs13JynhN/SqI1mkAESvRa5rqs6FUqjs620xVPcFyOg5Ss8J47wO5IjGt2tHNpSQ5XleVy6oYmrt/VQWc8rbLZGYvj0qrJ0qpZMXUkf2rr45luNzdWFtAbT3JMtp05q7YzkEyxYsoIfrajgxW+EL+pLWKUxTBMnf3HW1rYHY3z/Niqof55gLM2NhFMSTw7thJfIkVYkjm/KBuXVs0af5j1wQgnWu3orTYsgz3QsWCA5tefp8hgRFd+Ln8bXU4wJZO1Tym8L5ni6uWrGd3fyrQZs+lNpDCqxGFCbt72VhKRMMG+XvqTUZg6EXVXLym9FqGsBH1eHjkFxajr01Yj5ldfoXvbZnx9Pd+4V3pRroOQJDHXaWVTTy9hnZ7O8eNZmVPEW5tbeGZMBXU7tuK8/z5UpaXkXH/NUD+xymzGOGECwi9uxO3po3fHVvLq9pZxPd3toSeRbhGo06kRvkTZew8qtfqA/e9fxbb33iDY18OooxcN61nel6L60Uw67kQKa9M9SIHuTiJeD7FggNSmEKJFg3HU3oA+npRRiQLqr/GwGw8FiXg9OIr3+kty4qPga8eZO3zy5xNvkFM27Ga0xcC7E4f3oVlKQGuFqRf+ANk2itZ1n+MaMRaTrEKvTWdrRbWamVePZCYjeeqGq+jetROd0cSPLroDxRNGM76UgBKiZ/cu6qbNQhBFqhdXsatjJTVnfbsezYZSM9k2LSXZB+859D77DInG3TjOPAvTlMkHXU9JSqR29iBk6VHnpsUM9xViSqxrRfFF0UwuR7VPUC5LCt2fQtYoCOtTvNrWT55By5FFWTB+wtB6KqCyIJeBgAOvewCXksKsTmLKM6ISBT7b4cMXTjG73kGuXUefP0Fxlh6tQUflhAVEYnMoErToNN+oa+nb420FSx6o996LL1GFUPk3sS05wGrnNCzqr/7uZPjfQFAJg9Zm/9kP1k8//TSLFy9m7Nix/1HJiAwZ/lcQBOF7sTbLkOFfzTeKCioqKr7Wek1NTd9qMP9K9oiWiaR7nVOKQlCS+XByHTvDMXSiiEujptyo42c721nmDXF0to0nRlfgS6bI1mnojifojCeG+spX+ELEFYXJNhOvjt9b3vrTsjxCksRPtrdxTkEWa6eN5PetvTzR5cahVnFNeT51Jj2N4RhmlUBIUrhiezsfTd4rrHRJSQ51Jj1bQlEuKs5GLQroVQJaSUAlpJXjW6Nx/tDayxvja4bU2QFW+cP0JJJ4k6mhgDwlK6z0h4jLCq2hGAstJkZqNRhEgWAqPdZdkTiVYyo45KQzh7al1ukxu7LRW9PZQZ0ootMOf6hf4gnyOnp2WfI5U4pzL16Ks0p4rsfD0dl2jCqRUUcvIhmLEuxNi+iYXNmMOucCdnzwNnJrG4mmJnrvuIPCu+4CIOxx0/zZMgT0xDecy9SbRQxfU21XrxK5oDjdR1ZdWUqlRiR/XBmn7OxhWzjGieubaJo5geyrrkI/ciTmmTP224ZjZD3hDTGMjuG+tE+PqaB5wE30k4/YdOOtdNWPRvebe5jrOnA2eoknwD96vNxQmf+NWgoALLl5pOJxdKaDZ1XVGg2zTz936Pe6QxcQDfgxqGz0vroa1MJQQB6JS7y3fgCzQc2ho137bSsUTRFLymRZ0+Pc/uHbhPr7qD/yWOyFg57ZOgsMBuN98SQbghEOc1mpNuqZYjNxiNNCOCVx+fY26s0GrirLo2yhTMUxqsHgtJb86v2FY7obd/DSr29l3IJjcBWW0tfcTPWU6fT0N2HXOtFZ9bz9q1/StXMbGp2eqolTqDhGBNLKp5sGWjGqtVTaDzxxcSDMejXmvC+/JRb+9rfEd+360mAcQB4IIrV5iPf5SKDi8ysnQTLOEU8aUWlFVFkWJAVE4/DJwuY3FNb+TqHkUIGyi/yIUgoxsdfWZ9+Z/3hSZtlWL6Bih3Exh4/PR6dLjz/HpkMATDoVeq2K6XXDJymM+n9O7EaWk3g8KzAYijGZKpBkmd6IjwLz8O/HB60biO16l4XLbydasxDj6U9BqI+1W9/i8s2f8efyw6iffSUr8keDPlNimOH/L/YoXWfIkCFDhgz/DN8oIG9paaG0tJTTTz/9exPK+FdxbUU+77sDzHZYMKlFIpJMqSH9cHxXbTF31hQhCAKKonBHdRGr/GGOzXFww64Onunx8NK4KsZbTSyfMgLjYA/mcTkOGiNxXur18vcuN2cWuHilz8uFW1qZaTezJRRjqTfIqflOLinJwaFRc15hFhpRoNKooykS55hsO0/3eMkfDKglRUElCNzd3M09Lb0A1Jn0zM+y8e7EWmQFNGJa3O0Prb3sCMfwpqRhAfnNVQWoBGFo/wDUosB7E2tJKgpZahUy0JlI8YfWXt51Byg36Dg5z8GGQIQSvY7P/CFW+cLcXl1I/TEncntTF1VdbsKSxD0tvTzSUDakuL4g28YN5XlMNZUQ7++ksGkrnT4Pl9sr2dbczM3TJqC3WNFbrDztibAlp5Ircm0ko1FS8QQhJYXxhKOxHLJXadvodFJQP4bWN+wMbIJACxj2jyG/FmNKiknKCi+MNXFjYxc5WjWCSkXWBQf3gjZY7cRDQXq2bxmWnR5hNhBftpZwVzu6ylL6fH6eaek5aED+aMcA77oDTLKZOFEn07FhLcXjJmJyfrmSL0D55BmUTx4+WdDcF0GnFilw7u257fXFSUkKhS49EVnN0laRIleCykNL6LRo2dAcoKHETDiWQqMW0SoKvld3Y55RgNq1Nzv8yTYvkYRMjlVDICYhW/JwygIG+/Cgaw9XbG/jI0+Qh+vLOCbHziuDk1KbghHe6PezPhDhxw49619+FlteASOPOIYdnWEau8NMq7XjtOydoAh53ESDAbxdnSy87GqO+PEVRHxePvnrn+nv7qI2NJ0RM+egMxrJrxpu09EX8XPq63ehV2t5et5tKIpCbeGBJzHcLU3Ew8GDWqp9EX1NDZrKYlpbH0enyyIv78DWXBGLEY9DRjDtJPjZdMLdAoZ8Lz0rnqfwkHNRV+eirt6/vNVVL+CsU8ifCqnuDipWfULuOCvbG420+utZqTdT7TRwWr4LseUD5kY28pn+WFzZ2Wi1WhLJOBq1lvoSM/Dl5fBfl1U9OzFrDIx0FQ8t29q7DnVwNUZ9KyZTBbevfJalm97kT4XF1B12HejSn33zp0+R62vhUEHkue5GNi75C79tfpHxrZ9QkzOXt8ecS335t++xz5AhQ4YMGTJk+P+dbxSQP/PMMzz22GP89re/ZcGCBZx33nksXLhwmN3G/y9MsZuZYj/4A+ueTNQRa3bSE0/yxvgaNKJASJJJygpRKZ21KtKng4jueII7m3rI1qppjSX4zBfizAIXWRo1RpXITLuZS0tz6IwmqFy6kTMKs/h1zV4Ls4fqywhLMla1iv+rKCBPp+GKbW282ufjzQl7s+3znBZmONLjVgnp7PgeXhxXhSeZGiau1hqNc+GWVgyiyMLZtqH9+twf5sZdnVxTnkeVy8q0fAcfRWMc57LxnjtIkV7LWIuR63Z18mafj/5wiC7UnJjnwK5W8UB7Pw61iuNzHfhTEp2x5NBn6kSRS8vSJe6S3YIspYiZHIzc3kJFRwvJsSPRDFqR3N7tJ27O44iBDhKff0qwvwfUasJVZRgPTfeTxoMBdi37EHtRCZMvrSdwDORO+OdKGU9c38imUJQlk2opMegISxJJWcGuOfBXQlSJCIJwQI9vw4hRvBxK8OHpF3N4VRm35B88uL6pqoBpdjMn5znpWfUJ7pbd6C1WTJOHvycux9kSWEupuhzv+m04S8qHfK730D4QZX1TkGYpQX65kRkaIzqNwIrtfgCONGtIyQqyrJBIydgOL2XJyl7k3ihvbu3koeVNPHjGBLStUTbGJOo/7cZ19N4qmAKXHn84RTwl0RiLczsWshx2NptM+CNJ1jUFqcwzUJyVPpfzkkGqXnsEh7gIcuYSjqVYttVLvkPHX0eVU6TXoqRioIAyqDngC0ToX/Uu3fpprEnZ0KgE5jQ4qZ48nXN+8yfMDieyLCGKKox2B+aCEmKRCDGvG212JQt/ehP6L3hm23VGZhSMwKm3sqUtrRZelmM8YHn2zo/fR04msRcUYXR8vRkeWY6TTPpIK0rsRVFSeL2r0esL6HG30qoxYTccS549C5Cwjm0jWuQhkfAgijpUKgOCMHxM9kqBQx9I74+UakDUCITVH6AGisxu7uiZSX8ggbEtxQK5Ebs8gFMVoMNtxaRei1ZaSlyYQn3l/lUe34a3mlZz5dJHMKi0rD3r9wiCwGu7V3HNx49xQlkNN045BACH3sKxkRb+1tTLVaseIWvWFQBcO/lEGpf9kVuck3nZXM6o4ABUzIV4kLuOux1X3tfXuciQIUOGDBkyZPhv5BsF5CeffDInn3wynZ2dPP7441x55ZVccMEFnH322SxevJjq6m+mQvyfjKIoKEAgJTGQSDF71TaWTxnBH+pKuKWqgGzt8H7H1/p8PNPjYWGWlefHVlJvMvC7lh7qzQaaZqf7oLeHo5y+oQmZtC3UvqgEYaicfI96uj+VIqHIRCWZa8rzubA4Z1gP+BdxaNQ4NGr64kle7fdxcp6TXK2GHK2a3kSKF3u9THeYuXhrOkBfH4zwkSfAoS4rI80G/j46HYzNz7IiKwoRWeGVPh8r/WFK4zGukMNMt49BFAR+VV1IqUHHbIeFcwpd1JkO3Her0mgoHDWOi9fuotNkZ3zFFDQGA6/3+VCA+0eWsWnTBmzdrZgnTSPq8+JB4B5tNpNberlOk2LnZZcSOO5I4okE8aqRVE7eO+GQiscQ1ZoDBspfhkpIC3/t6Wufu2oHvlSKT6eMPKA1nCUnj6ln/QjxAL3ftWXlLM4r5EqViO0gAf0eqox6Koo0KFKKorET0JnN5FTv7/m8I7iRz33L8Xlb0O3wEPF69gvIVSIoQLuSpHnDNvSOavYRB2dTa5Ca/jDFmwYQHAY6swwYtCLhuIxRpUEAApEUEYcBXEaUkkHP90CcwEftlI/LZatGoNBppDjPwOvbg1QPKtx7gkm8oSQ9XhWFRjWxXT4mdu0i0NWK/9O3Yc5c4kmZaELGH0lxRLmTLk+M5pCaCaeei2bw+6PrWI176TNs9zeiPexikpLAK/fcgaejheOvuZG1zz+JLa+A+iOPBWDS8Sexbcn7BBQjnWI+toEYNQXD+8e0Kg0Pzb8USE9ayDLDgnFPWwv9u3dSNnkG5VNmEg8GDpr1PxAajZ2SknNQqYaXm0cirXg8K1CrbQgpP2V2M4XFYzBUCWT/JoAkimgNU+gYCNPet4Xq3BgF+YezqTVIa3+UWSMc2Ex77ysqtZq82lG4tyQIxNbjcNZyTlUOBSGBiDdFf9lJFBpC5CRyCXSH0akFFAm+OFHwz3Dt8nRfbLktd2gyL9tow6zRU5lVj9GY1nO4bNzRnN+6huXeHvS9nRy9+zOysis5qnAEnPonSEY5PuBmhKsYdCaYcw1fXROSIUOGDBkyZMjw38+3EnUrLCzk+uuv5/rrr2fp0qXccsst3H333QwMDOBwfDtBpf8kFEVh7uc7CKYk3ppYzXmbWtgdiaMWBNSisF8wDnBqvouwJHN0tp1qk57PfCHubO6hUKdhfla639qlUVNp1FFvNvCHEV8tTPZQfRn+lDT0eV8MxhOyzPW7OinVa7m0dG/5690tPTzR5cabTHFNeT5XlObyeKebEWYDz/d4+NQXptyg5aH6MtRCWtDu5qqCocz6WZua2RSMsGRyHX+uL+Pyba3MlEQWl9cNBbDnFe0VBivrbKfjgQdwLT4fQ8OBfSujkkxKEHGUVdLz0st0Pfsij518Fo+4RKqEFAOAwWZn3KJTOXtjE2vdAfKjCWQ5iaa5FdeWXTx9/kL+vHI7V8YHuGb+XOKhEOtffAaTK4vRx/zgS8/nro8/AKB69qEIgsA/xlaSkBUMKpFwSqI/kUQhXf5/MES1mng4TNTvxV5QNOy1Yv3X7wff9PpLRH1exv3gtIOqWleY6vAkB6jJHoksurF94fMA1KKIAAiCxCGkr5FELIpGbyQpKXR64iTjMn1j81DHUiTdMcpyDGztCHP0mHzOn1sGisAHaztQFBG11YEUTND/8CZS/VEiCHTmmonEJEpzDFykdZJlTn9OaY4BrUYky6LF/9puwqt6cM2pofLyB8iV0xoSTouWw8a40A8Gwxuag8SSMklJYWx5OpitnDCJjq2zqZ89j/x6F4Ig8OQTLfj7+kjGYgiCgLDPZItao2HU4QvwR5K098co/RIBNmAoe78v3Vs34etsw15QRF7tt8vQarX73+cMhhJstvEYDIXE433odDkYtCo63TG8ySS5tloKcnV8tMlHKF5DsHsdLH+WxIjZJFMi8WQKggNgSbdE9PW9TzC4BUvzNLSf1GE9tpIfTs9CURQicQmTXg1kUQaU5RiALKLxOvTagx+TcDKGQa1F/EJmvjPkxqEzY9QMn2Q4tHQ0H7Zu5MoJxw8tm5pfy+ozfzf0uyTLiILAz+acT8fz1/LjrS9wuN+LpNKyuvt1dM5SuPBjppq/vZ1fhgwZMmTIkCHDfyvfWmU9Fovx/PPP8+ijj7Jy5UpOOukkjMZ/TijoPwUZCKYkIpKMXlRxVLYdrSiQewDf7z1Y1SquHCzTBphgNfGT0lxGWfY+HGdrNSybMuJrj0Mriuh9fWzftJ7icZMwOYeX1LZEEzzR5UYvCsxxWhhlSR//E3Md9CeSaAWBT30hzivK5pzsLBIh0IrBofEd5rJyydYW3nUHyNOpOSbbwZZQFJ2YLoU/ef1u5jgtPDc2LZQVkWQ+84WYYjMNE5cKvPY6wbfeRu1wcpfezvpghMcayrEPZusPXb2DepOe58fVY1WraHnheWatX0PuEfPwesM4isuYfOZiNLr0hMBsp4XPfCHOKcxC77RQtXQJotlMUbcXrezF4HcjpyREUURQiai+Qp1ZSiYZaNoFQMW02ai1WlSCgGGw3v+RzgGisoJxnyoFgK3LPqJrxzbmnHXe0Nh2fPg2wb6e4cJm3xBh6H8Hx6y2cEjWgvQvY0oPuI5THaIisR6rqpCAoxRBkaiSN6ONxGmzzyEYlegzasm2ahBsWkYWm9i9xYOigKc5QGlOHp/u8KIhRUwws2Kbh1JJxtYfRbRqKZuSi1YUcZg1bGpJXzcWo5o1jX5qCk0UDvatyyOcJHsjSNUlKANxFOdekTaLIX2LCcckHGY13d4Eyj4OeRZnFkdddg0tbUE+2OhmfKWVhot+hVmdwlSYxeTTzztgVcJa93YMWi06zf6CcF9F+dSZ+DrbyK6s+eqVv4JUKkxHx1PodDnk5x9HdvYhAMhyAo/nM9SCGS0uVH0J5Jcfo+M8Bzl6I0Wu+VSvDILHw9hcNbVVDlrXPU5OeDfe0rmEnbPxeAMYVTLGGTmYy8wYRqaz+IIgDAbj+2PQHfwevMPTwUmv38mcogbum3fh0PKt3Ts48Z0/MCG3iicWDHfJuGfO4uEb8XfCC4uh7mju1hSwrq+J1kAf+WYnzx/zc66qHEuy+13KUwH8xlLUAiB+p2YeGTJkyJAhQ4YM/1V84yellStX8sgjj/Dss89SWVnJeeedxwsvvPBfkRkHeLi9nyK9ho8n15FSFLzJFLfu7gLg9HwXBtXezNLrfT46YgkuLM7ez/dQIwr8vOLgCs/hQcu0URbDsED+i+zctoWN3b00mhs5esregFxRFHzJFOcVZvFo5wA/29HBWxPTAcYUuxmrWsXcz3fgUKv4eEodW34uMrBJ4aQHsxg5xsCvm7oZu2IziwuzeGsgQFMkwVU72mmPJXhhbCXvDvj5c8cAT3a5uamyALNaxY27Oniy28PdtUWcVbC34NR53g/ZrdZy/7hpLO310pdIcXtTF3fXluBNpfAkUjSL8aFgN/8XvyS6bi3VRy2ke9sWXGXlQwEvwPlF2ZxflM3aQJiz/vEW5779EnPu/BU/Ks3lLKcBlErUWi1qrZbJp5+HcAANg6Ss8JuWHkaZDRydY2fUUScAoNbun8l2DZaZX1I6XGTrsxeextvdRc3UGZQ0jGFnOIatqARFljHY7Ac9Z3tIyQqv9/uYZjcPm8wZdfQiZFn+VtZne+gaCLO+McRotZ+kqZJIQuSQ0iSWjZ8QEF1sic6kwKkjx6ZFEATWNQVYvtVHWUrG1RYk36UnnpQYCCRBTGsSxCWBnaiYeVIN9lIrmiwDZYOft8dm3h1MEIhI6DQiZoOKXl+CsVUOcka46PbG0fiS5DjNEOgkIuvRW51EEzJLt7iJJxXGV1gpztLjCyfRa0T0WhWe53ag3tCPdkYRjQY1A0EJjVpkx4CbmgIj4WAIta+dkZMmsGK7D4MqycWr7kcliPyj9FhqZs37ykmZfTHaHRjt3+5+FYlLLN/mJdemZUy5FUVJkkqFUZReenvfJitrLiqVjmhwN4l4H20v3knrq2cRHxiNoAsTTFRjMQYwRLthwZHQvgJV5xuYR57ERz3tFJsU1nc0YWYKHd5pjC6ZjdmZBV9SUR+JtCBJUSyWr57sUxSF3rCPhJREq9LAhmcY+dKFXJg9lW7zlGHr+uNh3LEgFbZ97k9NS6DtU5Jyir+KlaQEkdGpAH4UiPmZP/MiGHEYLzkr0sJuyV+AKmNnliFDhgwZMmTIcDC+UURQX19PX18fp59+OsuWLWP06NHf17j+LWwLRbmxsROzSqRx9mje6Pdx/uYWDnNZOSrbNiwYh7SqdFiSOcRlOWgP9cHYHY3z5oCfDcEIJ+U56UskGW8d3gu7yhfirISFYMFo5Ag85wkw25lW7/57t5trdnRwUq6DSVYjakHAk0zh1KhZ4Q2RrVFxYq6DzliCUZ9s4RKplBKNiTeDQRaV29gRiRGTZU7MdWJQqTjUZWV7KMrHGyPkrTeQKPABoBcF9iQ0x1qMvNbnozWaGDbOv0ckfjvhEPqSKUbp1fQlUkSl9LuaInEkwLxP2bGuohxdRTkAz9mLeHlnH8flJPhBrpPyfWygnun28F5WPnnOPCY0NtK05F10FgupeJzsihp6tm+icuZcbIOe4fuyJhDmD6295GjU/Lm9n/OLszgu58BB2BkFLo7LsWNSifTu3Io5KxeT08X8i66gr3k3xSNH8XyPh0u3tXFOQR53Hjfpa53j53o8XLWjndnE+blnN6MWnoDGYEAQRVT/pBBiMJIgjp6gZGSirROltBJ3MEln3hm0BNLHcFypHm2oDa+mBK1aIJaUCTgNTK9zorJpEeQU1an1+HDg0ZQiigIalcAaFIrCSZRwivpiM6IoYDWqcQeTBCISVflGqvKNfDrodV2anSTPoSMUTZFMKYRCYfq2vMon+hMozPKj04jEkwo6OUbXh++hmjaPz7tVGHUimkiKaLYJZ72CocBMOJHWVsixaun0xOlwx4jERaQeGf2SDfithUiCwomGehQ5yQ7NCPw7PEyt3zuZEguFSCXimJ3fUob/S4glZcIxCa86BbvfQxN1U1p9Np3dLxMMbiUY3E6+63Bydq7FpdLSMq0ETaOMuEogePEV9IUkCps+I9n/CcJMLXn+7RDqgVAP08wlPOAZYGxVHg2lJgqcOvIdugOOY7ungx++/QdOrJnO8Y42VrkD5GQfzqHlUw+4/g5PJ5vdbRxfNZV/7PyEx7Z8wIWjjwQp/V2+YvQRMOucvW/wtvLzDx9kadDPC8dcm+79VhSUd65DFkTerD2ZSzrX4+hYyXE6AaXrLXixLR2wVx8Op/w9vR2Nfv/BZMiQIUOGDBn+pTz++OP85Cc/wefz/buHkuEAfKOoYNu2bcRiMf72t79xyCGH4HQ6D/jv/1dqTHp+UprLL6oLAUgNCruNMqdthr7Ir6qL+GlZLjXG4Q+dsqKg7FuXewBGW4z8dVQ5T4yuYNHanSxcs4tpn21F2ud92VoNEbUWWRAAAU9yrxDchkAEq0pkos3E54EIn/rD/HxnO6/0elm0vpHD1+zkjX4fowfL2P90Qiv/d81Wbg910BFLEJFkzKJIpUnP5aW51JsNjJZMLPUFuWlFDzdXFPDUqHKOyrKzNRQFYLLdTECSeaRjgLDHTdTvA+D23V30JVMAGNQqPpxUwz11xfTEkxzitHJSroPLSve3eIK0d/uuSJzftPRyw67OYa+dHh3g7K4dnDNrIkpRPlG/l1BfL6H+XrydbUT9PkL9fQfc7iSbif8rz+PIbBufB8K8OxD40vNhVqvYufR9Gpd9xI6P3gWgqK6e8QuORRBF8nQaLCqRMsOBA6QDMcVuYrrdzNRQP1G/j2Q8ut86kqKwLRgddt6/yEAixbU7O/jMFySUSu9HTbGdmmKZ22NqXt69BSHuZ1t7iG2hbJxZ2UyotKJt+wjWPYZ94BMqcnSU6jyMdoVQ23Xpig5fMw2xJYxPLcViVJOUFGJJmWhCYVd3lMbuCB9tchOJS0Nl5nqtSI1Vg5CUKXDqGVtuIdeerjqoyjdySIOTESVWMDhRCRJatUhFrpHyHAMaJcFAzgS8vrTyeSwh41eJJExaQtVO+hMyyUSSyNv3kiN1AxCJy2hSEeobRawfhZlTZ2dqlY2zCo/i0JpTUdRaEgzPwP7tZ5fxyBUXEPZ5hy0PxVL0+4dPJn1TnGYNh452Mb3ODh2fQs8G1MkERmMxarUDkFGUBIKoQqWzYjOMYsxlKtS3uIlmS1TmGwiaS5FtBdjyC4nVncbqvAvpEYqYcPhi2l1mrtj4Dm+2rqLQpUc8iKbBQDSANx4i1rGW/BXv8vy6zVz60eMEdn3Igxve4vmdnwxb/+fLHuf65U+Qa7QzKquUyXk1BBNRWquOhGt2w6y9pepKLIB8/1R+t/VRSg1WUrJMV8gDgkCocBLrtC5+0biWnVkjadVYWN1wJsbsOigYD4oCsvTF4WbI8B/Nueeey/HHH7/f8iVLliAIwtAD7J///GfGjBmDyWTCbrczbtw47rzzzmHvCQQCXH/99dTV1aHX68nLy+Owww7jxRdf/MrnggwZMvxnc+6556a1bQQBjUZDRUUFV199NeFw+N89tK/klFNOYefOnUO/33LLLYwdO/bfN6AMw/hGGfLHHnvs+xrHfwQqYXiZ+XE5DmY7LDgOopx9Sv7+kw8RSWbOqu3oRYElk+vojic5ft0u5jgs3FM3XMjtiEGxtxydlrZ4iq54kt3hOJdsa2WcxcBH7gCCACZR5Pe1xRyTm87wbgpGeLLbgwIclW3nsY5+dkfjLMiy8Xq/DwCzSsSkUnFhcTbvuf24kykCKRlvSmJ9IMx7k2rRCGlbtNX+MH/u6OeHBVn0ZMeJuFKoVIV85A3yXJ+Xt9x+ds0eTa1Jz+3VhbzV5+HETzfyc89uZp9xHg/Ul9EejXPTznYc7Y2cMTDAuPw83hzwc6TLytvuAMu8ISxqFe5kipPz9h63h+rLWOUP8UKvl0Pff5PWuz+j8Pe/o+8392A2ZXNcgY6lxWPpjKj4+dE/QK3VEg8HseYV8NLWnbyoNvNLSR7ygt/3XF5ZlkdSVpjpsDDjSyzu9hAdDOAcxaVEJZn/29lOg9nABcU5zHRY2DWolh+TZB7rHGCO08JIc7oyYlc4xmXb2jizwMWZBenJm0qjnhfHVZGoKyAVj2E8gJL3aRt287E3xKFOC0+OqTzguF7r9/FY5wAbAp0cl/UxR+ScQJmxijUb/byvzyOmZFHTr2IgGMegETDqVZh1AlKwnfZCF5FoFzuCMcDJyOZ3wHV2esOOSlJlh7O2x4J/MBseTqRo6Y0hkFZwF3f76HtpF9UnVFE+yok+nGTZ8m5SJg1Ro4bawr16AoIg4BgUfdthPRxVdwSHToXFoKaqwMhAUx9Fns/ZrT8Ru0WNRiUw4I1jE0Dr0JGlUzGw6h16tm1g9+oq9COPIpZUUHQmcmslRJWA3a4jnpTZrjOhFgTmj3Wg03zB9iw3D5VajUoSkTq8iAV2BFFgxTYf4bjEvFHOYWrmX2R1ox9/JMXMEY4DWqVZjYP3g7E/hESQiBAnENg0eAxUGO0NMGsUgiCSPSieNl2TICnJZFu1NPfkgyGLlR/+kvwpN/L7nS9jalXz4MIf0mAM0GLW8bdNr7KgbMJ+Imt7KDS7UIsqRnWvxNi7kkvsdXwQ9+DrXM/vm3chALMK68k12QE4Y8QhrOjaxlkj53LpuLR3+imv38mmgVZePPY6XIKfG1c8yWElY1jdtY2TRBOFjlxeWXQrs567jqQsce+ss3mucD7vptLibGa9nY+L53LC2JNg7k/SA5v6Y9Ca9h9whgzfAFmW6Ny2hZDPi9nuoHBEPaL4zZw0vmseeeQRrrrqKu69917mzJlDPB5n48aNbN26dWgdn8/HzJkz8fv93HbbbUyaNAm1Ws3SpUv52c9+xrx587Db7f++nciQ4b8MRZYJ9HaTiITRGk1Yc/MP2Mb4XXLkkUfy2GOPkUwmWbZsGeeffz7hcJgHHnhg2HrJZBKN5j+nZctgMGAwfLNq3q/Df9p+/v/KNwrIzznnnK9e6b+MgwXjB0NWlEFPaxFZAU8yRWcsyfZwbL91vckUnmSKW6sKuXRbK2pB4E/tvWwKRdkUiqIRIKlAQpIJyWkroy2hKPNX70QF/LaumCytmpAsIwPVRj315gSf+EL8paGcqXYzP93eRlM0wS+qCijQaVnpD3F0joOELDPv8x10x5M0mPVsCsVojcURgZAo4UmmODXfyT96vEyxmYjLMiesa8QoimwIxggb7IS06fLrw1zpMvpY005GDzSx1mBnfUG671Q/eGPM06k5b3MzcVlhgtWIShC4s6mbKXYTE4P9nOzpp/TF54gMDBBZswb/yy+T1OSi/skfuC0lc9TWjWwJdDLi0CNxFKVFzu4KC7TFvJyc76I64iMWClJQM7yPViMKHJtj/1rnbsThC4n6fdgLilgfiPBcj5cPlX5O0aSGlcW/1u/j1t1dTHebeXFcWvBuQzDC+mCEXLd6KCDfg9ZgRGs4sNiWZbCv3vwldnY/yHXQF09SottNKKlCK6aDtIU6A+HNPubNraAvkPaBF0WRXV0R/H6JScF2khYnihRDJUKO6EFXPp1gNEXT6j5UGoXKiVOpzVYRawnS4Y5xSIOTPJuObZ0h/GEJQzCBOpZC6gtjH5NNMJoimGVAJStkWdRkm0W2vP0aJlcWZZOmDY25TpaJvdeMvsMP59QjSQrjtt6My/M5SY2FXvXRFGXpkWxaPKEU+JMYdTLqyilkHwZCzTSmr3sfKaojOGMmnxXbqMozYidtYXb4WBeiIAwFzKFoCqNOxbq3XqW/rYVjr7oWcbeHgWAPa6U2RuVMocDlwhdKr/dleEJJwjGJREoeFpAnEl66u1/CbK7B5ZoJtmLe/8uf2PbJUo674WzQ+FGrTQiCGgQBv38joXArSdUsirNtqERhsHoGFEHDlG2v8GrJbNYGNiAA0ZYaji+qocwoctcON7Iy3L4sKUv8ZvVLlFtzmVNUj1mjZ3nZ4Ywrn8KNHe1ojS4+7/eSY7TRF/HzSdc2FlWnz8nU/DrebVnH8s6tHFWRbrmosOXTF/Fj0xrZ0N/MkvZNDET8bHa38XLe4fz+kPOZH+rmMJ2KnFAvMx+fy1LHBGpK5qIWVfx8yomYvliSrrd+6bHNkOGr2LVyBR8+/hAhz8DQMrMzi3nnXkD1lOn/tnG99tprnHzyySxevFfosL5+uKvIddddR0tLCzt37qSgYO/fjJqaGk477TT0+kwLR4YM3xXult00fbaMxD7Zaa3JRMXUWbjKDpzg+C7Q6XTk5aWfcU8//XQ++ugjXn75ZXJzc3n55Ze5/PLLue2222hpaUGSJNrb27nsssv44IMPEEWRI488kvvuu4/c3L2Vo7fddhv33nsv0WiUU045haysLN5++23Wr18/tM5jjz3GXXfdRXNzM2VlZVx++eVcfPHFALS0tFBeXs4LL7zAfffdx8qVK6murubBBx9k2rT0c8C+JeuPP/44t956K8BQUuWxxx7j3HPPpa2t7UvHe8sttxxwP1944QVuvfVWGhsbMRqNjBs3jldeeQWTKTNJ/3X4RtGmKIr7iZcBWK1Wamtr+dnPfsaiRYu+s8H9/4hZreKzqSMRSQeDI0wG3phQTaVBhzeZGhbgn7i+kW2hGB9OruWOmiJO3dCESaXiipIc/tLRzxynlUlWI33JFItyHdzR1MWDbf0opAO5YEpm4ZqdjDbq+XFhNmdsbCKlwPsTa9EPZoxnOy187g8Tk2UWZNs4PMuKVhB4qH2Arng6iNsUijHNbsablJCBo7Js5Oo05Oo0bJ81CoDNwQibg1EMKpHn6gpZ/8FbrDTa6Wjv48LiHADOmzCGzTEfR5RXcVl1Ofe29hKRZJZPrqPcqOOh9n56Eklu393N2wN+ZOClPh+Pt32OJZWg47e/Y7peh6GhnoGzb8cT3AkspyHWgNZiRXY3Ew+Hho7fn0aWsj0cZbLNxH1XX0AiGKTqlns4fsRw9exPvEF2R+KcXZgWolMUhRd7vdRbDMN6/3UmMzqTmWB/H6xYwnXmHCzdrQzoQkMB+Y5wjFBK4uRcB0fvE+gvynVgVasYZz24ynVEkjGIwrDv0G3VhawNRFAd4Hu1B6taxdW5WYSWxTCMuQCt3ow3lOQTk55pC0dQW2mjY2P64XVchZkub4J8uw5t0XnkxCKEtYUcW2cH0jfTT9b0EdWo8NuWsaKjhaNyTiUc0yAr0NofJcuqxaRT4w9LdNc4ieabMBRZcHSGqS00cYhejabpLcy9nxO2nErs+RdIGo2wT0BucxlI6NVonHokSebDTR4Ki89AKp5GKH8mKRla+mL4c17FoIzAlqxBkRWCMQ2WUXOQowGskh9J0BBxx4hb9ASiqaHtG7R7g+ouT4yVO/1oVKDx+ImFggQG+imoKqbDt5M2pQ1dyMy8kqMOeoz3ZfZIB4mUMqQQv4dUKkgy6SMW6xlaFvb5SEZjiMlyiir3PpxLUgyfby3JpIdmfzGJWBE1Ji9iVjVTa+10rvsHS0tmMLduNm/07kabimH461EYjfnMvnAFM0caMH/BvqzR28Vft3yAXWfi1LpZfHra3bQF+9nqbqdSXsrqvkbkeIRFVdMYacvluG1Pg2cjTLmQz3t28nHnFgCOqphEOBljQfl4flA9jXyzk1yTnbtn/5A6ZxEPbHiTLIOVI8snwN3V3B5xw7wboOU1jiys47KFP8X6JWruGTJ8W3atXMGrv/3VfstDngFe/e2vOPaq6/5tQXleXh5Lly6ltbWV0tL9nS9kWeaZZ57hjDPOGBaM78Fs/uoqrQwZMnw93C272f7B2/stT4TDbP/gbeoOPfJ7Dcr3xWAwkEymn6cbGxt57rnneOGFF1ANaicdf/zxmEwmli5dSiqV4uKLL+aUU05hyZIlADz55JPcfvvt3H///cyYMYNnnnmGe+65h/Ly8qHPePjhh7n55pv54x//yLhx41i3bh0/+tGPMJlMw5Kl119/Pb/5zW+orq7m+uuv57TTTqOxsRH1F0SETznlFDZv3szbb7/N+++/D4DNZkNRlK8c74H2s6enh9NOO4277rqLE044gWAwyLJlyzJtOt+AbxSQv/jiiwcMyH0+H6tWreLMM8/kr3/9KyeddNJ3NsD/H/h9Sw9bQjF+P6IYk0o1zDrr7E1NfOINcUKuned6vDzWUM6R2elSda0gIAPvDwS4tDSXP40oYX0wwlyXlT+09fGO28+fRpQQlGR0osib/X7iikKpXssr46s5cvVOehLpm8B73iAleh1JReHQVdsJSzIn5ju5paqQl3q9/Kqph7Zogie7PUBarA2gVK/Bm0jxqS/EzlCUUWYDJ+U5OH9zM/NdVk4e7J2/YVcnCUXhjsp8xuVm4Tx8AVM2d0BjFxOsJibaTOhMZnrGzWBFJE6ZJHNHUzcnettYqlNRuXAhPy5JB+6Xbm1FI0CpQUdbLEF73XiCXg9njRqFYVCNvOK6RRi2bWHbrl3s0Jkp276RcaefitGxN/s8yWZiki098ybXj6elo4O+lIrjv3B+Lt7aSm8ihUYUOMRpYUc4xiXb2qg36/lgUh0A8dZWOq+6CtvRRzNQVkR4oJ95OgOu8eNxle+9qV+6tZVNoShPja5gnsvKxmCE8ze3ADDHYeHtAT+n5buGxiXJCuGYRFMqwbFrd3Fcrp37Rux9mPOnJHrjSZZ6AnTHE+TrDuxnHlnTi3vFLuI9m6k69TAkWYWsQHIwieo0a5HlBGaDhjG2PVmYcmyA7QvbKs420NkZRkKFFxGNSkVVvpGdXREUBT7c6EYlCmRZNAwEk9gq7bT2x+gPpej1xRlXYcUshEGR0UkSxuUrQRCQolFSah2SrGDMN1F4yzTiSZlub7o6pDN/IZ2AKJL2FiQFCSs62Uk0oQAKaFTYuoKE7QaWVs5BlxQRVK24TCOQZYWBQILG7gh1RSbsg2Xne7LYSQkqZh/P+DmzyS4pA2B0/lz0oRzKjFUHPK4HQq9VcSBbeaOxhKKiM9Bo9h7Ro674GdGAH4srPdkzEEjQ6w1jkJ4FJOKayfSn9BSuuJOVhgaqxiTIK6+HKUdxz5IeGncsZ21vI6IgknCORhezYNy4GWbN3u/zR7iKuWXaaRRZsvi4YzO3ffYc3liIYDLKKFcpigJmjZ6XGz9jQuVoVGv/CqZsmHIhR1dORhAEJuVV442FmP/8TQSTUTSiitVn/A6dWsMxlZMB+O0h5+/90Mp54G2ByRfA2DOYYDmwFkSGDP8ssizx4eMPfek6H/31ISonTfleytdff/31/YJmSdqrh3DzzTezaNEiysrKqKmpYdq0aSxcuJATTzwRURQZGBjA6/VSV1f3nY8tQ4YMe1FkmabPln3pOk2fLcdZUv69l6+vWrWKp556ikMPPRSARCLBE088QXZ2urXrvffeY+PGjTQ3N1NcnLbKfeKJJ6ivr+fzzz9n0qRJ3HfffSxevJgf/vCHANx00028++67hEJ7E1C//OUvueeee4aSnuXl5WzdupU///nPwwLyq6++mqOOSicfbr31Vurr62lsbNzvvmQwGDCbzajV6qFs/9cd74H2c+3ataRSKRYtWjQ0YTlq1Kjv4hD/z/CNAvIDiZ7s4ZxzzmHkyJH85je/+Z8LyP/a5aY7nuTy0pwhL/A9GFUialFAK4oIgEqA7niCCze3sCsSB/aWK3uSKR7uGKA9luDRhjK0oshdLT080N7PQ/Vl3DeihCPX7KI1luDI1Tvwp/Y+LFjUKpZNqUNSFOqXbyYBPNXtwZ1McajTynsDAV7s9Q0ppkcHfaxaY8khSSx3SsIdivJMj4e3BwK83u9HK4pMbbVznMmBziEyz2WlP5EkbjAP9Rk3RWJMHAxAr97ejjclcYjTwhXFWUxq+pR3bHm80NrFmGwXdzX3cLYvh9vqi7Bnq0jJCuqDCFflj6gny5nFU/fcicXhwPCFHuzmSJv48lQAAQAASURBVByjSiRXp+HiK67ixR4P4wN9/O2TTzlx8kSMgz0tV5fn8bEnxJXb26k16Xl5XBVHZduY5bAA6TaDzj/eT3zLVvp3NyHeezfRrbt4XnQx0Rpi36v5rAIXH3mCjB3MhH/oDtAWSwuFvdnvw52SCKbkoYB87W4/He442UV6ZBRSg8f9J9va6EskebShnHkuC++7g7zQ4+XSg4jfGcflEG5dSSDRQ+/ObRSNHs+C8VlEkPlLRz/TzUay0KISBRRFISZH2dTuwefVM2OEA5NeBZEB0NupL7FQXWDi3fUzKIxOJbs0j5wSgZoCE6Io0D4QQ6sW0KjTKuh7LM90agF3MIk7mMTScApNXQvZ3Bmn7Kob6YtA164wwUgABZhcbSMpKWxoDiArkO/QDQXmsrznfKux+eZQlGwkkZWLO5gCGfwF6fOisubhX/cO8YqpiNEQ7pCBcEcQn1GLTlEwmDVEEzJjyixkW7X0BxLkOfU4LWVDx00jaqm3jjvgMf0mSFIUt3sZJlMlcclJUkqQZdWi1miGgnGALW0hvKEYDdlqUCJ0htfzi61bONlayri8IyEsoYkm2eHpYG3fbhQUnjzqatSCCp3KDGvWwEEe6Je3b+e93dv4yfhj+bh3LW3Bfqrs+YR8MZTB/wQEZBSaDbko824itOt9XnznTnJrDuP4qrQCuy8eRi2KWLUGii3ZbHG3Mb53DXx4Gxz3RyjfZzJg0Z/3/qzLZPgyfH90btsyrEz9QATdA3Ru20Jx/Xfv8DJ37tz9ekBXrlzJmWeeCUB+fj6ffvopmzdvZunSpaxYsYJzzjmHv/zlL7z99ttDmaADJS0yZMjw3RHo7R5Wpn4gEuEQgd5ubPmF3/nn75m8S6VSJJNJjjvuOO677z7uv/9+SktLh4JUSIthFxcXDwW3ACNHjsRut7Nt2zYmTZrEjh07hkrP9zB58mQ+/PBDAPr7+2lvb2fx4sX86Ec/GlonlUphsw1PuezrfpWfn9bE6uvr+9oThV9nvMB++zlmzBgOPfRQRo0axRFHHMH8+fM58cQT/2sssf8VfHsj5AMwf/58brjhhu9yk/9f8MSoctpjCYwqkYQsoxVFWiJxbmjsYLTFyAMjS9GKIrdUFWBSqXh3wM+qQAQAm0rk2p0d7AhFUQ/+IS/QaQikJN4a8AxmEmGtP8yxOYWcVeDiiS43PYkURlFgnMXAPKeVQ10W5qzaTn8iSUCSh4L/o7JsHJvj4PHOATpi6Wy6GkgBDrUKb0oiObgf4y0GDs+ycVq+k5TSwQfuAHymYdnvZTqq1GRfqaYjluSHm5rxplJDwf1NuzqZ4TDjS8ncXlPE7kiMerOBUZYizumexDspNWv7QxypqNixMknP33UkG2DefQwF4/27d+Lv6qRsyoxhXuGi04FQV0VIUUhGo8TDId6S1LSu/ISsoJc/F4/isznj+HvbAM+0uvnA38Zrljxat7dw46hqAM4qyMKbSPFaf3qfHRo1jzTsLQW6ZnsbLx9yLPf39jF54RGo9VakN97h2E/XcO+1NzNn5zaKxkwA4OzCrKHS9+e73fy6uYfDXVYWF2Zxe1M34UiM8wZf3xSMkFSBVi1QbzeyZUYDZrUKRVF4o99HRJbxplLcVFnIKLOX07/Qe74vKouW8gWz6Nu1HTGvklA0hTnewe82rOMPcjlHGMwcj4VQLEUomqLb/jJJMYAzdRy+D9eT9MSx5y2HvLHQcAqikD726n08ojXq9EzynIa9Ex+KotA+ECOelGgoMROMyRQ4dSAIhJMCkqzQOeEwYkkFVUweuia6PDF0mrSOggAEI3Esmk7CqTxkJX3b0WkEDAO76NY4SfmTiIMVI2qVgEkv4g4myR85GYv+DdRqiUDXAlxLBugvs6JzR9k+vQhFJVKRZ2BanZ1kSkav/X6EnyKRVgKBzUSjXQSj0BmawMyGkXjDSdbu9lObD9rUy5TZCnBZDiEv62gaWz+kyKTnlFon54w4jIR3C9v76mhf3wPqt7l/3vmMzKogz+TAHQ2wdKCN2YceNvRA/8UH/L9tWcInfRuY9lmIC0uzmXDEFYzPrSIuJUlKKWY/ey1JOcW7P/gFZo2eN54+l6PbV2D09vK7UCRdgg7YdSaWnnIHrzV9zvXLn+C3a17h70Iv+Fph/VPw/Hlw1G9h5LHfy7HMkOFAhL7givDPrvdNMZlMVFUNr6Tp6OjYb72GhgYaGhq45JJLWL58ObNmzWLp0qXMmTMHh8PBtm3bvpfxZciQIU0i8vUUzb/uet+UPZN3Go2GgoKCYYJmX+yXVhTlgJN0X1z+xXX2LfWWBzWkHn74YaZMmTJsPZVq+DPPvmPZs8097/86fN3xfnE/VSoV7733HitWrODdd9/lvvvu4/rrr2flypXDSu8zHJzvNCCPRqP/k6IlDRYjbbEEM1Zu55Q8J7McZq7a3kZCgY3BKD8rz8efTPFir48jsqwc7rLyaEMZOlHgxl2d+KMJHuty49Ko0AtQrNfxVLeHVf69N5MPPQHOCLt4uttNnlbNKfkuTs938qvdndzT2sv97X1DWW+XRoU7KXFlaR4n57sIpSR+X1fCUWvT6stFeg0tsSRzHBYkFF7r9+NQq7h3ZCk37OrkruYeflyczZ3VI+hsldhUkmBLVRCjJHP2xia8KYlSvZbLS3L4Y3s/To2K0zc0sSMSZ2GWjWtDHaxf+xGqmYdz79Sx3N7UzcTtmxi/fCeWOadjXqmQPXF4GdHd21tYLeh4pLsTa34xF25pYbrDzFVleYw4bCGKotCxYQ3dWzfy+siZLPT3U5yM8uvdn9GWpUKIZlEkarDmFFOVSFIX8bLqqUcZOf8YzFnZZGnTN6kTcofP1iVjUT5t7yRsNPGL8y7lk0MmIEej9B+5kFctLsYJSXKq959ZTHk8jPjBsdyXnY/7vvs5xGXlV03dqASBUoOWnniSI9fsxKxSsX1mw343uDcm1BCWZPJ1WvJ18H/7qPvvwffCC0TWrSPvuusQjUbMWTmkDA4+2uTBpEsyP6uLY5I72W7M4ZyycuTeJD1hN7IqiCblwGASmS0tJd6cT3OOHZu6AWvKShagVokcMS49cbBnbP5wko0tAdQqkap8E9k2LYIgsLU9RDQhE47LFLnS3++UpJBr19LYEyUpKdQUGDHr1ezuDhFNKHSHfNy940EOyZnMeOMMQnFw6cOEU+lrVKsWqM43kVdcxZr2BN6kgKyASoQxZWZu2N6JEZEf6G0UWrJJpcKMmlREe2sKxaZjx8hstOEEWpeejc1BUrLC7HonsqzQNhAj26pNVwV8R5jNVaRSs4jH+0gmd5BndaPXivh6k0gyNPf6qbJHUasD1JeYaelV0Rw4FHtKxRV1TUipLXilDRg1TmJSghF2FbkuG1ZT+nq8bvkTLO3YzG/nLGZhxUTuWf0Sj2x+DxGB46umMi6nkgvGHEaZqYhzV/4U9YYeXh/xQ/onnj5Uav7I/Et5bscyvH07eGKgi1dlGzvsY4jUHcutY45J70jnGtZIajyKwhGl49jt62Zu8WhwFcOIY6B5GYT7YWDHd3bsMmT4OpjtXy+T8nXX+1cwcuRIAMLhMKIocsopp/DEE09w880379dHHg6H0el0+/VyZsiQ4ZuhNX49kbCvu9435UCTdwdj5MiRtLW10d7ePpR13rp1K36/nxEj0iLEtbW1rFq1irPOOmvofatXrx76OTc3l8LCQpqamjjjjDO+s/3QarXD2nK+7ngPhiAIzJgxgxkzZnDTTTdRWlrKSy+9xFVXXfWl78uQ5jv9y/Dwww8zbtw/Xx76/yPZ2rRPdZZGzaXb2oB0f/atVYUkZJnLt7XyjjvIL3cLGFUqbqsu5EN3kKboXl9kT1JCIe3r/diocrwpiet2dhAazHi/0e8jV6thgs3EtRX53La7i1f6077UCVnhjyNKeKvfz9pAGIMoYFCJ3NXcze9aesnSqEkqCj8pyeaRTjcAL/f7WJhtpcao44RcB1VGPbsjcRTg711uHmzvTyfoz4VpNhNP1Fcx+pPNAFxbnk9EllkyuRadKHL19jZ2RuK8OeDnfG8nis/LX1esZNT4SdxVW8yOs04kGQhwzsIFfPwrHUdsaubYLTZWu/3o1GqajDkowBLRRH0kxnJfiP5kiqvK8nAO9gMnoxE0egO3FtnZVXQkK9atZXp/KzsH3DQ6HbwZDPEDp53l9WVs//Bt3NEoiUgIyOb0AhfH6EDT2wuFe0uM3+jqp1mdFs+a5Hfzyc2/YPKPL2DM3Xfyfksvh2XZDnhTVxIJVNEoE+Q4FSU5RCWZRbkOZtjNFOi1RCWZ6XYzOVrNAWcb83UabtvdRW88OaQpEN2yBe/fnyTrxxehLSlh4KGHSLa2YT3qKDqjASSThRu1OVgEgWtcOVA0lQZTHn+1FUEiRKTrA96R5oBkZUKlgypbOZtjveyaABpZoUWswoyKwwfH8MVxrdzpIxxPz6TKCmTbtIRiKaKJ9LJwLEUiJaNVi3y63ctAMIldJ1Fhk0lqRNY2BajKNyL647R/sAufPQSyhhGFJtrdEdyxWmxGFYGIRCKl4A4mqa7N45AcWLbFw0AwiV4lsKTJz7upMCJwd2wFO9vKSdhrICTQPDqbUExGFEDl0DO23Mry7W5SskJ7YAAhaWZdU4Bcm5bpI77Zg7uiKHi9K1GpjNhs6bKvaLSLcHgXDscUHI5J6T59cw0mUzmCIFBXZMIbTmI15JGfdw7LtkZo8nshGQE0GHUqPJ5PAIW83Pk4HT58vtXoTbVYTHu1CeYUNeCJBVnetZXHt3zADk8HsqIgo/B5zy6e37WCYysnc9fsH4Kum6Yd7/FqOIK3eS0zC0fi0JvZ5u3kjZa1bN31ET/Iq2Z0yTiOGHczDdmDmgWrH4PXf0K/sZifZM/ivRN/wc8m/WDvASibCSXToGY+5P9v3scz/PsoHFGP2Zn1pWXrFlcWhSPqD/r698mPf/xjCgoKmDdvHkVFRXR3d3PbbbeRnZ09pGL8q1/9iiVLljBlyhRuv/12Jk6ciEajYdmyZdxxxx18/vnnGduzDBn+Say5+WhNpi8tW9eazFhz9090/Ks57LDDGD16NGeccQa///3vh0TS5syZw8SJEwG47LLL+NGPfsTEiROZPn06zz77LBs3bqSiomJoO7fccguXX345VquVBQsWEI/HWb16NV6v91sHvGVlZTQ3N7N+/XqKioqwWCxfa7wHYuXKlXzwwQfMnz+fnJwcVq5cSX9//1cG8Rn28o0C8oOddL/fz+rVq9m9ezfLln250MJ/K5NsJnbNHp0uMxHSgm0hSeLczS1MtZnQDgY/EVkhIqe4v62P0fv0m48360kBG0MxUkBHPMlos4GQlA6GdkTi3N/Wx/wsG/fUpWetDnda+WNbHwBlBi2HOK1cvq1tT5U76/xhNoWiKMBEm5H33UEe7XQTlPaWr3zuC9OflPhdSy9nFrh4d2INd+zu5m/d6aBdI0CeVsO6YISnut1cU57H2kCEl/q8vOMOcFdzD6fmOzkux87fuz2IQFn9GJqXf8jx/i56VCIpWcF752+o7mxDX1uLv9uDDCxtbOWxX1zD6zPmsfuE0zCIAlMcZkaajTw5qpz+ZIpgSsKiVtEajXNDQo9z/KFc5MhhvtmAxmhmeUc3F4+spFaSiWvg7MJ02Xf17EMpHjsJk3NvGXjrr35Jsrubup9di2HsWACeDCRwSQkmagUKX3sF5/IP8TqsWBefxw+9LeTnNhzwfGvy8qj64H3EwYqQ53o83LK7iyOyrPx1VAUGlcg/xh58BnWZN8hfu9ysC0aGAnLv00/jf+klNPn52I4/DlGnx3r0UahGjmDg+SfpNVhYkW8kR6umviTdZ41z8IbdtwWjZz2lNhd+0UKpJR1QGc0WVJ4guS49nZ44+c79fa1T3hiIAmqViCDIlGbpKc9LX5smnYrqfCPuYILNbWESKYX6EstQeXvI46Zj3TLKjzkHnVrArFfh7E1h69XzYPGP6DPn0e2Lk5LSigPBqIRaBTqNirHlFqJxCaU7RH2Rka1vtlK6oQ/9+DyuqctmhNnAil4LEdEMAYWeQACtGgQk9BqBSAJA4KPgW6zs3sV12ScwJ288FoOKAtc3r9RJpfx4PCsAcSgg93o/JRJpRaNxYLWORJaTKIqMN7Cd9zo7GJNTzayR6cA6lpBISknUkszo4Dt0CcWMzGkgqT0WWU5gsYzA718PyBg0VoTVj0DeGFDrON2ZxenH/JxjXvoF/mg/N40q5/oNuwCosOVRZMniqPJ079Y/bCNYW6bltvw6blv5HAtevIUlJ/+K46umcv9nT9OssTHQu4WHf/T88B00pfu9nFKME4vryTMN12QAQFRB4YRvfOwyZPhnEUUV88694IAq63uYe84F/zY/8sMOO4xHH32UBx54ALfbTVZWFtOmTeODDz7A5Ur/nXE4HHz22Wf8+te/5rbbbqO1tRWHw8GoUaO4++679+v3zJAhwzdHEEUqps46oMr6HiqmzvzeBd2+DoIg8PLLL3PZZZcxe/bsYTZiezjjjDNoamri6quvJhaLcfLJJ3PuueeyatWqoXXOP/98jEYjd999Nz/72c8wmUyMGjWKn/zkJ996bD/4wQ948cUXmTt3Lj6fb8j27KvGeyCsVisff/wxv//97wkEApSWlnLPPfewYMGCbz2+/zUE5Rto0s+dO/eAy61WK3V1dVx88cUHtAP5IoFAAJvNht/vx2r97/Wt/en2Np7s9jDLYWaBy8p1jV0AaIEE8PSoMs7e3EpSUbCqBAKSwmy7mUBKYmMoyr5dHxcWZfFwxwAy8Nb4asZajQiCwJNdbq7Z0Y4M3FFdxHtuP2FJ5vqKfE7b2ERYkhlnMfDYqApmrtxGgUaNT5Ip1GsBhe3hGBpBICDJ/KmuhM8CYZoicT7xhcjWqulPpNBHo8QMBi4oyiKhQJVRR6FOw32tfawNRhhh0rNt0Gf9MKeF3+ii7P5kKX/NruQNax6n5Dl5qtvDbdWFnF+UTUySafhkMzqPm6duvRq5sJDGvzzOa30+3nUHeLyhjBt2ddIRT5KtUfNpVTaL12xjqdEOwDHZdh5uKPva50FKJQl73Gx67QUAxh16FMay9Pt3hGN0vP482pCfjUUjGf/xR0y85CI62pvp2rye/JGjqJi2v+L1F+mIJbi1sYtT8p1sDEbwDvrLiwcR+EnIMg+19zPFaqQ64sOaV0Cquxv/K6/gOO00IitX0nnlVZhmzaLk4YfwdrSh0evZpjHh0qipMOrYGlhPZ7SFuT4RtahB0RjYnVwLAhTqzsBQfHBF7FhCIpqQ6Usm+OPrWzmzM8WEKycjicIw7+14UuaddQMoioJOI5CUFOqLLVTkGfGGEgxsWokKhdyScXzUFUWjFphXb2Jg9xIiugo29TnItWuIJhT8kRSiAPPHujDo1AQjST7Y4Mboi1MfT9IeTOLsCNIzMZeKkU7adwfo0arJswr0BNK3KbtRRY7uJXTqFILxVMpzbGxbup2NyRaOnT6DxgGBpt4otYUmRhanRcg6BmLs6g4zrsI6pMy+B1lOIggigpB+yPf51qFSGbFYatPHKdZNMLgDb6wMJbESldINyKx0hxjvMBJKCUwa+dO95zUlIwoC6u7PIdIHVQvSQe4+9Aba6djyLhPeuSo9oeJrT6/zfy30JGL0+7by1q63eKzZjUVrYHHvOXxs+JRfnno8oVSMU16/k0t8Gznc5uRqxySSskQk2Mc5kpuKaC+fGfI49ZhfUZ5TCY8cAf52+PEnYHCky9ETEXB89X06Q4YD8X3//T6QD7nFlcXcc/69PuQZMmT4z+LAPuRmKqbO/JdZnn1fHH744eTl5fHEE0/8u4eS4V/EN8qQf/TRR9/XOP6r2BaKcum2Vn5YkMWFxTmUG3QEUxK37O5GNZg9T0gyepWKbK0atSBgUQlsCcdZ7gvxRfmFC4uyuLW6iOd7vQRSEidtaGSyzcwZ+S7ub+tjT/jk1Kp4akz6JtQYjlKo0xCSZO6qLSZPp2H99Ho0ooBOFJEUhd83d7MuGMWkUXFenpPl/hBPd3u4qCibK8tycWnU/OjTjfzuuotpraqj5rFHmL96J06Niq0zR7Eg284afxijSuCcTS10xBLYNGp+4BMprZuB0WikNC4xwmTAoVbxcq8XETivKJvtM9N2CMJhSxG0WsZptTzX40ENaASBvngSfTyGo72bxmWv01LSgGiw0mAxsSjYw5rnlqE75Aj+2B/hwuKcIf/veChI08rlOItKya1N9/c1LvuIgaZd5NbVY3K4hoJxgFqTHn1lJf7uLi6YPRXNEelJpzyzCVmSyB/59dR8i/RaHm4oQ1YUzt2U9oO/qDhncOIjjRyPE9uyBcO4cWhFkUtLc2lds5It61dTNHYipROmkH3JJQBYjjySIp0efUO6PNNRVALApH0+M9r2EShh1L1hQECYeyvGVQkkfwTtrHT2MxyMs3Sbjyybhsl5YQKafLo8MTrcMYJRiU3mJP8o0mA2apisEfdTvFeJAjqNQCSuDFqTMeQH7jBrcUybRawnTO+f1sFh5ajsOqKxZsKa7Sj4UZhHjy8tG1jo1NLpSdDjS1CaraLrmR2IVU4ktUjAoKc7z4Kn1klcBnd7hPKN/ZSUWmkj3TKgVsHEKivufhXJZIq2vigDmwLkLOukpLSZTW+4kYXJWHJMNEV24+vSMr1gBD2+OBbfRtgZgDFHDwXIkhSjtfUxVCo9eXlHAwJ2+/BSbb0+n7aeFlrcPpx6NTaNgPzGNsaOHEnYKqDV2Yetrx2sHKBo8n7XiCzH6ex8ng3uAW7cupmXqhZQNvIo2PEWqDSg1tPt7cZkLOPxFg8K8Oc5l3HXg0tZV7mBV3cU0hLtQQHODO7C7o/z2jH3sCYFN3x0D2NTvUxoX8/c0adCzuDDSKgXoj5IDbbGmLLh+2mry5DhO6F6ynQqJ01Jq677vJjtDgpH1P/bMuMZMmT4z8RVVomzpDytuh4JozWasObm/0dkxr8JkUiEBx98kCOOOAKVSsXTTz/N+++/z3vvvffvHlqGfyEZdZHvgOXeINfv6uT6inzmZ9nYEIywJRTjY1+IH+Q5mfrZVjSiwNkFLjaFosx1mmmMJKg06nhjfDXrAxF+vbsTALUgoBMFgpKMGni4oYwjs9Jlbo80lBOXFM7ZnM58X7Wjfcj67FdVBZhFkZW+EHk6DedubqExEueN8dW80uvjT2193D+yFFEQ8CZTzFm1fSiQH0imeLrbw6vjq3DHk2wPp3u4Ly7J5vcjSpGzc5mY46TMYuR3dcWUDAaZf+no57U+H/fUFbNq2kjCkkR/PMmsVTuQ9Fo+G1czdIzytGp+tLWViCRzXlH23sBvH9/XVf4wKeAdd4C/tGxC/+AD5MycjunMM+lyS1hEEVD4cVTL3dEE23p8vOyOYFGrGGc10hqNs2jtbuxxA/nb2/iNwUBeSTkmpwt/Tye5NSOxZOfsd/5KJ07bb5nBaqN82qyhDLciSQiqr34gFAWBJ0ZVEJCkYcE4QN9dd+N98klyb7gB55lpYQ5Ldi56qw1LzvBstiAIWOYduCIFgGA3E3r6kNRalFFnIKjUoNJQMG3+sNU8b7WQKLIRcvezpXcnu3VqJEUky6pBFAROL7EiGEQWT8tC2HNOWpbAwE4itSfjS+mJxGUEARQFilw6RhTujejWNwdo7o1SPCqHSf1hcmYXoChWkkkfRmM52TkOVuzwkUgp6DTp49fpjhFLyiRDSczuKP58M9uByjwDFoOalr4oibhE/+hsItq9t6iUBB2eBLXFZ/Pqql4UVAQNkFWRjSj2oLfn4FrSx305n/Nqyy5EQWD5qXdhc0ap6FyByh2C4DiwlRBPyqRS6f0CaG9/CkEQKC//MaI4PItuMjrJCq/B0zaWgTdmkZrQQ/XAGkzj53LN8r9xZnIZp9bN+qpLA3c8TDzeR4VJQ11eDcrMs8GWC+PPQpIitPk7OP2N31Co1XFncRX3DPRzxnt38/v5P2FCNIe/bH8TSZE4d+ShqA45A+IByK5hQiLC7VUj6QkmaC6eSvm06/Z+6EXLIBUHU9bBB5Yhw38Yoqj6XqzNMmTI8N+FIIrfi7XZvxJBEHjzzTe57bbbiMfj1NbW8sILL3DYYYf9u4eW4V9IJiD/DljlD7MjHONTX4j5WTZOznOSq9UwzmpEAZKKgizDXzrTJXgrB9XTm6Jx8nUa3uj3D21LUhSCkoJA2prs5sYuGixG3h7wc+OuTioMWk7Nc3JKnoPTNzYBMNKoGyqHFwCXRs3ioixW+cPk6dT8sT3dZ35iroNqk57/29lOMCUNqbJfXZbLBKuJZ3s8vOsJohEEkorCxVvbeHd8NbzwIr/vHGDhgJ/T8tO9cgOJJDfsSk8ivNXv57JSPSaVCpMx7Ydu+ULw+tuWHgB+Wp530OP4wMhSHu0c4G9dboQJ0/jpKQPYjj8eXUU5H0VieJMSx6zdBYLIsjGzuGVEBY4uNz/IddAbT3J/Wx+dEvTqbWwx2HkqJBHZ3cWkgkrqa0dh+UKA/GX8uqmbP7X18fSYCurffp2eX95GwZ13Yjvm6AOun5IVlnqDTDHrmbxjM4YDiBvq6+tRF+Sjq07bsa0PRFgi67lw0ekYVMNndBVZxvfcP9A3NGBoOICIkSkHimegMmXDPn3uys63SHV0kspdiKG+AHuuEZs3SiJLT69SjKSI5Nq1jK+wDlmE3Wg1DN9272YIdrJx8256xCIqN/chChCcXkiHO04gkqKuyEyhS488eA21l9iIWNTs2OpFqxaZUjMdQRDo6AoTTyroNCJ2k4bqfIFd3RH8kRTlx1dhCCXwB9IZ9wKnjiyrjvJcI7Ks8NrnfcgKiAJDXuh2o5p3PulDI/tJaSxMKVOQ6+tIdpdQUWhCk+PD2dsOPbs4tHgM1y//Gx+3b+XhiYsZZUqgVix0frKUnbo6UjIcPmYxOo1AT88bCIJI4I23UdsdmGfNHDochTm1vH7T7YgdCeyq01GfqbBNOYKKlg9o9HXzee/OrxWQn7Spj0RiMo+PruXp6iySssSS9k1MyCmjv/NvxCSYVlDL5a1vMnbZo8RqT+EenZUR4xxUpsbxl5dfA8AQ7sGSd2i6BB3ggemMj3rx/fBlLFn1oNrnOtdZ0v8yZMiQIUOGDP9xGAwG3n///X/3MDL8m8kE5N8Bl5bkMNpiZIY9ne0VBYG5rr29dZ9OHcHOUIwFa3cNLcvWqNEIAm3RBBUGLc3RBHpRGAqS9zT2t8USPNDay6NdaZG1pmiCpqib5mgcXypd3L41EkcFSIBagJkOM52xJBUGHUFJJkerpi+RIizLLPUEWeIJcajTQl8iSXM0wet9fsZZTeRp1eRp1dxSWcBNKzeRkmV+vGIDzXojMrA2EGaO08I9zT3k69KXjgCMMxu4p7mHhCyTr9PwSOcA85xW6kx6rt3VwSizgT2pyFd7fdzZ1MOf60vZFo7RFIlzVVkuoiAwzW6mxqjn4q2t/NUd4p0ph/N+YRHbgxF+uKmZM/JdQx7qdSqIXncdi089BTHm46WnX+D5yYdwbNMOjhtdR6i6lut2dRCWQgCMtxp5c0I6Y+9pb6FfZ+L0xj6OzbFzc9X+s6ueZIqkohBKyUj+AMgyUjBw0Gvgsc4Bbmzs5I7VS5n6yIM4Tj+NvJtuGraOfdEJ2BedMPT7LY2dfOYPU6zX8oO84QJb4RWf0nPLLeiqq6l47VUAWs86m5TXQ/lzzyEajVD7hckBfxtC28dogMCHn2GoX4RlTjHxtf1E4hJ/anuVkc5S7pt6zkH3A4DRZ0C4D9GTiymSwtYVQhWT8E5K2/gEohKrdvk53qkbEncDcAdToCgUS7uQK6eRUkQ2t6WPv14jsLYpgCBAdb4Bq1GNIKSDcwCLXiTLqiMQSbGrK0x1gYmJ1Ta2tYeoLTQRiUsIgoDJoEaSFMzRNiKGQuK9/WxGTyKlsKE5wPzxufyc07kidSIGtZY7Vj3PVJeB3nABslpLwcfP09ufQF1fikZvRqNWI4oiBQXHk+joZPc1hyFoNNRu3DBMhb52+mz6tzai//zP3LGthTytyAuJLbzQcBolY0788uM5SIPZwGqPnvdb1pFdM40Xdq3gN6tfwqTWMd5h4ucNNTwy/yyEtTaID2CqPgzt7rXs8HTytw1vAGCUk2SvfYyHd77DOec9i1ZrBLUO1Hrs1vK9wXjPJpBTUJBRS8+QIUOGDBkyZPhPJhOQfwdoRZHDXAcXtzGpVIyzmbijupDlvhBv9Ps5ryiLl3p97IzEOKfARVjyM8Vm4q0BP0kF6kx6flqay+/b9gbjexCBLaEYJXotelGgO54kMKicnlSg3mzg9qZuAJ7q9nBNeS7Pdnsp0mmY57TQGIlxmMvKxVtbCUky2yMxPvYEeaLLTUSWaYzGCZjNxEQVpkQMp0ZNTJbZGYnzx9Ze7m3ro1Sv5bzCLB7tHODKne20x9J9wlkaFQNJiV2RfrI0amKywueBCCfnOtgZidEVT7AzEuPZHg+PdQwQVxQmWo2s9If5XWsvAjDXmc7o9SRSjFqxhZ+U5tIVT/KhJ0BqcP9P/Gwp7tdeA0VBDoXoDyexjpxAOBhi4srl5M6exq27O4lIUG/Wc1S2HW8yxc837qJ61wamaRQ6nSPY7gvRffMtaPLzyLrooqFjfEdNET8pzaVAr4WLLsR27DFovuAruy/jrUYmSjHKLSa0ZWUYxo3/yuvm8tJcagb8HHqAa8cwdgy2447FOGUqkLbkirc0I4fCyLEYotFIry+OxaBGJcgoqQReRYOidZKQSuibNI09+vKjSsx8uL2LArOT+VUjUFIyfQ9sAFEg58djEEQBRVIQVIMBqMHBQNJEIhUiFJPYPKeEWeUWvD2xofGV5RjSGXB3epnVqEaNguTpJalWkWpdhbZiGhW5BvzhFO5QEqtBRXGWntb+GJ3uOJHEXrWEUEzmtVW9ZFm19PgSqFUC7mASvUaFgEA4JjGqNK3u3iAodMguLIFG1uqnoxIV9BqBhtK9mWCDOh2YnlBwJEoBBCIpinQBXBtuQ7RMJ6/+LPSW4cddk5+H85yzUbLzSEoKGlV6YkySFKaddh46jcjq004iknDgk0Do+IR6VyVMOosv0h7spyPoZmp+bTqwlyV+W1vIsS8/yr27+vigZTVHlo1HFATCqTjL+uPc7DoKQRBhwrnExpzO5nWv0Rfxs6R9E6vcHQiKwlHJAQ6NdJAbaqT3hQvJnXYhSv9OdhTPJFdQ4wBIxuAvh4EswTW79mbSM2TIkCFDhgwZMvzHkQnIv2eSssJzPR6m2k38sCibLK2Gz3xhqo16pthN5OrUBFMSvYkU73uCJBVoMOnZGYmhVYnUGvVsCcUwq8QhCzRI9337kuls8b7oBDjSZWVnOEZjJIaCgDeRojEa4+KtbVjVKjaFojzUsY+CrUrkZxV5dMcTLPeGWJhl5xNviE/9YQ4vL+RXNcXc29rLpmCUD9zpLHGtSc8VpblsDobZFkoHZaV6DSgKA0C+Vs0xOXae6/GgFQRurynkZxX5/HTQo/0v7f0U6rW0xhLoRIEWrw9IB0BTbSZm2c3cOjipMMlm4p2JNZw3WKIvA6YfnIj7tTdo9/lpuPBHPNsZpNvmRBEElJ2rAXhnYi2Xb2tljT/CIU4Ln3hDvBKIMyK7jFOztHxUWUteXw89zz6LYDAMC8hVgpAOxgf5smAcYILNxJ8e/xOR1avJe/QRTNOnE92wAV1t7ZA12heZ57Iy7yATOSmjkccuuIJJNhPzSfcYVbz6Kko8jtrppM8fZ8V2H3ajipHel8hKtvKQksVr3b1cV3MWalFAVhREQaAwy8DJU8o5U30JgiAgxyVSA9F0LbikEG8L0P/wJszTCrAfXYGiKCzf6h2q0lBbtQjZRuTuKDajmln1DjSDJfYzRjiIJ2SybVqUZJy2Ze/QpxQR0Jfj7QjS1BtlfIWVXIeO4iw9GgG2t3iQEdHrtchyulS9pT9GSgajXkVdkYkCh46W3iiKohAIxIkjkO/Uk+/QUTaniF3r9YRiJahFgZSsIMkKufa0pZs3FsKuMxFNSGzrSLeHHDc5BxErTD2XMnMuWPY/7oJKRfb//Zy31/Yjr+vHatQQiKZQiwLJlML8sU5G33kP/3j3DbKPOQo6pkPtUfttJxr3cuxLt5CQZc6tP5xr6qbT9+AhvOIcTYvoQkRgi7sNWZF5+bjrWfTKHagEibauN7ileQBfIklP2APAnTNOZ5QjC61Kw1Pbl/KRoZBT1Abe0xbj7W9H27aNxYLAem8XA9uWcOm4o9MZ87qjQYqDNlOu/pVEvfDO9VA9H+qP/3ePJkOGDBkyZMjwP0YmIP+eea3fx093tDPDbuaFcVUck2PnmBw70ZTE+VtaAPhbQxk/KsrmpA27AdgeTnuRX7OjDdWg9JpTo0ZFEr+kYBQFQrKCDEPCbHtC9ZPynPyurY8Xe71cUZLDfW19rA9G0AgCNSY97dH4fmM8NtuOSaXioYbyoWXXVuTz25ZeTspzEZVkLi/NZeKKLXTE05nwK0tz2R2JsSoQHXpPayyJcVAYrC+R4q9dbhQFfIrMpBVbGWc1stSXLmFOAU+OrmAgmWKq3Yzvycd56ZjTsCkyl5flEUpJGFUiO8IxHusc4DNfCLs63fMsAKJKRGpsxLp7F2tOP4XLp4zliu1t1LQ1kepL98wX67W4NGpqW3cjXvlDJpxyCredeR5TbSaK9njAm8uJ/O53/MaczRH9/iFP8G+DcepUpGAQTUkpvuefp/uGG7GfdCL5v/zlAdffHYnxu5ZeflSczZh9POkBPvWFuK+tjyqjjvmDon6fCxreD0e5MiURS8hkaYI0JNYiCzIgMLd4DEEhG7VKoDTbMMxybcjKzNNIKhIk9sMGLHo1oZSMJiGDrCDHUqzc6SOWkCnJTmeyBQEOH+NCFEXmj81CkmU8wSS5ai/RWIKehIuynHQPetzdQqm8GWeig65Tb2LgmDNh9rEIAlTlG/EEEiQfXo/LtY1Qfg0RVSWl2Xpqi8zo1PDgmid4qifGXw67kOQ/dlKuKOwekU1cUchz6DBo95bHjyw24w4mGVlsoteXQBQFVKLA+p2PEU328Xm0gl0BD+GglkvGLUAUhfSVc/itdHlidG5qZnzoNVS5DZBTT1idxfrmAE6zhnhKQSUKpJJx5JSCVq8CtYD42W/RGG1ULb6Ixp4I4bKTsAt9GBVXOrM9SDIVpsGmpz2S4NHN72OVE3TrS3lGdHFUxSTOqJ3NO5//narOD7EFD0FGRpJhQ38Ty7vT126ZycBlVdlc88mTqIDnj7yI8bmVFJqcXL/Uwo5wWnfiZJWRHectZd3uz7mkckr6PEgpnht5JjMLR1Kuytziv5Lmj2H9k9C/IxOQZ8iQIUOGDBn+5WSe1r5nptvNLMyycWyOfdhyiXQwLQMXb2uj3mxgjyO8WS0SlRUERaA7mQ6A22IJbq4soCueYJrdzE2DPt0iYFOpCMkyFxdnc1qBi1t2dXKIw8zr/T5kIEejpi+ZIiZJCMD5hVmMsxq5o6k77fWt26sq3RqNs8ofZlGug2fGVnLN9nb+3u1mUY59KBhfXOCiyKAlMSg+B+kgWQZKDDq2h2OMtxrZGYkPqcD7JJmPvCEcahVnPvkILinFy8XX8nSflzsqC9BPn8r9bz1H0QU/4sR1jSQUmVX+dH+xThCIKwpBSUYFjLIYMNhstN18M85dm8jRqZmT72Ka3Yyj0oUp7zwAftfSg1Ul8mRZNu5oFLmvj/OLsvc7R+snTuXpzS1sa+39pwLy7EsvIfvStG1ZqqICdV4e+pEjD7r+8z1enu/1ohdFxtQND8in281cXZbHBOve5b9u6malP0zBkiU46+cBZkyhrWjLZ0LZecyWU7wX6UFKQDCePu6KotAfSGA3qtFqVCgbnqDJWYJP7GZjzwRUosDRE7PJv3YKoknDwLp+kpLC5Bob+U49/b4472/wMKnahsOsYdlWPwP+BMdFH2C7ZhYtmlH4A7soz/Jjy5rBFv0cPLITs3YJ+o2rOOKyczAatKxvCtDcE2FiAqJ5c4g4jJTnGNBrRd5ZN4Dv8zf5VLuVoFbh7c1tzNjhYWBaurc/26KhxxdHQWF6Xbr8utClp9ClH/p5iJgXu16F0B/AF+pgvc+L2Txceb65N4rg70UV64bOCDS9x3uW+SjKSFKygiiks/bjEkuQBtahzZ4OhVPg0zDhiMIdS//BBP0cVGKKkc6XcLlm43BMHNr+y6076YkmyTXl0RPrICYlubigHLPKwXGjj6TaUUBs+z+YHu5g5Zv/R5VQwlWBDTSYyjEVzaFry+uMVSwU9HnRympiopq1nl5OGnEYalHF4gknsKJrO0eXT+L2FX8ntf4p7rQZ4JD0df9a0ypuX/kcswpH8vD8y77JJfy/Se1COOIOKM14XGfIkCFDhgwZ/vVkAvLvmTydhkdHle+33KxW8Y8xlSz1BPhLp5uBRJKwnM5zn5rv4paqQraHoyx1B7lldxdWlciPS3J4sdfLT7e3E5TSAVelUUtPPIVNJfCHtj6WeINsCEYpHSwHz1KreGpMBbc0drLMFx767KXeIMnBGYApNiM98STP9Xi4u6mbJPBQez+1Jj1bQlEUYEs4ilOtwpOSGEhKjPpkC3a1il9UFXB6gQtPUmKlL8Sf2/q4q7qIs4uyuGpbK0/1eDGKAhFZIUerZp5Fx6LlH6DIMpdtPIYGUWZl1w7+5KrkhLPHMvftd1len870GUSBE/OcTLGZ8KckHmrvpzWW4JaytEXYpBOO565dEzilMB1klxh0UFIydIz/1NZHSJK5ZMokKt9/H03O/sE4wOEuKzdU5DN9UJQvmJLwdXZS4HKhMn8702bj+PFUL/noS9c5vygb3eA+fhGtKHL1Por0IY+bn1fk8+rr7zD23ruRrnVRVK2gEVJgzoGBbbDpaa5Ex1Gak3gqrxDW/IUW3WjWh0rZSpyrJxehLp+NOrkBFwHC8gREQaTx7RZc/jjOk2uZO8pFSlYwxHrRb/gLGEezW55GKJbCYVBQiwJqlUDCVY8xocWhB384yeaomtlOkfqZR9LcG2b9Lx8FUaQ8BUbAoZeQvR8inzyFit517JIbSEk6BCFd9WArKOWkLbvRzDiGXFMeweNdVGTp8AgqKnMN7OqOUJy1f+l/JC4hCgwpxpvDYwlv9nDCxlwWVNr5W9Vulnduoda5V7hPrxVpU5ezu/B0KvVu/Ls/5LqtzzPG2sC9R56D0+BAFKC9exYGVT7ZxfWgNRGc8FMufPcx1gWXoCqy8F7vxyCEeXbBUezp0m4L9LOicxv90QTd0Q4A5vh2krPpac7Pn4PJkj6niZqZfL5zKVWFY3hgx0cUhjthey9nj6tC8m/kIXkEr8lGXuhfw1uVR+NLSlz8wCKuV/qpPfY+Dh89nw5ZoTXsQ62xQdJPW6Cfv279kAVlE1hQNoFjKvd1rc9wUFQamHbxv3sUGTJkyJAhQ4b/UTIB+b+JT30hFm9pIZCSeGFsJedvbgHS/dy3DKp+15kM9MdTKKR7iDtjCS7e2jpsO6GUTFCSCZLOuB/mtLIhGGWyzUhnPAGCQL3ZQL3ZwPLBgDxbq2ZdMIJRJeLUqLh4axtBSSKlpDPdBlFgcyjKtnCUeU4r28IxtofjmAZLoO0aFQLgS0nsisTpiiX53B/mrX4fm8Ixnuv10GA1MNlmxqJWs9QbxJ9M8dSYSkaYDXgefZS7d7RxfrSHkliIXoOFHCnBaJ2ahgfu45Yxn3LL+VcQk+Fn5Xnc0tjFC71e/mARMP7yJvKdNvj7E7zU6+WJvgBuWeBR+/69so/aNTQ+/wI5ihftl3h6a0WRS0v3+oAv+HQzbZE4zz53G9MeeejbnuKvxKVVc1HMh/um3xK/8EJ0lZXpF9yNEOmHoqkgCHzw4nOsf/Zv2H9wNrfOmoKn+Qc4p9WhjW0Er8S2Vi/ZNj1ZgF2j5tnJVWg8buK+Lox6Nf1iIY1ygnBcwl4yj4JYJf6wQsANIOFzGBj3aRfGYBydVYdRFOjv9pKdimKU/cyud+BKdcKSv1BqGE2PeAi9BcewdXcAwvD/2DvvKCnKrA8/1Tn3TE/OEZgZmCFnEJBsACWIARURddc1u4Y155x1zQoGDCCiggoCiuQ0ZIZhcs6hc+6q74/GURZ13V1d99vt5xzOYarfqrpVU/1O3ffe+7uQBkBIBIIhzBsbSE0xYjco0KrDjnLsgRfI2P0EHS3Tic3IAoUXyTATo7Oe+Mqd9Bk1hlmzHyAYkviiuI1uSYB2P0nRasx6JUNyzfiDIh5/CO1x59sXEFl/oAOFIDBeLaDOiSJ35Kn4Ux20HzuEM1NiWU01stoaLuo7EaUsvF/fNAMmnYIkSyzVVh/xY8Zybdk65IKM8nofHp+HgdlGiusCyIQMhjjkpMRAo8+NSRXDrLTJ1IfK6A5YkQkygvKont/pJ5U72NhwmJyAnW6ZCrMpiReDai5Imgzpi9i3ZQl7rRV4hUQOxk7gyT5zWF9bzbmBAMN9bWBv4sgVO1ix+R1UcgUxFy7mKmcLf17zBJt0yQhuCeWqu5nmquOM4fNZdfadWAiBIZ739n7G0qMbkSHw9IRFv9lzGyFChAgRIkT49ViwYAFWq5VPPvnkVznekiVLuO6667Barb/K8SL89kQc8t+Jm4/VYw2GyNKqSNOoEZEwy2X8tSDjhHHZOjVZWhXjLCbiVUoSlXJaAiEMx+vI5ydZWN5mpcbjJ0Wj5KbsJK7KSCAoSWyxujAr5HhEideOi7hdmRbL9ZlJdPiDGBVy2v0BJu4+RrgKOfzvg6IcOoNBFh6u4avO71t9uSSJeQnR3JadxL25KZS4PBTotcw7UMlOm4vJMWGneI/dzbz9lThCItEKOd3BEF8M6kW+IVxrbOvbj47GNopREjKYKcksIGh1k2cxc/4L7zBOHuL06CjsoRAmhZx+Bi3brU5yvN2oVSAcF0k7J9FCVyDEzL8pB/iOvnt3ErdsKZ1+N4YJ409oY/VzJKuU2Dq7MCbE/+SYoN8PgEL1y3ub/y22Vavo/uBDPMXFKOLi0A0ZgiCTYRC2gN8JplQwp9EgCkgI7PYGuTQ1mcQ778AXENlSbkSVNIhGhwKXXEPskD8iczaB3c+Oejka02VoVDIGRmmYbLLw7YEukmUtDFcWE+x1AWq5DZ1ahkUmEHVRAV8ds6FWypg2KA6/OYevdBeTkZxIH6MKusLZFPEmOSNTokiIUlHX7qHDHgAEYoxKlAoZvjo77n1tpFbbSLp1GL6AyJ4KGwbDYBKN+ZTHn0VIL1AlFeJrdNFPsIPXic9pp9Xqo7nFzcAj7ThTDJRH6dD8oG7864OdeP0iMmCg00vCmBT0GgWqRgdfa5T0qq2jz5k5qNKMJN09FE/V81yvSyAtYTryH9R4a1RyeiXpqWpxc6DGQVK0nyuKpgHwZXE7/qCI/bmnMZqycAwdx95KK23Nn7CiPcDGzhJuzp7NvQVX0e62ISKRrP8+w2F+/nhkCFzgqkbv6eRRQx5LS7+lVB/HeFk9y6r3MtEURNLlY9G46RXXG+UZD+KRyaFxM+SdSX13K6NTCrh56Cz0Sg18fCcX126nNfNMxmVPYuqmB4kJecHVRk7LPtj/HugsXDjhLmSCwPl54/7pZzJChP9Ffvgy/EtejPft28dDDz3Epk2bsNlspKenM27cOG666SZ69+797zM8QoQI/1YWLFjAW2+9BYBcLic5OZnTTz+dhx56iOjov9/RpKamhqysLPbt28eAAQN6tj/77LNI39Wt/j/kp64rwi8n4pD/Tgwz60lSK1lSmI1OLmPXyL7IhHCLtB+SolGxfUQBXYEgnYEgarkcIRDCKYbF3eanxHFtZhKbux0MP55yrT2ugL17RAHHNdaYYDESpVBwZ04KgiBgPC6QFqtSsGV4HqVOLzceq6M7KLLd6uS6rETOT7TwXktY7XmSxcheu5vWQIC8LYd5uzCLJY2dtPoDXJIcgzck0n68xlwAHCERo1xGdzDE2fFRDDJ/n/odbe1gQVcNbSodf0wdyOCgRLcIjT4/rQjUGMx8+oM0/z+mx3NprJ6d72/ENWM6BRdfBoSjwbdmJ/3kPY4+/3xqY+I4zZjKxCM1vH5ctG51m5Uqj4+r0uNPED77jmXDC4ACOOvHo+piMMjej94FYPA5FyFX/ONfI0mSaLr1LxAKYVmwgKg5c6g67XQQBAwfLaXRo6a/Oh4tMH/2HD4eMY651t2w8V4YvAi7kEy7PYBZp2F4bz2xJhWUrYemPURnhIBcvCEZXg/4Qn56xeqQy0Dl78TnbMJdY6VoRRmaghhiLyrA5Q0idnbi8Yu01+7B6mhiwvAzetTUsWQjjb2dECrkHpGyJjc6lRwIoBetJHUcZMueAfTOTKRtdArxaRr8Xg8dLoH6Di8y1WCqJ6zColcSk2smsL8Df0DElZzPgLNz0EVb2HK0m+C2g1gOdBPVnsqZNw1BEAR8ATH83VDL8QVEQqKE9VAnMbFaJg6IZ0MgRCAg0aA30Of4/ZXJlMTEjOU0vYy9dansCFoZlG3icHkTqUIjiXlDSIhSkxTtJ8VeR9NdD6I75xyKMguJ0iuxLmsn+f13CQ0fgFVdSXPbLoaZBuLLHsaUjIEoZHKSDBbWVBcz5aO7uH34XM7PH49FYwwrnQOrKnexdNNiUtRKLoz1oUqIpq/TxMTeI5nZdwZymYxD7TW8X/otd+gE+PouaDnMyyRRbm2mwdFBrNbEw0MXUth6hDcbPqGx70JMM56E9iroMx3emHT8gpWkTHuYm4fO/oefxQgR/tOQRAlftQ3R4UdmVKHOMiPIftmC6m/N6tWrmT17NlOnTmXp0qXk5OTQ1tbG8uXLufPOO/nwww9/bxMjRPifQZIkxC4X+IKgViCz6H9x8OWfZdq0aSxevJhgMEhJSQkLFy7EarXy/vvv/9PHNJv/ef2iCP8dyP7+kAi/Nu3+AEubu9jU7ewRRTMq5Cc5498hSRITdx9j+PYSVDIBk0LOhGgjt2QnkaBWopAJDDbrWddpw/uD1mgKmYBMENja7WRDl4O1nTbuqmik3uvnwcomGr3hKG9AAp1chl4uJ0GlYEFqLKIkscfu6jnWAbubrmCIOk94n9vKGvi2206Zy4NBIeeA08P+4+3PeuvUTLAYOTfRgkkh4/S4qBOux5iQSGxeX2oz87gyLY7l/XPZOSKf+cmxbBuez7tF2SfdA6VWx4O5w7ksewSNVbWIvpPV4v8WmUqFZsKphAD3D+7LzWX1PFTVzGGn56d3Bj5rs7LocDWtxxcaehAE5AolcoXyn574BUEg8Z67ibvhBhJuvQVVZiaWBQuIWXgJtWTQHLDQ4QzbLBcE5qbGkyF4QBJBDBFnVjGyTxTDe5tJtmhQKWR4YvvhisrBmJhNYboBxfG+4pnxWqL0Ss4cGk/vvgV8Jc1luxNcsWoUlnC2gU4tJyteQ2achgu3r2H27i85VLf7BJv31Qf4Ym8nO8utlNQ7MeoUxJqU5In76BXYS7zrAGVrPqY6SsnKF27mzWsvJ04POrUMUYL+mUa6XYGw4y2GV4KDooTeEoMgBkgMWkl4+irs2x9h2TAn+9ur8QVEvtrfwdp97WQmaOmdrANBoG5YEpo8C0Grl4EZRiz6AKkxe/D5vm/np9YNwhHojSCEe4l/c6iTeoeKyi4BuqvRqWWkxqhpe+1lbMtWU/LuGnaV27A7a9D85WzSv1mHKS+KJgWs6pZT6+rLCMNYDrbX9JzjzcPrCEkij+9ZedLveExKAYPjcxiZNpgzBl/D9MwBrJj9KLMKz0IuC0+939QfYnvzMTa53WBMgsR+3Dd6Pn8ecjY7m4/xedVuHGkjQR+DwmNHiw554VyYdBfE9YHe02HghbBgNaj+Ob2DvyUghvi67gBO/4nfj26vk9cPfUWrywrAsa5GSjrrf5Vz/ifTWVtN2bfrCXh+fr6I8OvgOdxBy6O76HjtEF0fHKPjtUO0PLoLz+GOv7/zb4zb7eaSSy7htNNO47PPPmPSpElkZWUxfPhwnnjiCV555ZXf28QIEf5nCLXY8G08RmBXNYED9QR2VePbeIxQi+03Pa9arSYxMZHU1FSmTJnCvHnz+Oqrr3o+X7x4Mfn5+Wg0GvLy8njxxRd7PsvKCgeGBg4ciCAIjB8/HghH3s8666yecaIo8uijj5Kbm4tarSY9PZ0HH3wQgI0bNyIIwgnp6Pv370cQBGpqan7S7pdeeomcnBxUKhV9+vThnXfeOeFzq9XK5ZdfTkJCAhqNhn79+rF69WpcLhcmk4mPPvrohPGrVq1Cr9fjcDh+8rr+3v3w+/1cddVVJCUlodFoyMzM5OGHH/7pm/9fTCRC/jsQp1JyR3YSGrmsJ5r9cwiCQIZGRXcgSLnbx1/z05n9N0JgD1U1s6Sxg9nxUegUcu7MScZ0PAo+0KTjjDgzq9ttLG3uIiRKvNnUyWsN7awZ0ptZ+yroCoRF4uTAkzUt/Dkrke5gCK1M4MJkC682dAIgSeFe4fW+AHLggwE5FBi0nBZrxiCXcYrFyPQ4c8/iwv29U0+6HrlCyZcp+TxS3cxgmwudQk76cVuzdOqfvAei3kjQ4ab6oouQjxxBylNP/t17V2DQcmB0Xww/WOx4qFcqFW4f/Y6n0P8Ubzd2sMXqZHqs+YT7LZPLGTR3fo9d/yzRc+f2/F8QBBJuuRkAnTdIhz1AiuVvRMwKZkGv6T2OV2L09/fKFxBZ2Kxgq20gH3QFGJWhJy1OS6fDT5LSBlU7EdJHI9PHoWw9imQJUV+kJWVsWASvutVDdZuXhCgVadp0fKIHvT6DQFCkxeqjotkNxzuTSxIIAqgUAt3OIPHxI6loFqiWFaBIcKJSq0i64B4cG9/mQK0TQRAY3stEjFGFPyjh8wd62vRVt3pI8RwgpvELOo0XoczOJxgdh0beRkvLIfLMlyCXCfgCEnsq7CTr5Ci8QaLUbXicXjqfbcSWFU3WlAbc7hq67BkkxcUCcKTOidBczPTgFo56h9KhGoRaFqIw1gPRWRRX2qnv8KKaehHRumj0k4YQb1bism3EJdlY1nqIt8sO8OS4S4lNHE+qPB/RD/dueYXhh+qJmXkWBzvCmg6eoJ9Ojx2tQo1OGf69mNU69rVXcbC9gtHBLQBMGvMsSmVYOb/k6zXQUMp9vUZxduVHcOodMHA+A4GBsRm0ua0ICJjVepj/MYKrg4TY3O+fB40Jzv/gn37+fop3Sr7hsd0rOKf3GO4bfUHP9rdLvualA1/S4OjgtuFzmbf6UUKSyJZzH6XO3s7WpqMs6DsRjSJcxlHvaKe8u5lT04t+dRv/nTQd3o+9pYmolDTic/v8/R0i/NN4DnfQ+e7Rk7aHbH463z1KzPx8tP1ifwfLwqxdu5aOjg5uvvnmH/08Kirq32tQhAj/o4RabAT21Z38gTcQ3j4wHXnibx91rqqqYs2aNSiV4W5Fr732GnfffTcvvPACAwcOZN++fVx22WXo9Xouvvhidu3axbBhw1i/fj19+/ZF9RNlj3/5y1947bXXePrppxkzZgzNzc2Ulpb+03auXLmSa6+9lmeeeYZJkyaxevVqLrnkElJTU5kwYQKiKDJ9+nQcDgfvvvsuOTk5lJSUIJfL0ev1nHvuuSxevJg5c+b0HPO7n41G409e19+7H8899xyfffYZy5YtIz09nfr6eurr//sX+n+MiEP+O/FDEbFfwieDevFZm5VVbVbGRp8sYDbRYuSgw80Bp4cKt4/xFmNPZNqgkPN6vyw2dzkwKeU9DrlXlKh2+ZidEM1Rp5cGrx97MMRrDR2MjDKwaVgeQUnCKJfxYYsVWzBEsy/AX/PTCUkS/U16+ujDTuOPKcn/HO81h6MdM/4mev5DXKEQakGG4niq4qpBvbAeOoJVDKFMS/vF5xIlOOdABSOjDNyclcRZCX+/zgfgkT6pbOt2MiP+5PH/akpUyGql6Y470I8cieWCC074zKBRYND8yFdTkP1oFLSu3UNxpZ0xWi3DuvYird9Bx6nTiM3KIdmigf3LwirsSi3atFFMmTOa7cUNtAl62u1+Av4QtVU2NEoZKRYNz0ycha92J3852k6uwkeuTA2CRN9UA+kmN01dbjp9WgJBiZAo4ZRH0Wf4bGJDIt8c6gYRDvqrSJw4k0ZrCEkCm9dHcoyWQdlGdleEdQkUcgiGoKHdRQxQFO+g9fW3kCsCSO3vE6sIcqS6lDH5A9hWaiUkSrS4gihkfhJiN9JsFXDkTaYmJ5ZkVyJWVyGebjmTjEF8rl0kqO2k+jchQyJK7CDJomZAphGNKhkAzfHe7NagB+fEszFFpzMhR4/fO4pAoBtldzNmlY4scwKnZw/B6grwzqdLuOzrbWiLasEzDovGQJfXSbYxkakr7iZGY2TtnPsAkAky7ht1ATavkxRlI5IUQqHQ0O11EpJEvuoq5eVQFTfWlqOs3giIBPrOxb76fiyH/kp7zEi+1Gdw9aAzqXJauXLDa1xYMIErsgeBJopSextLj27k8qKppBpif7U0vcEJORRY0hidkn/C9jOyh3KgvYZ8SxpKmYJT04vwhYLolRru2PoOx7qb6HTb+bJ2L1MyBvBN/WGaXV28POlKHH4Pb5d8zf2j55Nn+X6RbmfzMa7++hVyopJ4//SbfhX7f22yR56Ctame2Kzcvz84wj+NJEpYV1X+7Bjrqio0BTG/W/p6eXk5AHl5eb/L+SNEiBDOGg0cbf7ZMYGjzcgSTL9J+vrq1asxGAyEQiG83nBm6FNPPQXA/fffz5NPPsmsWbOAcES8pKSEV155hYsvvpi4uHC3n5iYGBITE3/0+A6Hg2effZYXXniBiy++GICcnBzGjBnzT9v8xBNPsGDBAq68MtxR5IYbbmDHjh088cQTTJgwgfXr17Nr1y6OHj3ao4ORnf19tuqiRYsYNWoUTU1NJCcn09HRwerVq1m3bh3AT17X37sfdXV19OrVizFjxoSDjxkn6mj9LxFxyP8fMSM+6qR+5t8xOdbM5Fgze+0udlhdTI4xnTRmrCXsyIuSxOyEaLwhkWlxZqb/4Jjbup1stTo41WJC84Po/b5RfSlxejAq5D1O+L9CplZNiy94Qp/tH1Lv9TN+VymFBi2fDOoFgFomI6F/IQk7d/xD56r2+NhuddEVCHFz1k/XnP8tuToNubp//Vp/DG9JCc71GwjUN5zkkP8QSZKQJJAdfwE91uii0+5nWO+onpR0masNUDM51oxWyqK5xIHaYPj+IBljw458fD8I+ZERYNDgDDrsfqL0SvbvacWqVJDU7CJjaAIcXEpVWwPr5NOYIlMjCCK9o1cj8wlkdYdIszZhzz2P2OQEki0atCpZj33Depk50lnLluodpMhjuHXgOWxtbeLRb97n9Wl/pG9MeljDQC3DoJRT3uFFrTwFosZS2Sxi6/QxvLeZLutpNDpq6fam0DdLxqT+sXQ7/RysdiCgQSnvTasrhDA0mdigRGqsDkGQI3MH2V3eSapmJ4Ig0W4ZQry/Bcf6HMzZTg4JAr2SdUTplWQn6siMU7GrtBxb0hSCzqXs2FNLSnwGDiGJqwfO4qYf1GQf6DpGfaqCG8aloKtdy6oP/0CyPJYH2zbi1I3nMYUZvVKDw+/BqApnX8wp/ZCgvZEZqt7EGON4OmEnexs28fixdu7sm0m/Y1qi+kyDgnFQt4PSN25GU76KGJPIn5V+ZuQWYVBqaHJ10eGx46nbBZ9cADkTWZo5g+VlW2l0drK7pZznTr2CCWmFJzw/G7vsXHGklluyElmY+uNt//6W/nFZfDzztpO2Z5oS2NtawY7mUsanF/LU+LCSu9PvocLaAsDW5qN0ehxU2dpodoX1JzbUHsAbCnCoo5b9bVUoBBkxWhPRGgNvHl6H3e+hvLvpZ2168/B6VlXu5JkJl5Fh+mmxxTu2vMORzjrenHot0ZrvvwOugBd/KHjCtl+K3hKD3hLzD+8X4R/DV20jZPP/7JiQzYev2oYmJ+rfY9Tf8P9ZdClChP8WxC4XeAM/P8gbQOxyIY/5x+f8v8eECRN46aWXcLvdvP7665SVlXH11VfT3t5OfX09l156KZdddlnP+GAw+A/ViB89ehSfz8fEiRN/NZuPHj3K5ZdffsK20aNH8+yzzwLhlPfU1NSfFKUcNmwYffv25e233+bWW2/lnXfeIT09nVNOOeUnz/lL7seCBQuYPHkyffr0Ydq0aZxxxhlMmTLlX73c/5dEHPL/MgaZ9Awy/XwtqUwQTlJz/45R0QZ0chl/KW/g+oyEcG9vwjXmQ8y/To0qgEEuxy9JuMV//QXnqw4b9V4/l/6EwzHErGdZ/xwytP+8IvqvjW7kSJKfeAJNXjgF1uoKEAhKxJlPtHFbqZVuZ4BTi2LQqeWUNjgRJahtc5OTpAe/i9SKV0gUVCgSb4eUIaQNGPL9AbxWKP8C4gtBbYIdz4G7A+2oGzBq9ZQcPEi2vxiNdSy9s4+ngsb3I6ujkUtpwimPwyKCQIhgCEgeyi5RS3uLhVFRPvQaOZtKurA6gxi1cuKjVOi9Zi5PPh+12khMcwWl4hFcISeHax1k6EOkxGhoe+0gbS0uKqdmkxSrJTPeRFNnO26/SF2HB4fPgD3Qm4QoFaWNLkIhkfpOH0WZBjLiYuhyTqKxzUq6TsbY3uGJPSVGQ2Onl13lNoL+8ciEIHZ/OmMDTZRsKEK2NYQsuxuZ4CEhysjuCidmnYKBcxbw+f4GfB43eoUIErQ73Px1/xfcOOQsAJ4u/pTPq3bT4OxkeP5MskNuHg9oGGsvY4KnCXvtNqbfUMxNm5cw6v2beO/0myiMzYDDHyH3uxDTzDQiw+upIVuv5FXHTjxOHQ9kGSgt+wL6Tod9b5OniUNp6sSvTyGleTcp3WWQ3p9pmaP4dObtZPq64cDLoDFzedFUYrUmbD4325pKsXqdJz1nDd4AtmCIGs/POzo/JCSKlFub6BOdgsPv4ZHdH3FKSl+mZQ3m7F4j6fY6sWjCi3t3bV3KqspdDErIocXVzV+GnUO6KZY4rZkn96xkQ91BTkntS7TWyLTMQRzprOOMT+7HrNKxqGgKO5qPkaCN4pUpf/pZm7Y2lnC0q4GK7mZUMgVbmkqYmTMclVx5wrg9rRXU2tvp8jp6nG9Jkpj+8b04fG7Wzb0fAN0PSgsi/GcgOn7ZM/pLx/0WfPeyWlpaysiRI383OyJE+J/GF/x1x/2D6PV6cnPDGVPPPfccEyZM4N577+Wqq64Cwmnaw4cPP2Ef+U9oRP0YWu3Pl1PKjmvQ/HCBMBD4OwsUnJzZKUlSz7a/d04IR8lfeOEFbr31VhYvXswll1zysxkIohguTvy5+zFo0CCqq6v58ssvWb9+Peeccw6TJk06qV79f4GIQx7hJN5sbGdZSzdpGhU3ZP54Ss2/yl8LMmj2Bcj+iZrxNI2Kg6P7ohb+fo39n0pqcYRERkUZelqr/S2nWE5O8/89EQQB8xmnI4kiuz96m5rkCShkSqYOjEOn/n7iDonhtHDx+MSbHqel3e4jJeZ45F6pBVMqCjEEsh9M+B2lULEWEvqDvQEEOTQXg88BchUIcnaX23BKKbg0Ckb2laNJiOFgjQOlPIfssTdyuduHWqgiSApNDaeSpmihQZFHuxgW+wsEJdbvP64tANg9IexuNwgCcd0ibkULholDeEw1jM+0TQgBFaUNTob2iiIYkuhMNuILSXQ7/fiDIoNyTDi9IfZXO3ouo8Uafvk2aORolAKHa53UtHrplxF2tmyu8B+hNpsPmztIeqyGxCgVVncKoggJUUp2OlJInNNNWh89tjgbPs9a3jgkI0k2HkdQw+INyzhmr8YRdPLO5OsoaRX4qG4DfVOCYK3Hd+B9Piw/hlWuIlZjotTr5pRz3uSCrx5mltREZexcnPpeZAQ8HGivRpQkfJ56IAMGzEfY9QpvRavRnH4bam8H4vqL0DUdI9BWg9JnJw+gcAZMuANlbC9atr/MMsnAQmMchpb9UPwWZIyijyUVOn1w2TcQ34c04NpBMxAlkYX9JpFqPLm2dn5yDINNOnr9A5keL+xfzUsHvuSWobNJM8bycfl2yrqbmJY1mLtHnke720aVtZk+llQ6vQ58YoDrB81kUEJOzzEOttdQbW/jyfELuWXTEhqdnaw++66eSLharuTJPZ8gAG0eG7dveYcVM/4CwCcV21lfe4BkQwxbGkt4edKVPD7uEsq6GhmRnMfVX7/Cutr9BEIhzs8/scXb29NvoNvrICfq+0yYL6r30Oa2opIpaHfbOPfzx8kyJ/DJzNtZX7sfmSBwanr/X3x/Ivw2yIy/bMH0l477LZgyZQqxsbE89thjrFx5spCj1WqN1JFHiPBbo/6FrssvHfcvcvfddzN9+nT++Mc/kpKSQlVVFRf8RObjd7XVoVDoJ4/Xq1cvtFotGzZsYNGiRSd9/l16eHNzc0+rtf379/+sjfn5+WzZsoWLLrqoZ9u2bdvIzw+XphUVFdHQ0EBZWdlPRsnnz5/PzTffzHPPPceRI0d60ul/6roSEhL+7v0AMJlMzJs3j3nz5jFnzhymTZtGV1cXFovlJ/f5byTikEc4iRsyE0nXqLk4+bcTz9HKZT/pjH/HT6nO/y335KZQ4/HR+1dIpf+tWNnazaZuB/flpvS0nANwbtrEx+s+JDDTTD9LDmrlidoCo/OjCYkSKkV4YWJg9t+UIlR/HXa4kcDTDboY3L4QFQ1+Ulyg8stozvwDyVEqDAdfBKUOxtxCVasXtzeETABzdDTaxDQ8/hCVLW4Amrq8KKSjpBh2o9f3op+7GazVBAUdEBaCC4kiWpUMs16JViVQ1epFFhDJaKonx1RMfcpIdGoFrTY/ghSerButPjqK2xhxfh4dx2wQkjDrlGw82InbL3JK32hkQrjuH0Aug5AILm+IgnQ95U1ulAqBVmtYZd/jF5EkiX1Vdtw+kWidDLdfxOuXGFsQTTAksd1qRTlJQWYfLS6Xihf2dPN+TTP9TTBEF8furoMYFQbSjfFkxybR5j/G7oMHUKqyoH4t6kPLeG3AQh5XpbGrtZwPq3Zze+smrpgXVig1e9wIgozdXdU0ubrI0GuJ8u3C7U5HN+E2iEojoe/ZdLbtQbdkFhgTIGUwyrptkDoU9HEgV0JUGpiSeT5nFitq9hE3+HzOW38T1G2HoA8crfDiSECAm8rDom6Ea9V/zBn/jp9apPoxfEE/n1XuQiHISDPGMi6tkNuGzT3B2V6w5hkqbS1MzRxIYWwGd46YR6L+RJ2FdbX72dZ0lCprCy3ubmQIqOVK/jBgOlMyB/L2kW/4uGIb07MGsamhhCh1OPvGE/Tzl83vICGhkSvxhgLUOzoYnZLPiORw3e5ZOSNocHRS3FqBUi6nwtrCjYNnopIridEY8YXCiziugJfFh9fTOzqFPEsqs3uNJFZrwqDUEKMxYve5ufrrVwHYPf8pDEoNTxV/QoOjg4fHXIxacWL0PcJvizrLjNys+tm0dblZjTrrtxdqstlsJ73gWiwW0tPTef3115k7dy4zZszgmmuuITc3l46ODpYtW0ZdXR0ffPDrCy1GiBDhe2QWPWiUP5+2rlGGx/0bGD9+PH379uWhhx7innvu4ZprrsFkMjF9+nR8Ph979uyhu7ubG264gfj4eLRaLWvWrCE1NRWNRnNSOrtGo+GWW27h5ptvRqVSMXr0aNrb2zly5AiXXnopubm5pKWlcc899/DAAw9QXl7Ok0/+vMjxTTfdxDnnnMOgQYOYOHEiq1at4uOPP2b9+vUAjBs3jlNOOYXZs2fz1FNPkZubS2lpKYIgMG3aNACio6OZNWsWN910E1OmTCE19Xs9mJ+6rr93P55++mmSkpIYMGAAMpmM5cuXk5iY+D+5sBlpexbhJDK1av6clUiM6v/Hes0FyTHcnpOM/DfuPfmv8EJdK+83d7HT5jphu7Z/fy6JyyHXWsqZ/dOR/41YkVwmUNPqYfuxbvzB71u3EfLDjueh6mtAgtzpoAvXuVa3uqn0JrBJP4/13X040qHhcKeWrQlXcyT1ChBkOL0hRCDGqKTOrqKqxY1WJWdwjgmTVo7dEyJIMmpNBkZjPqSNxKbNY19LLCZ1eNrYW+XAoFWgUcmobgsLm4gqOcrULoyqegpkx5DJBPQ/iPhLIfAGJDaWWPGHJAyBAMYPjhLs8qJ0B1C7AuSlGtCqZBRlGPiuW51JK+NInQt/UKIo00ggKCEA/qDEwZYm9nq2kWm2E138KEOdK4k1KTFqFSRGqzm1yMKQ3PAfPL0+k4sGX8X4hKGMM/bj8gN3c7u/kffOuJ61c+7BojEyLWsQjw6YxsiyT3HVbAWZgs8CArtay8n227ncWgJR6T3XpNLqUGo0jEzK45GxF/PAkMnoFPGo1bGgjeJQ7xlcvvMTqm1t+JFR6fGxt/8C6H8ezFsK571PcPUNrPt2MbwxmZH730QpUzAhZ2RYyM/vAjEEX90OIR9EZ4QXVv5B2t02lpdtwRP8aYdnTc0+Gp2diEjkW1K5ZM2zCIJAv9jvS1z6xqQTrdKztmYfbx5e1+OMV1lbetqgXVE0lRRDDC3ubgRARMJ+vI3a9Rtf54OyTfjFIJ0eB5+ddTuxWhNf1x1Eq1BxWtZgYjVGvKEAKpniJHG5iRn9CYohPq/ew1N7PuWtIxs43FGHzefivh0fMPmju/i0YifLy7bwwv7P+eDYZj6ZeTsXFpxKnM7MlnMf5Y2p12BS61hUOIXLi6ZiUIYX8z4o3cQX1cU0u7pPujebGg6zs7nsH77vEX4Zgkwg6sycnx0TdWb2v0XQbePGjQwcOPCEf3fddRcAM2fOZNu2bSiVSs4//3zy8vI477zzsNlsPPDAA7+5bREi/K8jCALK/J/XA1LmJ/3m/ch/yA033MBrr73G1KlTef3111myZAmFhYWMGzeOJUuW9LQFUygUPPfcc7zyyiskJyczc+bMHz3enXfeyY033shdd91Ffn4+8+bNo62tLXxtSiXvv/8+paWl9O/fn0cfffTvzj1nnXUWzz77LI8//jh9+/bllVdeYfHixSe0J1uxYgVDhw7lvPPOo6CggJtvvvmkSP6ll16K3+9n4cKFJ2z/qetatGjRz94Pg8HAo48+ypAhQxg6dCg1NTV88cUXPWn5/0sI0u+gUmK32zGbzdhsNkymk8XHIkT4b2Of3U2x3cUlKbEnLhwE3LDpoXC6+bg7QXbyIsi6/R04vSFO6RtNzHfpmj47bHkMZEoomA0J/aC7Csq+wJsxiTJvMlUtHgyhDmL1NUQZo9jXnotOJTC10Iio0PDNoU7s7vBkmxStxqRT0Nzlxe4JR85PLYrBqFVAy37wOfi0MQfxeFq8RiVDq5LR7QyilEMvswurFE1Ttx+FFOD05Dpk8XmImmg6bH7qOryUW610BCQylVqkUDgd/9TK1TgO96Ehz0JL7xhSLGr6ZZvQqsLnOVznoLzRhQrwH79vBakqShr8CIIIyPiw5QP2dZXyZP95TOtaj0OZiGHMn9h0pBOVQs6YgmhK6p34AiL9s4zIBIGQKNHZ3Ej0V5fSMnQi2sThxMZ+n/788q5lPHPkGy5xVXJLx04291/I80IsNZ3VBAUZX1/wdE9Ul5bDEJ0J6uPiMSsWwaHlkH8mzHuXJ/d8wusH13BvrIVD9k5W+OHRcZdypuABMQi5E9my/X0eaQ3x6tF7WZc8jPcNuXx05q0YQj4o/wrShkHtdtjzBky8K5zG3v9c6DX5Fz+Dt25+i08qdnDTkLO5tPDHRVPa3Tb+tOFlRiT1YUB8FldueJmhib14Z/oNPWP+tOFlNtQdAODRsQuYmTucoBhi2NIb8QX9XFo4Bb8YxOH3MDypN/mWNI51NfB1/UEmZwzkrSMb2N9eTbI+mg/OuJltTaXcuvkthif25pkJl/HIro9od9vY1lzKRQUTuG34OSfZua+tigPt1eSYE6m0tTA/fxynLr+Dbq8TAYEXJl7BbVveodNjZ0RSHxZPuw5REpH9nRKYwx21tLlsNLo6GRCXRX5MWviYgsDYD25FIZNRPP8ZVPL/H4uVvwW/9d9vz+EOrKsqT4iUy81qos7M/l1bnkWIEOE/i1CLLay2/sNIuUaJMj/p39Ly7H+RpUuXcu2119LU1PSTLdsi/HP8775VRIjwb2SgScfAH1OUl6vBkg2ycF233R3kYI2D7ERtuGUZMLx3FE5v8HtnHMICbSOv41i7gNUmZ3CsiKKrEhyNaDoPUaSqJq9oLKGG3TTKygiKMCpvMFHNX8O3WwjGnYXBmUhI8JArO8aB7uE0d/uIMSpRK8Pp3m5fCL1GjuzIR4iSSKphJnVkAuD1i3j94fD1CNfHxDqaYOxttDh1yAUJWckyqNtEeeoCSloFMo0+shv30CdoozbldDLitfRJ0uDy+xEL9pBgGUVzSywNVj/dR7oZllWPKPoxKvoiD4jo2930HZGIW5RobCsjVmNDKfPS7B7MmOiR5MbGkpvSj6/8mViMGhI2rcCpGRFOfxfNlDe5ECXok6JHp5YjlwnEp6TiPe9tfA1LCTkrCATsxMSMRqmIYn9dFSpBzmJ9DnVx/fjrjMcYI5NzweeP4wz40HwnJla+DpbOoTttFFv7X8JEmR/td4sq1ZsAuKxwClNq1lC496/MRMZ5KSMpqFuP9O2jSMDGecv5vORLqqPHMCH3DxybeyPmih2s//APnOWphaZ92OP64l+4htgB58GexXD4o7AewN845A6/hyZnF30sKSc9aqdnD6XDY+cUYxS4OkAfy8O7PuKTih28Pe06zGo9c1Y9wqD4HG4YchaSJPHixD+QbU4kKIZQHF+MOTW9iH1tlaQb4/jw2Gai1HrGpfVjfFohx7oaePXQWgTCugJ/GnA6yQYLZd2NfFFdTJvbjs0XjpR7ggFePbiWGwefRbfXyedVe5i4/A7cQR9JumjeO+3PfFqxg/M/f4JXJv8Jo0qLPxTkjq3vYPO6STPFMjGtP1nmRBQyBUn6aLRyFR/PvA29UkOc1kyHx8725mOc/emDtLltrDr7zh5Buu94Ys/HvHFoPbN7jeKBMfP5xnOIB3cuI9+SSnZUIl9WF7N46rXM6T2abq8Dd9D3ixxym8+FLxQkXhd5MfxH0PaLRVMQg6/ahujwIzOqUGeZf7dWZxEiRPjPRJ5oRpZgCquu+4KgViCz6P+tkfH/FdxuN9XV1Tz88MNcccUVEWf8NyDikEeI8HsikxMsnIdCEY62tli9tNv9iJJEcrQKSj/FIMhQ55x58r66WKo72/H4g/RJCRGVOR6MSdC0F5r3olIZkVJGENXuRm5IIzpKAx3ysADb+jpSOnwMOWUdQlQMmj5TCIkSabFaPP4Q6w90EgxJ5CTqaDFdgTcgEUJNksZFs1ePXAC9VoFS8qNzdhLQWFDufIHE2F7QZwaE/EhigLoGFzK0tHb48CSMwdK4nZG9TcSY1BRX2HAah5Fp2oQgljOx/2D2lFuJ0ivo6PgGgAZvNiGVnMQUPUGZQFm9C4lUzKogZrWcFPchJmTGYsw8n8b2NvyCAo/LQ4PXwGjpY1rkmewo02PWKchN1p0gmAeg0SSQmnoeHZ27cLnKUavj0CkLqLa34hdCXFl0GlOzBoJcQWWzi7mxFzNcsR/NJ38ASYL8M0AbQ3T9NvKbD/OZOo55GYUwfwVt7sN4694mNfVcCnPGwtGVqEM+Chq3gqcZAVinTUW54T6e7DjEgw2fs3XB13iCfm7d/BZLWraDrxURgXJbK0+9fx8vn3kTxv7nQsADvaZw25a3+bb+MB+ccRNmlZ6rNrzMrtZy3p30R4Y0boPeU8GSBUE/Y7c/yViVHt6+F0xJ2P+4k3p7Ozafi26vE6VMgc3n6mlXFk5Vz+SMlfeSZU7gwzNuASBOa6LL68Sg1FDn6ODhXcvJjU7iqfGX0ua28fjuj6mwNtM/LpNkQ1iUZUrmIO7xexiS2IuHdy6n2t5Ct8/J0qPf8sf+05meNZg3D69DlERm5gzj08pdXLbuBUwqLS0uK6VdDby4/3MGJeTyWeWusMPfCB+Xb8cb8vPg6At77PuOd6Zfz6nLb0cmyAiIIdxBH19UF/Pi/s+5f9R8JmaEhdz2tlYiIVFla+GD0k08tecTBsRlcWHBBHa3lKOUKdApNfSNSeee7e+h3qHkyXGX9pyn2+vE7fdi3LILbf/+KFPCiyEzP3mQFnc3RqWWy4qm0Cc6lXFp/U6w8YcLHRG+R5AJv1trswgRIvz/QRCE36S1WYQTeeyxx3jwwQc55ZRT+Mtf/vJ7m/NfScQhjxDhd0CSJDodAeRiGZ0dXxEdPYKYmFHojqdqB4IiBL3QuBsQWGcdzClFiZh0J35lR/aJoqPLge/gClwpfdCnDwS1GbTRIIUQtj9JbK/pEHu8RU/uVELG4fh3lKLKUCFThhDc7cTq7ISkAJBCICgRDEkIkoTT7cMVUvWoTXQEDIBEjFFJdpKOrm270aldeLr0KHXdYG8EQYZv8MXUNW3D2a5H6QvhURvRBrqJyR9AY5cflVKOUaekpSOOanE8zmASBWofpxaFU1I3H56LPwRFmSaKK+1UiuCvdSIASrz08lZwyDcSn05PS4ufKFclydpVFCXE4eIMysWBBDVFRMfq6WjyIUoSFsOPr+ge7fbzx6/Xc3ZGBn/OGoBcriE3Pge3rYFz+owl0RAF0FPfH/ftjeAI10pTuhpCQWwxvQn6vMxzVoJ8MOx8FY1gwz7sNERbHTJLNlxTDJXfhOvC04bTWb+dw64WFrUcgI5DyLVGxqcWIJcr+cvQOajX74GQDVnQi14KMqN7J/6uFih+BnpNgdhcdjUvodProNbezg0bH8YfChGvNZNdtQ6+uQ9qt8C8d8HRHI6qq/QQk8N9xn68996NTM8cTLzOzON7VrJixl9YN+f+nh7qABJhhf+g+L1+QaYpgd7RKSTqo2h0dlFjb+PL6mIWFU4hXmdmfFo/VlXtwur7vg2bUibn3Lxwv9I3pl7Dsa4GjnTWY1briNGaeLr4U9o9dtIMsfiD4VY1roCXwfHZnJk9jNs2v029swNnwMerk/9EvaODkCjywbHNVNlauGPru2xuPMJT4xfxyK6PWFm+nbenX8+SadeTbopDLsjwBv0sPryeLq+T+3Z8QLw+isLYDF6cdCWfVuzg/aObeKb4U+wBDwExxOnZQzk9eyh3jJiHQiZHKZPTLzaDcan9aHR2squ5jDNyhnH2pw/R7bbx4gtbSC0aRMbixQAkGqJpcXfjCHh4pvgzRCTWz7kfh9+DBMgFgXM/f5ypmYN4ZOz3arURIkSIECHCfxL33HMP99xzz+9txn81EYc8QoTfgZo2D/urHeTEBtEBMlnYWUyyaMhPDRFrUoFSBYMWcrTejeRXIZeBKErUtnuINakwahWY9Uq6ampIcB3AU9uCJ7GIAy1GEsTRpAfLkEO4zvw4voCIr8WP6AwgS9EhJBaCIKexeSWhkIv4xAuRy6Mo6NhLSewglJ0+lEqJoZ7VxCQkUaKbQGWLhzZ7gDa7jWRDPt1H25Fn5CMOSkOtN6AAajoceAIeilJKEBjKgSY3xuhoyu0AXlq6fYzINdF3ZDKb9gVxIsPuDteBSZKEzaMmJEoctrnx+EXwVeOyr6FU3p+JljzS3Iep1BaSWLOPxowRCIIahUKPRmMhLsqAJyDwid/Gm+XV3BIdR4ZXQVWLm34ZRkRRorTOhtmkIcWiYdORb7EGg7xdVcsBcyPv9c+hzNVFh9/G0dYOEl1N0FFGVt+zSI/TIl8fbvWGPg5c7UiA8tR76bPieDsRrx3Kv8KoMaFLGIXi3cHh7UpduP3cjaWg1BFTsY4bUkfBmJtoyn6Jg507SF13Ff2yZ3Fxv6lQsBPW38XuthoW+nWkB53Mq3oPdr4MtdsgZwJ2X1gVX99ykKAo4g35ydTEYSmaA60HYdCF4XNHZ8D8FYQ0ZmQpQ9i64m5wtOPwe3AHfHQLTiRJQi1X0u62ozeHyyUSdFF8O+/hE/p9p5vi+OysO7hv+weEJJGJ6f05p/eYns91inD3BI38p1Pa+lhSKbc2c/XXr3DniHmc02cMJZ11bG4swRsKPwdKQc6mxhKq7W14QwG0ChX3jzqfvJi0nuNMzhjANV+/yqHOWg6011BlbaHB0YHN7+ab+kM8s/czTk0r4sVJf0SrUDE8qTevHlpLq9vK2uq9FMZmEKXWMzypDw/vCvc9TTFYeP7UK3rOoZDJOdpZz7q6/fyp/2l0+Zzct/0Dvm04DEBOVCJNggzLoMGYp53es98Hp99Eq6ubL6v3UmlrxhcKoFdqmP7xvQgCvDb5KvyhIM7jYncRIkSIECFChP9NIg55hAi/AyadAr1ajsnUh4y4QgQhHBmXywTyUn+QfmXJpa8F8iUJmSCw9WgXbbYA0QYF4/vFgLWG5PRsOsRJmJJzabH5ae724Wpzoa1QknjtfeGWWoDHZWf3gWr8uhSGXlxArUKOPCmfaIMSffOXNHd38u1hN0FELFEJCJKIWyYgIqAV7cjbO0lXtNEkjCekMmG2++mVYiR63IV0OwNsONyFQeNhaC8VJU1m5LJJqDwyshJknD4kDl9A5JuDnYRECX8Idu1pZYhuG6O9B6mL7ktC6nScniBymcDo/Cg2Hulmb70TJTBD3E6m1sfiQAnDC8axueR0PurYz1kVZoZ5uoi/tB+CcHnPbRvay8yH+60AiECUXkG8OewgdhV/wrHQKJQtNrbF+0k6ugQMfVAh0OILO4N/HTEa/IdIsn8Lnz0FtgaC+i+QpQ/HlX8KSp8f1aSHsC9byAYhgbgd7zJGDIQ1AcrXQFw+wsD5KL6647hFAsT1CfeAV6gJlK/nvl0fk6ZcxeV//IJ9mmTaA3I0dQehqTacau5sgW3P0x8Fl2WdwUC9EdqPq3znnArAy6Pn0bp8EQNWvc+I2NF8q88Mp0VHZ8A5bwFg97m5aM3TpBlj2ddWRaJ+Ay9P/hOH2ms4MzGbqk+vY79lIBXWZq7b+Do1tlZWnXUn2VGJAOiPK5A3ODo4c+X9yASBj2b8hS6PA51ChUVjwKT+Xh9hXFo/7h99AYWxmT/7HbD73IiShM3nJsUQw4uTruSD0k3U2dt55+g3BKSw4OB1g2YwNqUve1or+Ly6mHRTPDqlmgprMwvWPEOHxw5Ao7OT01bey0sTr+TmobPxhvy8dnAtGxsOsXDts7w59VqGJfXh0n6TcQV8XFb0vbDdwfZqepmTKLc14wsF6fI6SDZYONRRy0v7v2B3azkOvweVTIFfDPLnwWcjSRJDE3tzdq/j2Scna8+RoI9mQb+JPT+LksjE9KLwM5rYi9uGz0Wr+Pn2jxEiRIgQIUKE/24iDnmECL8DMUYVUwZ+rxjs8dQjlxtQqaJ/dLzsuEiJLxBuipAYpYbOMti3GHV0NurBlwGQKkoEvUHkR9rR5FtArkQUJfZX28moe5dTQg0c1JxDZ3QfKmsctLa3MDBFINoylJKqBpRCAFGmxCx2M1ThZb8lj5AtwF79mcQ27yBHW00fzS72yybhCEm43ioh6o7hKOUCggBObwibO0BarAZ/UKTV6sfqCqBS6FEpZMQaBDrsATobK0lTJbHFeCq5cclodcV0dW1md33YuTm1XzSCBNlyFY2qEKl5M2is+obpORPwhSop19lY374daUQhE0894yQRF7cvxO25yZxb7aFP58e41hzDdNGVEFWAJdhCfvnTvJQ1h7jNy7i1cy9yRDJnPEuflF4ANLpqSFOJCHtfRfI5qVNbWPzVk1wz9yGiD69FkCToXx5OYxZaqOx9CrW6qWTE9YUtT4E5Gfa9A0gEBAuy6Q9gS+vPeduWM3T1/dy/7zmio4p4VdeHy4HPGhv4tkWFoOrPdcEWrvjsGjjzWZj9Biq1kWt6Tw1fWGclVG2EgfPh8xsZVLcDdDouM4xjiyYJCZExKX1PuBc2v4vy7ibaXDZsPidKSSTLnECWOQH71hfIKV9NQ30xZ9ZXkmqIIdUQg1l9sgBhl9eJ53iP7xs3vkFJVzhtf33tAc7OHcmHxzZz5YDTWHZsC4n6aPIs3/cobXfb+LRyJ/mWNB7auYyL+07k/PxxjEvrR6zGxNmfPkhIFHnu1MvJLEhgQnohj+9eiVGpYXxaIXqlhlcPrmV/exVdXjtravYxJqWADo+dNGMcc3qP4vm9qwlKIY521TMhvZBmZxeuYLhf/bGuRiCcOn/T0FkExBBtbitahRqbz8nd295DAlINMfiDQeaseoSPZ9zGNV+/0tMCLUUfQ6MrnB1xanoRi4p+XKne6fewvu4AkzIG9LRT+/57LOOZCeHvqsPv4f4dHwIwKa0IkyasI+EPBWlwdPQsiATEEMpInXmECBEiRIjwX0vEIY8Q4XfG52unsXE5CoWZzMxLf3bs6PxovIEQZp0SPLFgSITo7J7PZTKB7DQjXBoWj5IkifUHO/H4QvQSnYiCgvycJESdhvL6TpJ95VjKt7E4/RJsMj35Ch1iSI5XpkWXn8oQZz0262Fi+oxmb42Mw+40PP0mgge8BhXubDWCRoHD3U1BhhqbQyAxSkNdu5cOe4DeoSCGZdUcm5lLvc/NIPdq3rd18ry9iZszZxFNEW1iNiZvJzpZH8xiJ07BwL5qBxISacYtDI1SILfMICUmh66uHTS2HiFXiGGsZRSnxeYiKE90VkKixIaDnSDBdM0hFMEmHM3ldC55C1V6OjGLLiWv0M4El5JN6ln4onzMHnIxpPRHkiRoKKa5popuiwJVXCG6tClkbHuOa1u3ot21FPfU21Bo41Cv/QtaewNRQ6aRm5SIVZKRUbY5nJGQPBjMGdBeiqfegWHNn4kSPQy1DOG+rt0IwLiEbIpNmRzpqOPutFwubC2n1e+mxuNixbHNTBhdg6VwTs91uQM+3Lo4YgdeCF4bHFwWbn8HdGQNADG8KNFy3IF0BrzsaSknVmNibEpftCEPXzY7mNKxH0mSEDrKaZdpeMfcj53m3phVOub0Hs0f+k8/6blrcHSQZoylV1Qy1fZWRElEIZOTa07k6fGX8dcDn7O6ajcWjZHFR9ajkSu5sGACD+5Yhs3vIhAK8WVNMamGGBqcnXxUtpVz+owhxRCD3eem2taKNxRg+sf38PnZd2PRGLl20JmMTyvsseH6wTPZ1HCYiu4mXAEvWxtLWDL1WvJj0jCr9RS3VLCp8QgKQYY/FGBXSzm9o5Ixq/VcVjS15zj1jnb+uP4lKqzNpOgtdHocZJoS8IUCrD77Lh7Z9REH22tI0JmZnz+BvW2VXJA/jnu2vQ+ASqYgTmei02NHo1D1ZBB8x4sHvuDNw+vpc3g9OVFJnJLalzU1e7l9+DmkGCy8enAtacZY9EoNQxN6UdS2F90jqbyWPoVLFrzHfdvf56PybTw9fhHravexsf4wy8+8hZyon++7GyFChAgRIkT4/0nEIY8Q4XdGoTCh1aahVsf/+AAxFO5TDqiVMtTK4wprWguMuBZJkqhr8xBlUIQd9R/StIexXWsoMQ1HJw+wRzGFxqMCGmUnAVFJmXoYcfJWHmqwk6jWsTo/jj1lXWT6j9F1rB6dXk9TIAZXYwvx42aQat/GeqcIyBEIUNIvnbbyFq7c8SDZ5kQ+PSucoh2lV+LxidhrHFizo/Db/DgUahyigSKqeH5gJqn6csq68pDLdTQ4RxNrr2ZU6HNsmkFsc41CQMSkasTrCtHVuh2ray9qw6mUW09HIMh5vt1oD+3FE6dHnVbIwWoH/qDI4BwTZp0CCZD1PoOQKRfNpAI8a9/CvnEF6twcTNOmcZYBzkoYAYzA57dTfvQ5NMoQ8d8u4zS9kY7e01AJAWRD7iYQ9GE++imy7c9BfEG4VZ0+FuwNmA9vRu52kNxWCx0NMPt1KJxL8Nsn8YYUmFID1MvUPBQzlvGuemSAt9dU4tqO4LJ7WSUXSTu8jMaYoUz0NJEhh9tjRzDn6BYeGJPV86u88MunyGzYxhNtm/HFFKH22VluzkNMH8XSCdfx9jfP87nLTV5UMgCP7/6YD49tJsUQQ6Ozkxu0AvuDLjqRsbZ2H+M+uYSVRFGTOob4uN4sGXfJj/bpbnR2Mv3je0jUR/P52Xdx3uePc6SznqfHL2J6Vrg+/qqiiQxTNjEsLY3sqAuI05oJiCHeL91EUApRYAnXfevk4fTsgx011NnbuOCLp0gyRBOnM1Pv6EAC9rRW8ML+1bS5bdw/6gLePfoNbS47fWPTeGnyn6i1trGjuQxnwItJrcd8vB/8vaMvYG1NMefnjePiNc+wr60KgMHxuVy+7gUeHH0hs3uP4p2Sb6iwNoevzdWFWq5gybTrSNBHsbul/PhiwVhitCYuLZzMpYRby70x9RrmfPYwIUmkwd7Jwi9fYF7qbGYW9CMr4fuMgglpRRxor+FgezXHuhtZU1OMKElsbSxheGIftjSVYFBqcQW8SEj0cjSjQCTkbCUghkgzxWFUaYnXmXEFfATEIP5Q8OcnkQgRIkSIECHC/1siDnmECL8zcrmalJS5P/5h5Tqo2QgDLoaY3j86pNXqZ2+VnSi9ggmFMeGNIT84WxCcrdgscsyGw7h0SYj0Bjv4Az7SLU2o1NlEpS7kzoOtmH0yQqEQI3M16HeVI/plHIu/gSpHAJwSCbZS0rxbGKlvZo/hLJRuG+1SHKLHR57OSLwupsemwgwjhRlG1ogSnoBIfqoejcNLm2o4CdEFyI37EfAyNt+MXqNnd6Udo1hFgzoaocNJcrSKpm4/FdZpxK14Fe2MY0jxAURRQkBAQomEgFcdx9qmeJJ9Nhq73DS4WyjMKOKUvpbvb1DmQMwmE9GVVyPmKGDMWAAqupso7Wrk9OwhdFvLcXta0Chj8SlV+CuPEiPIMSgTYbgCpVwJjpbw8dpKoK2EOqWJdKA+7lzkcdA1aBJJnmj0sXmw7m72VO1goDxcB73VmM03ulSQq8iY/SIjDi0lvXwtdxaN4H2ZmiUxQ8n32xjtaWbQ0IvYZXNzafUqgiY1W3xBdBXraCOWIgEEJDwBOR8Y83gkahByu495piSuOPwmV0gh3j9SyEPlWxncfzYauZJGZycD4rIplYk0e2rYau7NdTHpbM89g9fbu5A5bAiuvXT7XAC8MvlPJ7TiMig1pBpjyTEnopIruWPEubx6cA17WyuYmjmQkCTx+ZGVZPmraG5az9zBt/Xse+eIedy7432SDRYyzfFsbyoF4Nw+Y5EJcto9Nto9thOe5xZ3N3N7j6G0q4H7dnxAQAzfwy1NR1lTXUy7x45PDKCWK3l+7yq6fE5yo5Kotbexp7WCd0u+7Um5T9HHMCG9kDpHOxmmOADOzh3J2yXhtnoKQYZCpmB/exVT9YMIiSFEJFwBL5sbSxiTnM+K8m18XL6dB8bMJ9lgwR3wsbOljARNIhnaDGrbvSc45EMTe/HGlKt568gGPijdTLO7G5VciSiGkMtkXNJ3IlXWFkxqPXJBRkbMHG4s+5aklAFoFSquKJrGFUXTAHhhYhZOvwelXEGb2xbpaR4hQoQIESL8FxJxyCNE+E8m6AVJhOPK0z9GtEGBUStHr/lB6nbpZ9BcTLD32WhNI/F370bdUcPwYVqOtsuwWbdjlB2iy9GOQjiNATqo9QaRV32FbsCZ2PIuQaFU0tAUbncVb1bR7shmo/oyhiT5sDaEEKQYRkTXYWn4guGWJDrW9cMV3UJNog57wMng9ES8ARGZAJnxWkobXUhSFP2H9MLnMdHVtRVX015K7Um0i1GI+gEoQtuplo1E4QqiVcmICypITcogtmguIZWfA7UKJLwACLnDUEhBCAi0Wv0cte7i7aa1aA2nsWjoiX3bQxod3uRcRL0Fo0GPKAa5dv0TVDo9RGm0jE4eyKG2UhLWPk5cezVBmRL5rI8RFBr49CpoPhg+kEKLX5fAa4o4Mr2tJAccZLq30GaYhygJyHOnwapboeQTRgAuQcExpZlZgQ6U9oOkBpy8v20JstELGZZ1CoMLZrL36Ld801rNWw1foxMDdCb04Zxdt3Bx1ABGf/smKw1ZZPl9tKucDMwYAq2bCClcPG0YSK7fiqjQsv3gp6T2nUT64bVM2v4E53s6KDZo2BTdCwmJ/e1V7AfuHnEuEzMGYFJpeSO6L9m+MqrsrSzMySQY7GBZvRVv0I/heOuzNw6to6y7kZUzbkOjCIvitTi7+ab+EADTsoagV6p5qbyUSdFqrut34n2fnjWYyZkDaHF2M2vVw+gUambljuS24eegkiuYmjmISmszldZmJOCi/AlcXji151x3bl3KivKtiJKEQalhWGJv9Eo1ITHEhLQi5q5+BG/Qz4H2akYm9UEAGpwdNDpBAJaefiOJ+mgWFX5f750fk8bg+BzKupsYlZLP2pq9VFrDiy0jkvMYnNCLzyp38WnlTu4bdQFf1x9kb1slG2oP8PDYi8mzpNLs7OKZvZ/yfsNy7jllds+xX9r/Ja8c/JIhCb3Y0lQCwMS0IsamFjAyKZ/3j22iydXFt41HUMuVLDvjZtxBPw/v+gi5bQOHOmt57tTLe6L+SpmcaI2BM1feT7W9lTWz7iHV+L32RIQIESJE+N9DEARWrlzJWWed9YvG33PPPXzyySfs37//N7Xrn+WH11NTU0NWVhb79u1jwIABv7dp/zZOzk+MECHC74YoSSdu6H06jP0LxPc9aWxIlKhodmH3BHF4QjR2+nr2tyvicQtGSrr1mJMmkJ58Duq+FyFoTPgDIjZfMk5/AiFZJiAxIBlmeF6hMpjB6t1tyPQxBPTJuHwhBCFcmy5K4JEZMKhERksbGCTsoaRTjV0WQ7kyFwnwAU8Wf8wl397Pl6V70Np9GNwB1KKLMUl2xuRF4faFaLd24vG56Go6iL+8GJNGQKVMQhd1HiJGJAk8fpGs/HQSrr0GucGIShVDdoIWnVpGr3g1eZ++itsVRBAgGJKI8urI9SlRNXUA8N7Rb3l01wqCYgiVLgnFxWtQz12G39tBV+UmgiGRbJ2a9JJaCAQZX3AuLyafzvK4ISgGXYQQ9EJHBRxcDq2HwZQCQQ9Key2l+qGc6m1GgYS88xhJXz1B9tJ70DSXwehrebXPebxgLuJxc3+Sgy5UziZmF0zioEzLmqCcd/atZlfyNEIKNZcVTeXLcRdTocvEpo1j2+EvqVIYaFPokCUPorcpjvlpeVzffzq5BaezU5/O85i4qXsvM1w1VMnUrD6yjpSQGlEbTWz6cIK6WDS6GFJrvqFX4w4u6DOWqwecwXn549AqVCw58jXvl22myt5Kjs7IrHiJc9KieHvypXxTfwhfMLwAtOTIej6t3Em1rRWALY0lXP/t6ygEOQalhgJLKnmWVM7JG8+abrhq60o+Lt8OwNqavQx/788sObweT8jP+LRCFDIZH1ds55GdywF4dsJlrD77Lmb1GgXAZ1W7uHnTEj4q28q2pqPcP/oC+sVkAqCWK5mw/DY2N5ZwWdFUcqOTWHbGLTw1bhHXDjyTx8Zdwh/7n/b92LQiLBoDVbYWOo8rsQN8W3+I4rZKHAEPxc3lKAQZA+OyaXB08uSeT+j2hvULAMq6GxiVlEe0Ws9z+1Yxd9Wj2H1ukgwWzu41ErnWQ6rZTEgUWVuzl2f3fYY3FECjUCJDIFptwBsKcM/2D3jt0FqWHNlAk60WpSDgCwU40lnPwPhsLGoDIUlkZ0sZNbY2vqrZR7Oziyf3rOTUZbdj87kIiiHW1+7/V6aXCD/BggULel5sf/j/n2Lfvn3MnTuXhIQENBoNvXv35rLLLqOsrKxnzLXXXsvgwYNRq9X/Uy+VESL8N9PW1sYVV1xBeno6arWaxMREpk6dyvbt2/+tdjQ3NzN9+sl6L/8M99xzD4Ig/Oy/mpqan9x/xYoVjB8/HrPZjMFgoKioiPvuu4+urq5fxb4fUlNT83dt/f/aLz0SIY8Q4T+EVquP7ces9E7WU5B2vPWZIAO1Kfz/xl3hXtbxYcG2unYPh2qd6NQyBmQZUSpk+AMiyra9EHDxbdQixADEdnlJtmSyu9xGW3UbY/KjCLXHoG0bR5+RiXy5twOzTsOYcXcSKLMjWn2EDn6EIy/cV1spDzvjBq2cgVkmhGMriHfVsdV8EXYsbNHNJT9VT8o9GtxAstOArFuGyyoy+Ota/AYlbs0hPI4KfOlzOWRNA7IwajIZkOUkLtHB0aCcZqsfhzdIlF6JXi0jI16Hyxfk2yNdFGYayI7XEWNSMXVgHJ79+6n58EP8o89FUOtJsahROOL5s2kk6LLYVWblxX1r6fB1E6M1Ml2VSvvRQ8QMBF+gkeT1SzjdY8QvxOC650bar7+B9wcn8qm1i03qdKoq9nLhvgKSRS9EZcDZr0D6cEI7XuLh/WvYrnQjnf4UrL4epCCIx2t8Dy5DHHsd55V9RJ3KxG3pU7lOHc2dnkr6jLqaM52dyLtaUCbPJOe9qYgBG/LrD9Ea9HF1VF/m6zVMnXgrrk3P8VyfyZzae9wJ6eNbGktYFDuGpKCLAq2Bc7oOY46J5tS2fWxurOG97HPQx/fmtvG30/eVUTxJOFL851CQpbo0otUGHty1jJAkopOrcIf8hOwtJGzZRCgqiScT41letpXNOSWUdjVwVu5I8iwp5B/v/X2wowalTE5ADOEMhJi7+lFWn30XC/tN4mB7DYc7a7lty9uMT+vXU4++s6WMVw99BYRTxAEcge97bx/ramRfWyVD4nM50FHDutp9fFW7D4NSw+qz78IRcHNm9lBWVe0G4Ik9K/mieg9I8OT4hfSKTkaSJCZ/dCdWn4tF/aYwKb2Iovgs6o+3aotW69GrtDw4ej6+H9Rji4JEUBJZXb0btVzJe6XfclHBqQyIzWJl5Q7GpvRjc+MRun0u8iypOHweLln7DE+MW8jdI8/rOc6N377Bmqpi5IIMnULNzuYysnVZTIofz17HLgAGxudg87vJVtk5ag2/qOQfV6JfduatlHTUolNpaHVbueabVxme2BuZIKPJ1cUFeeNYVbWLXtEp/+z08v8KSRLpspbh81lRq6OwRPVG+BF9g9+D1atXM3v2bKZOncrSpUvJycmhra2N5cuXc+edd/Lhh2HlfEmSWLhwITt37uTgwYO/s9URIvx3IkkiHk8joZALuVyPVpvym84Vs2fPJhAI8NZbb5GdnU1raysbNmz4TZzPnyMxMfFXO9af//xn/vCHP/T8PHToUC6//HIuu+yynm1xcXE/uu/tt9/Oo48+yvXXX89DDz1EcnIy5eXlvPzyy7zzzjtce+21v5qdAGlpaTQ3N/f8/MQTT7BmzRrWr1/fs81gMPzYrv/xRBzyCBF+B4JBBzbbIczmQhQKY3ibKCFJEAiF08SxN0LQA5Zc8HTD0ZVhB33IlWBOISEqnNbr9okkRqvxBUTW7OsgLiQnx1dHbHwRDQ4FZU0uDlQ7kAkigaAErjYSVtUQkMvYZFARCEp0OvwcavAyvJeJwN53UBtU+FUKtCoBj1+izeYnI05DjFEJfWZAdxWxshRaKzsIVWzDkjebTc2VrD5aytjYMQzIG0Wy0kHUmfuRUkdzsL0SS1Y8+7u/JlpzCT6/RLRRjSbOgbVlI2nqGFwKBfXOSTi9Im6fjMG5Kiqaw3XNh2qcHKt3UphpIj1Oi6Z/f0wPPkbQFE2Fs4JSh0CuIZtuQyJCyEd3l497hi7g9WOf8MSelXRbChnVKRHtS0QuyJCjYlGgBZ3nMK5p0XjdSxA3yYlPHs0guYnFcg2lSjOvu0uQJw+E9OH4K9fQFSglumgUMU0u5CodKFQQCIZr9gH2v4us+QBGKUCOXECuj2d/QMb+Cdciulrw5mWgcmYzeMtGom3HEJCo6q6nRa6hU6aiInEQf4xOInvmw98/LDtfhaa9cPqTjEkpYHmfgWSUfoJpxnNIMTnM8zth+4vcqayj3eWA6mLGmqKZJVMhIXFAYaJYFa6p7/A5CEnh58t93OYahZ4/+DN5ZdQd5FvDbb2+rjuAM+BFH2wnJpTPimAAhUzOJ+U7emq6AdpdNq7/5nWuHTSDj2bcypuH1+MPBbBojIxL7ct5eafgCfqosDYzNKE3s3uN4lh3AyaVjvu3v8+Hx7ZgVuvp9DpITLbw4Rk30+Ls5qbNi/GHApR2NVBta8Wg1NA3Jp0jnXU0Ojtpd9sIiCFu3fwW3V4nNww5G6VcgShJvH74Kz48tpmQJDImpYAMYxwhJGrtbVz61fNc2m9Sj/3dXhdRaj1zeo+muLWCvjFpnNtnLNlRidw/Zj4BMcg7JV8zJrmAv068ggHvXEujq5MbvnmDWJ2Z8/PGMSG9EIUgRy6X8+Kpf+SPG14kIIa4IH0kGap0Gr2NKGRH2d50lHW1+5ELMkLHE2G+bTjMxWueYURSH/pYUjg9awgP7/qIOK2ZwtgM3ir5mumZg7hz5LncOfJcAJqdXSwv38q8PmNJ0EX9SjPSfw4tbcWUlL+H19fds02jjqag1/kkxg/+HS0Dt9vNJZdcwmmnncbKlSt7tmdlZTF8+HCsVmvPtueeew6A9vb2iEMeIcJvgNNZTnv7N4RCzp5tcrmBuLgJGAy9fvXzWa1WtmzZwsaNGxk3bhwAGRkZDBs27IRxgiDw4osv8tlnn7Fx40YSExN57LHHmDv3e62gxsZGbrjhBr766itkMhljxozh2WefJTMzs2fMm2++yZNPPklFRQUWi4XZs2fzwgsv9Jzjhynrt9xyCytXrqShoYHExEQuuOAC7rrrLpTKvxH6/REMBsMJTqxcLsdoNP5dp3/Xrl089NBDPPPMMyc43pmZmUyePPmE+XDVqlXcc889HDlyhOTkZC6++GJuv/12FIp/zA2Vy+Un2GUwGFAoFCQmJuJyuUhKSuLNN99kzpzvO9SsWrWKc889l5aWFjo7O8nKyuL999/nueeeY+/eveTk5PDXv/6V8ePH9+xTUlLCn//8ZzZt2oRer2fKlCk8/fTTxMaGS8Y++ugj7r33XioqKtDpdAwcOJBPP/0UvV7/D13PD/nPWHKOEOF/jO7uYrq7d9BUsYn2yjKw1pDSvo5phTqKMsIOOsWvwt43w854wA3G5HC0fPcLSF3VNHT6yE/VMyTXhFYlRy4T0Epu8rxbaFD0psERnujs7iDegEisrIvpzlcxt27GMrcPwqR03EEJmQCGYCudLW00Hz2McvDFMPgyShrcePxhz0EQoLbdS12HF6s8ni2uvlS2eqh59Qbq1n3Axh0VPLD7PVa3rqElVEeMQc0A5WEMnv0Y/YdJzhqIJAloZFGEAp2cWqhmcI6ZcPwWZJIVraKTkCghECLZImfVrlZ0ajl6dThC7A9JFFfa6XYGEASB5Fln0CtZR7PgQClTIiFh1CnIy7QwMNvExNxeLOg7kdyoRCYOmUj+5NNJzz2brF7XsW3CE6g9XUgS6M3dxFiPcLq7FqvXhczRSq7oY7sumamZ82g97Wk4shLl0vNI3LCEc6KjWTvnPtRbnoGAG9+Iq/FPeQQJkGRKSBmEBNj6jeDGXAMKBL74+mmqv3oAU9BDokZJVk4SMkTa5BpOW/UYza4uFDI5JZ31TFx+B9/WHyYU8MMnf8K/6WFCBz6A3W/CZ1dTOGAO8otXccXhHQx/70Zqv34ENj5EklyGQgxxhczN1F5jYd7byOLyyFVreaZ9C4dbv+AavZKl02/kgrxxJzyP+9Ux2I3JzMgdzrjUfpyXdwq3DpiIN+DhkZID3L71HW7ZvISF/SaRYQyvlF/RbyqjU/P5sqaYtbV7AVjYb1JP27T97dW8V/otu1vK2XPB05jVOj6v3s2nlTt5aNdylpZuIiiJdHodAAyIy6IgJo3S7gZcAS9BUSRRH82nM2/n1clXMT1rMNnmBG4dOpu3p1/PHcPP4YvqYrY3H+O1g2tpdHTiCwWQIeAIeHAHfRzprKPK3sqY5AJiNEZ8oQDdXhd50akMjM9BQsIfCrKtoYQn9qzkSGc9Mz95gGkr7mZNzV66vE62Nx9jV0sZp6+8j9nHU+tLuxvZ3HiEu7YtBeChMReyfvb9INCzYNEiVbHXtZ1dtl0ExRCrq/cAEK02MDShF3cOn8euljLsfjcbGw7x/L7VPL9vNZsbj+DwuxmdUkBIElHKT3xheePwOl7c/wVvH/n6X52G/uNoaStm7+G/nuCMA3h93ew9/Fda2op/J8vCrF27lo6ODm6++eYf/TwqKurfa1CECP+jOJ3ltLSsOsEZBwiFnLS0rMLpLP/Vz/md4/rJJ5/g8/l+duydd97J7NmzOXDgAPPnz+e8887j6NGjQHhhb8KECRgMBjZt2sSWLVswGAxMmzYNvz+8UP7SSy/xpz/9icsvv5xDhw7x2WefkZub+5PnMxqNLFmyhJKSEp599llee+01nn766V/v4n+EpUuXYjAYuPLKK3/08+/mw7Vr1zJ//nyuueYaSkpKeOWVV1iyZAkPPvjgr2qPXq/n3HPPZfHixSdsX7x4MXPmzMFoNPZsu+mmm7jxxhvZt28fo0aNYsaMGXR2hgMSzc3NjBs3jgEDBrBnzx7WrFlDa2sr55xzTs/n5513HgsXLuTo0aNs3LiRWbNmhdvm/gtEIuQRIvwOmM2FhEJuatc1EPTXoOujRO+tRq6OQ8gcER6UMjTcZ1pthKoN4GgCczrIFHQEjRypc6JXy5kyMLxiZ9QqmBJTRsjZTl6wGFXaYNRKGQaNAp1ajsnZibzDA6427H1M7DtmxaSVY/eEEABldw01h0tRanXE5/ahT4qe6lYPXr9IYrSKTkeAGIOSug4v7fZwjXHCzKsR3U6UUfGMU4ylXFlDhmAhN16FzjgeVHKw12NWprCv61xkgozcmPdpbzWgz7wMg6EX2dlXEQy6+OZQO/Kgm9G7LmLryPcJCSqc3iAT+8ewprgNfwggRFOni2hDFEL1t/RT6JhZNIrL9u3nihiRG3vHwva/EmqopNO9gL2p1VR1NyF+/RwmvYiQ9iLdXif3b3qddYh0y9XopCCfG3PZoozh+eZ1LDf24gl7CQIStTItu5pPZ5SzkxhRJKQxEpN9btg5bj2EW1AwtbEZTaeLLxDwSxK+PmdgmvYADVVLyFj3Ovs6a8PLDm2wztbImMvWcn3jyzyijuJFXS6CJNFmbWGaq47daj2tHjtXrP8r52QOZH53MRWDJ/Beh5JBZdu5ofZzqN7EW5kL+NQ4HrNQiTt1EDQXMzt7MON2vsafbIfhYyuYksM2RifQ2+9D4XUSbNxLtzqBHc3HOC1zCGnGWI5ZGxmR0JtkgwVnwEu9owNP0M/hjhrcQTm9o5IYmtg7XJu1/X1MKh1quZLJWQOJ1hiI10Xx2sG1dLjt3D7inJ5nfHB8LpcXTiPFaMEfCvJlTTHBUFjFHMCiNnB+/jg+KtuGRWPgkuOR6zNzhvLqwTV4QwHmrHqE5WfcQrTGwKLCKSeIsxXFZWL3e6iwNnF50VT8oQCHOmqRCzKsPhd+MUi2OYFGZydNrk46vQ7Ozh3B7SPO6SkDuPjLp9nZUsaWpvCLklquxBcKUGNv4/qNrxOnNWFRG7D6XDQ4O5HL5CzqNwV3wMeu1jIW9J3I3tZKPi7fxsqKHbw59RrOyBrK6urdJBujefHAF8RqTFxUMAFRFFlevo0Or50Orx1vyM/MnOFsbzpGYUwGhztrGZ2SzwX549EoVFg0Bi4qOJUL8yecMHfM6zMWT9DP7N6jfs0p6XdHkkRKyt/72TEl5e+TEDfwd0tfLy8Pv+Tn5eX9LuePECFCeK5ob//mZ8d0dGxEr8/5VecKhULBkiVLuOyyy3j55ZcZNGgQ48aN49xzz6WoqOiEsXPnzmXRokUA3H///axbt47nn3+eF198kQ8++ACZTMbrr7+OIISDEosXLyYqKoqNGzcyZcoUHnjgAW688cYTIs9Dhw79SdvuuOOOnv9nZmZy44038uGHH/7k4uGvQXl5OdnZ2X83Cv/ggw9y6623cvHFFwOQnZ3N/fffz80338zdd9/9q9q0aNEiRo0aRVNTE8nJyXR0dLB69WrWrVt3wrirrrqK2bPDgqwvvfQSa9as4Y033uDmm2/mpZdeYtCgQTz00EM94998803S0tIoKyvD6XQSDAaZNWsWGRkZABQWFv7Ltkcc8ggRfgckScLlKseYrEDZ4UIbk0+7O4kdzcn013tI1znAWgMpw0CmgKzxoDYRSh1JeYdAtFJBQpSHZEu4rzOeblAZsCdPYGNnIYIgoujwMmlALCrF8T9IipSwMFlMH5QKAZkA/mA4fdkuxCNFJdBbpyQ6NR2AZIuGZIvme6ObiqG2gcy0kbS2NWP3xzF4WD90BhMHax2ckljEaJMFW0jPnmo3mvwoAqEEkpq+wiTJSLLMRiaIaNQJqI6nULd3Odld5casVyARRZHjPQz+RrRKARRyMtVdHNi6A0GZC6gBOQ2dARK61hL76TlICDybcwHPj72UqZnH62u/eQi530nQN5T4+FSmxYyhPmEKQuPHNL1/KdaCWTykEZEDVhRs0iYhzxzL1JYDjPM2U6KyUNnrbE4//Bp9gAs2vUJ2yyauTD4NS3wf7t+1hNgNd4azFUQRJBGbx8Z+XQpfqRNYse1jHlbHcu32o3xp70YAJMCrjmKoMY5OezvftlRwZeKpDFQpkPwCmqr1PNH2Lda+p7DsWClPKZL4suEIFxbOA/sh/JKEPW0k6BX4S1YxUPE5loLhTE3NQZcxHLHf6UxoK0O37obwPajeCAoNZQNnUKUTiK8pw2TI48/lR7C22WlxW6l3dpBuiKXC1sLG+kMUxmaypbmEBkc7Vp8Td9CPWiZn2YSFaKJS6fTY2dtWyaD4HG4dNgeFTI4khVPBnQEvTa4Ta+jkMhkfV2yj2+tkZGIO7w7PxSsKXLTjKAqZjJAksrpyNy3ublrc3RiPK7vHaEx4j3cVkCEgEwSu2vAyDY4O3pp+PVqFmjM/uQ+lTMGnM+9AJgjMWfUI9Y527P5wbbpOoQIU3DRkFg+Mno/d72ZGznBOSe3b44x3euzsb6siSq3nmQmXsa3pKC/sW02jq4tTUwv5uuEQ7T8Qg+sdncyNg2ciAWa1nhW7PmDdN8+yURXDsMTeyAQBhUzOE+MX8ti4BZR1N/H6oa9INERj9bn4rHIXqYYYiuKy2NpYwvl9TqH9uICcJ+jHFwqilisZlJADwLzVj3GgvRpfKHBCvXqv6GQeHHPhPzTf/H+gy1p2UmT8b/H6uuiylhET/fs4xP9qBCRChAj/OuGacefPjgkGHXg8jeh0ab/quWfPns3pp5/O5s2b2b59O2vWrOGxxx7j9ddfZ8GCBT3jRo4cecJ+I0eO7FE4Ly4upqKi4oSILYDX66WyspK2tjaampqYOHHiL7bro48+4plnnqGioqLHYTSZTP/0df4SJEnqWVD4OYqLi9m9e/cJEfFQKITX68XtdqPT6X5m73+MYcOG0bdvX95++21uvfVW3nnnHdLT0znllFNOGPfD349CoWDIkCE9GQzFxcV88803P1qLXllZyZQpU5g4cSKFhYVMnTqVKVOmMGfOHKKjo/8l2yMOeYQIvwOCIAdkROdGkRSjh/QRdFt1hOqdKBWycP24vRHUx8JOuS4WcqfQ0unlaIMNpeghINOiUghkKluh+DWIzUPKPTccf5TCiu0nvD9qzDDsKgBigIQoFS1WPxpRJKrCCsl6ck4ZjVIlP8leAKrWg9eK2yAjzVyOweYl0TIfzFpSYzXYrKV0dm6kyTYUeSiGkloY8sWleAlRkv5n2m1+AiGJVsUkBmaZwNON8/P78fW6hU5HgJAI+6LPw3HupUzODP+haiw/RK0yH1AgCCBJ4A2KbBYHcJoymn0FdzJUn01FdwtTMyEQsNE9YSE6vwq9/BTO6xfL0Y5COrudRDtKuFBUIu77nPfsVbxk6suz0f25Q6dm/qwnwdXJ3q+fRawtxuIKwtBFfN1URrGkRi6JCGKA5/Y/yz51LEZjMmpHEzqlnjk6DS/5YKU2hV5+G6c7KjGrdPx5yNl83pqAtvRrFnQcROt3oK3agPGrW7hu1G0sO7SSSnM8ywecxurP72a/KgavPoXz0/ryfnMrZn0iaQP+RJYgMdjrIVZrormrnsnO8CLJ6cceY5U6CbNChlqh4u3D67g/qoA53eGWZAS9xJt7sdfTxqmtFdBUxgpJZJ7iLMyWXKZmDuS5vZ8BAjqlhqf3fsqetgrUciXPTbicNw6to0/ZKjQvjoDrDuIOhXhx4h9J1If/6DQ5u9hQd4BN9YeRIXDPD5zG7xiVnEe9o4MmZwcayY8kwitjZ7O3dguv1LVi87vJMMYxKWNAzz46pZpbh80hEAqSaYpnX1sV6+sOAOGabytOau3tADy2ewXNrm6OdNYhR+CPRdPZ315Fs6ubbq8Ti9bI2Z8+SLvHjgBcWjiFP/SfjtPvwajSkmSwEK3W89Cu5fSJSuaPA06jpLM+HI13TcUXCnDV16/gCnjDdfLl23ls9woeHH0hwzfdx2xnIwuSpnLVwDPoG5uBEOyko2Mz0dHDkCSJkCQSCAUZk1zA+pr9NDg7SdRHY/O7WVm5E/XxdPTrBs0gXh9F3nGRt7U1eznQXg1AtikBURJ7RPL+W/H5rL/quN+C3r17A1BaWnrSC3eECBH+PYRCrl913D+KRqNh8uTJTJ48mbvuuotFixZx9913n+CQ/xjfOa+iKDJ48GCWLl160pi4uDhksn9srt+xYwfnnnsu9957L1OnTsVsNvPBBx/w5JNP/kPH+Ufp3bs3W7ZsIRAI/GyUXBRF7r33XmbNmnXSZxqN5kf2+NdYtGgRL7zwArfeeiuLFy/mkksu+UULBz/8/Zx55pk8+uijJ41JSkpCLpezbt06tm3bxldffcXzzz/P7bffzs6dO8nKyvqn7Y445BEi/A6oVNFkZ18JyCAjPAn01kN2ggyp4xCYs5D6X4RoTOA79/hInQNRgpzQYeqFbAB09jLQyUGhBo2ZKIOKyf3VSGIQtSYOpfz7ib3V6kOrkmPShb/2wePaXCPzo5Ekkc0KBZsO19Av6QhqbV/2VJtJ0AaRH/wUc3oq65W9mBhnIiVhOILVjD42g8PWaLA6aOz04vZHkRtTxIBACUZnDbWaGXhi+tGt6k2dR49BAXq9AqsrSJfDT3uLncLGjzB6Kigbu5hWW1j9ur7Tg0wGzd0+0uKzcPpsaN0SMhFaZcf465HlXJo4AQloS5xCnqBkSn4Mfo+bbWXHOOwfwbT0IEGlGV1ApL7DR7xZT0qfLO7a/gHVhgQGdR/lWGwR+UY1pqZ9VH5wMddrevFA3ylcWfwsQscWOLsUQ9NRZhR/hOncdxm4fxWh1q+R5Cp8vSaj9nZDTC5nGVJp3PMR5zoqKPR3htPT9QZGJE9h+IEvsOn7UuDpYmh0HDQf5k6bm492fcgIRykZbX6Ug87kgM/HdUEbqv1vIl+0jjfaKnhj2dXseulUTrnscxL0UdC0n9eX30TQmINZ9POH9j2Y+i3ggoJTWV25C0mQcYepkH55U8ht2Yui+huiXHamT3yYFe1WRrsbMTkaaQ2B29nB+LQiTt3/Bjf4NcRHJ7KjrQIAXyjA13UHefbUy9la+yVuQwK+YJAzPnmAP1oPcZn1ELY5S3ikpYmvavcxNWMQBzuq2dlSxhnZJ6bUPXbKJXxZXczGhjLkQhrZUck8vXMF9oCPISYd5V6BWkc7E9P7n7Dfgr4T+apmH1d/8yoAMkFAkkBCItOcwBWFU3nl0FrePfoNoeOrTn8ZPpc6Rzvbm49xeeFUrhxwGhqFCqNKR7vHjgTsbilnW9NRyrubuHbgDGrsbXSrdOxrr2Yte0nWW4jRGpm64m4+O+sOsswJXDdoBiWd9YxKzqfu+EKA3e+iMyWPlho/ZXI9CfootAoVja3bWFd3mDdqPmZa1kjyLakc7qzjYEdNj4heu8eORW1AI1fSx5JChbUZnVLDF9V7UMuVKGVyMs0JZJjiyDDFs7hkA0tLv2X12XedoLj/34ZaHfWrjvstmDJlCrGxsTz22GMniLp9h9VqjdSRR4jwGyOX/zLhrF867l+loKCATz755IRtO3bs4KKLLjrh54EDBwIwaNAgPvzwQ+Lj438yip2ZmcmGDRuYMGHCj37+Q7Zu3UpGRga33357z7ba2tp/4kr+Mc4//3yee+45XnzxxR9VU/9uPhw0aBDHjh372Rr4X5P58+dz880389xzz3HkyJGeVPkfsmPHjp6oeTAYpLi4mKuuCgesBg0axIoVK8jMzPxJ0TlBEBg9ejSjR4/mrrvuIiMjg5UrV3LDDTf803ZHHPIIEX4HJCmEzXYInS4NlSqmZ3tj3dsEQk4yGnbQnZSGvWENCQmzUGvTKGtyA5Bk6UeKIBH0NtOrYzXIciFlONgbEH1uvEEjFoMSwdkMRz+G9DHYjH3ZVmpFq5IxbVBYlGtkXhTBkIRaKSM4IglxTzsaWQNuVwV2lxW3bypdfhdqR5CGiipMObPZ0RkiVyEyKHss+6vt1LS5w/XnMgdJ+lL8UiHG3HTKatoocWeTOfF1fFXtJDiqycpKID47A6srSLvNT4VDg/rMW1EqnHjcjUACcgF8AannWj1ekdPTNPiWX4GojOfJ+FMIEiLN4keTNYJxid0cC6Tz7REr6fVf8LT9KMdCNqKEs9GrXKRYVBg0cmJNSoIJExkSKzG6tgKaYMyo8Qw1RZPSup6WZgddRoGD67dQBHijs9CYkojb9DSlzi7W7FvBJ34FH6adww5/Kaq9YdGQ4NibMK+9mZmqaIr8nSBXwYgrsWNFtLbjF8MlAcYFn/Ntx0Z0YgtfFtej8Hfycvsm9KKfI417eaR1E1oxiNRyAOeRt8lacT03I8cs+qg58BH1agtjY9OoVepBELhzzEU0tQ9hXsEZZBuiucZ2EFVGXypkWs6q3sPZsYOwehVM6mxhtgCnzX6WVW9dgDFjEiZlAu3WFmrtbRRFp1Pf6cHvc3PfqAu4b/v7BCWRN4+sp9vnZKU8FaU5g4uPbaFPdAqptv3IxQDL9n/GfpmFZL2FTHM8a2v3sre14iSHHODxPR/T5Ozi5UlXctvmt7H6A4gIFNs9jEjKY2B8NkVxmQCUdjWQpI/GrNaTE5WISqbALwZRyZTIZQLXb3ydS/pO6mmBJhNkXFQwgUxzPEExxIH2GvRKDevr9lMYm0miIZrpWYN568gGdAo1E1KL+LRyByaVjiOddQDY/G5OSenLpsYjNLm6aPPYkCNjc8MRsswJAGyo28/0rEGoZOE/mY/vXsmYuFw2JSZwZvYQGh1dnP3pQ5yRlkm3T0m718uK8q1cXjQNBIFJ6f051tWIhESy3sJnVbvY0XyMV6dcxXWDZvLwruW8e3Qjh9pr2N58jD7RKaydfR/ugI9JH92BLeTiwR3LTqh//2/DEtUbjTr6Z9PWNWoLlqjev7ktNputJ730OywWC+np6bz++uvMnTuXGTNmcM0115Cbm0tHRwfLli2jrq6ODz74AKAndbSlpQWPx9NzvIKCAlQq1W9+DREi/Lei1aYglxt+Nm1doTCi1f66bSI7OzuZO3cuCxcupKioCKPRyJ49e3jssceYOXPmCWOXL1/OkCFDGDNmDEuXLmXXrl288cYbAFxwwQU8/vjjzJw5k/vuu4/U1FTq6ur4+OOPuemmm0hNTeWee+7hD3/4A/Hx8UyfPh2Hw8HWrVu5+uqrT7IrNze3Z+4ZOnQon3/++Y8uGP7aDB8+nJtvvpkbb7yRxsZGzj77bJKTk6moqODll19mzJgxXHvttdx1112cccYZpKWlMXfuXGQyGQcPHuTQoUM88MADv7pd0dHRzJo1i5tuuokpU6aQmpp60pi//vWv9OrVi/z8fJ5++mm6u7tZuHAhAH/605947bXXOO+887jpppuIjY2loqKCDz74gNdee409e/awYcMGpkyZQnx8PDt37qS9vZ38/Px/ye6IQx4hwu+A01lGR8fXaLWppKR8L4SlUsUiuT3IjOnQegiMWo5UNDIi+CXDcy7gWIufZlsQueAn3/I1HYZ0tOYp1JSXketuY/PBbrwhBYUZBnKDteG0944ydHFFJBgFzI5DsK8WBlyMXCZDHnBA3SGCsQOQJOjy5uITG8kytZBuXkdC0lQ08hyqtcl47DJkgoy6di9mnQKFPBzZl4BUcyV6eRkdHoFDzlNQx/mQt/hwubsIxnSTatxBUJ3B+v0GBJlAtD489VS4pmJUNqNX1BKnPUpC4unsr/YQpVeSGa8lxqgKn2f+m4QEORMOOBlkHsxZQ3Jg+HmYgeDRbtRdR+l74HpeUCewxpLP/K/nUjnkAQ5yDiXefTQrVfTp6iLr00eRCXIYvACd3QkBD0qFESlhCrfGn4fFdog3fC6yiubQ8crp2Apm0dLSSXbbAT4bew1HonLw71+CsnU/nQMm4m7YRrrop0FhoEzpI+vct1Bkj6Wt8lkAnh1/EfUuJ/3+j73zDpOizPr2XZ3z9OScAxNgAkPOSAYFQQxgVsyKypp1FdMaEXRVzGDABIIBEAUk55xmmJxz7Jy7vj9ax2XXTe+rG96v7+ua65qqeqrqqe6qp+s855zfiUxm86cfoDUYWDx8Eae+exKt3w3GZPJypmBuuxnx4Bt09B+J5Oxq2hUx3DRwCZfoPLxz5htGxoYicXeydP7rvF62l7fO7qK8p5nc7l7W5hTDzhe4OTSNnXM+ZEPNEb7v7eI2WwMXtZzF9kUmO9LSeEqdSkF3OzWqwPdmVGqJn7WMjb2t6FQ6QlU6BkVn8FHpdg62lnOoNSBg5fH7qOht4fML7qeu90ru3fE2qcmDaD+2Hqkg4dq8iQyNzaIoKv3nG9zUBF/ewh5jFoWROVyWNZqcsEQ8fi9yiZQBkSkcaatiX8tZVFI5l61/nlCVjl1NJQyKzuSj6YtIN8YyJj6PLQ0nUMsUjE3oz5dV+9laf6IvX/35MddSGJmKQaGheNXdfaevNjm5Y9ubqKRyJIIEu9eF0+tm2bGvALgyZxz7m8sBEBBYPGIeD+7+gIMtFUgFCS6fh+cPfcGVueNZcXozZreDH+pPUtbT9OM9L3JtwSXMcTs5L2UYi7a/i9XjZENDHbnhiSglMv4w8iqmphX3qc6r5UouXf98Xx9/Co97/tAXfFS6naExWWhlgfC9sp4mTrTXUBCVysbZjzHmswf5pGwn1/afSJLhl+vB/rcjCBJyM+dz9PRrf7VNbua8f4mg2/bt2/u8WT9x9dVXs3LlSmbNmsXevXt55plnmD9/PmazmcTERM4777xzXi4XLFjAjh07+pZ/Ol5NTc05pY2CBAnyzyEIEiIjx9Pa+s1fbRMRMe5XHyt0Oh1Dhw5l6dKlVFVV4fF4SExM5IYbbuChhx46p+3jjz/Op59+yq233kpMTAyrVq0iNzcXAI1Gw86dO7n//vuZM2cOFouF+Ph4JkyY0Ocxv/rqq3E6nSxdupR77rmHiIiIc0p5/SmzZs3i7rvv5vbbb8flcjFjxgx+//vfs3jx4l/1+n+J5557juLiYl577TXeeOMN/H4/6enpzJ07t88zPWXKFNavX88TTzzB888/j1wuJzs7u0/07rfg+uuv5+OPP+4zsv+cZ599lueee45jx46Rnp7OV1991VfSLC4ujj179nD//fczZcoUXC4XycnJTJ06FYlEgsFgYOfOnSxbtgyz2UxycjJLlixh2rRp/6s+C+K/QaXEbDYTEhKCyWT6zUUHggT5T8TrtdHZuR2dLhOdLuDxsfd04XG6CImNA5cZ35F3aPDH0CvEUujYDCPvod2l5UB5G+GqEiI15RhDBlBnGkhDh4MpjpVsUV+BX5AxvJ+R6BA5dJZBaArINXB0Bd0dZ2nxC+RNfgKrW4KtfDu2ng7SkqJoCxuFKIq8W7IB0XWMcouLapuUx/PuQRAEZBIRtxdcXj9Ds4xUt9pobV0HSCjoNw3RfYIzremkxUSD+zBy8ShWYRzdzmjCpCeJj87lULUGiQB5iVpKGm2o5BLiwpT4re/zWUMzG1rcXJVwOYmaWCYVRKBSQK/pNCpVImpVGE63DxFQ/0meu9cnYmuvR79qChJDDCfM3fzOUMBVCXlow69gyanfc2fvCTalTEVv72RZ9WdIkkfhrdvNp/psFPFFzKjbzZZRG9E7Gxk/JJ3KVfPIbD3C9tx5JEgg4/QneIwpnLFbSfFZ0MkV1M5dhERQULdlPR2aGM6mT2Fj7REeGnIJYyNV+P0eQkN/rJvcVQV/HIhfIkPyaBfdrSVs3/oiB42ZlHtF3p2ykFCVDt8L6UhtnbgFBU+k3UR1/rVMbnufcjysberlGbGD1VGDOdpRy8CodC7PzGewQST066eQN5+kzZjGRp+ckc4WnggdwkLTSQhbQkzCXq5u72FUTAYVfjjeXs20lIEsNSggLA1f8khWl++mf0QyPU4rN2x+FaNCS6hKS425nStzxvHwsEv7PnOf38fvNj9FpdXJ6qJpqJ29kDsTUfQHXoJK18Nnl3NIGcWVMRPZfskfuOH7V2m0dOLwuRmb0J+R8Tn84cDqc54LpVTGuIQBnOyo4eJ+o+kfkcSju1dxz+DZjE7I4/0fS30tP7GRRH0E1/WfxOJ9n3B74QyUUjkvHfkyMEGkC6d/eDJhaj29Lhvf1R7FJ/pJ1kdREJnCoJgMHt0bUPQeGpOJTCJjb3MpItAvNJ7z0wbTbjchkUhQSeVsrD7MO5Pv4Muq/Sw/8S0A4xMGUByTwZU547n9hzfZ1XSGeG0YarmSBksnG2Y/RpfDzGP7PuaGAZMZn5jPrVuWc6qzltHxeczPHcuQmCxWnN7CK8e+4ZXzbkIAbt78OiqZgnWzHsSo1PG77e+yp7mUBF0Ebr+HL2c9TIjy3FDMNlsv75z6nrlZI+kX9ut6hf6c3/r3+5frkIeRmznv316HPEiQIP85/FIdcplMT0TEuN+kDvk/yp/XCA/yr2fVqlXceeedNDc3nxORVFtbS2pqKseOHaOwsPDf18FfIOghDxLkN8LpbMHnc6BWJ9LQ8BESiYKEhPkB41amJSZmxjntT21Yh9flYuDFV6A2hCAdsYgUQLR30/2ZgOePx4kadpSR2UPoNpeg1+cQGTkelc6LWiFB1R7BRO/3SAouR6X+UX09Khf83kD5tLgiriqrpNLZzWs1NZg7jUjJw6eSEKqHaGNgn/uGX8jBllyOHF5LTngoDrcfQYCp/i+ROjth2J2gUNBp6sbq2c9gMQpF7xEaZTUk6VtY7xhPRncOUiEVn6iizOein3QgBr+csXkGautX4zR1M2HA1chkOuo6zLS5EzhrdmDyVNHrMRHti2LziS5GZbbR3bUVqyeOuNjZtPS66BejBD8gkWLpaEO+ajKnMx/FOvBDBp24h0pRSqNcxx6bjzeKuugqdTPDVsdT5i4kMhXOyz5F03ocWd1u5lvOMtaez2BPLwMPXMLn2ddz3uePE1N4JUePRxCvTCPj2NNUygyk9dZS+NOXlTiYCP1g5LoE0iJOQM1OikUDNp+Hr6v20f/oKVKUavAuhxlLICwNJjyKRBcDp9Zw6ujn/N4Xit7UhWDvodtpIVSlQ6I0Ito6cYp+blZ0oMpJJqz/w7zz6QIUopqwzlJenP4kZ90ezkvKp61tE2ZLCbJwIyHNEN1bzTxVKBKPlZPKMK6Nmcyh8+LRrFjODwodh8PGc4cpYEQVKBXwzUIQJOzJmsNip4J+ofGsmfkg/ULjKetp4toBE/H5/czNGnnOvWq3VXJ7uh61uj/qDy4Hl5meq9awv241KYmTycm+CC75AJeo5BlFCDHa0D6F6jmZwzE57UxIKmBwdCb37VxJVW8LfkRyw5PY23wWi8fB/pazxOvCaXOYsHpc6OVq3jr5HV7Rh0yQopYpeWJ/IDw4RKnlZEctIqCUyLghfwophmgOtJSxunw3PtFP//BkznTV0e7o5e7iWSTpI6i3dGJyOzjb3YhMkOIVfVzabxSiCNsaT9Fo6WT5xFu5uzgQjij/k3DxbY2n2NZ4CpPLxq6mM6ilCpps3dxeNIOc0EQuW/88bp8Hs8fBvuazhKp0jE7IY39rGdsaTvHS+OtZ+MNb1Jrb2XHJMxiUAaXZ09e8CsCl65+joqeF4ugMlFI5LbZu3H4vC394i/en3c2f8kXFXj4s3YbZbee5Mdf8j8ar/xRiooqJjiyiu7ccl6sXpdJImDHr31bqLEiQIP+Z6HSZaLXpP6qu25BKtajV8cGx4v9j7HY7NTU1PPPMM9x0003/VelBQYM8SJDfiObmtfj9LhIS5uPz2fD7XQQCvH9We3TX1iJoNMijoohMz8JpsaCQeKCrHMKzaOlxcaraR269EsHtQrSZ0Svj8UjqCDE7IMqPXi0jL0kPSQvQmOqxtp7G7+9FEl8MKiOc/Bg6z+IrvoloTRYWsYporRFHj0CoToVWCR0OG9VfvEmit4zIokmMjC9m5KyAQIjT7cPm9OI6LaLxuUAMqMFlxkdjbrkGp+0YnvYG6tTDMHkTcHYf5LhhAIUyNT5RpNZuZXppF8peJ/Y7i/H7XYiCl7N1Zbi9Cup6IonXwaXx5zM61E20MoqtnTtINcQwTEzk8zoj6doonBIHLT0u1PtfIqtzA9x6gKZDO0m0tpN35GaMfjcuTTSZgoIXRLDHzsf82RwuuOAVSr1mVnbsQheWjCb7FZApEAUJ1XIDM8wV6P0eDigiSWv4AVr2Q9pUng4byrXNu4mPzGaFEMWtnmbieyoDJehqtmNc9zA2hQ6xfg8CEKnvJC9xEK1tZRxrO0KKvQ5EHyulkVxTOAOG3x4Q33sulbGObuYkTmeQs5tZjd/j2Gyk6s0jhMy9BqP8GaReF+9EFrJYIQOHhRsr13OjIIH5n8OqOcRFZLJ53BNYtrzMiHAN+ooj1Kgi2akIZ8CwG8iOzmRuewtj4nPRJOXD4BtYaWrgzQ4FV/urWSlLZFjGaGi6CErWUdR5illZ8xiRPhy5ICFUGSj3oZLKuTp/Am27/8gHNUfImHA/I+JyUCqjUCpj0ekyAtfVW49FqUUUvXxTsYOstDlIc2cx6k+eh3k5Y3hy/2fsbTpLq72HwbGZXJM3gRClpq82uYBAmjGaEx215IYnYnbbERExuW1c9/0reEUfueGJvDnhNsatfgi/KJKoC+fK3PFMX/s4AC6/l+cPfoHN6zrneTzTVYcIuL0evKKPm/tNwPPI4xiTXLTcdDkXZQ3HL4pcsO5J2h0mAOSClD8e+4Yvyvfy6oSbsLidAEiRkGSIZFbGUIqjM9jTVMoVuePpcVq4OGsUF371NJ3OQMm0mWlDONBazpqKvaikgZcDj+jlio0v0Wrvod3Wi8Xj6DPIASxuB16/H5lEwhMj5hOuNvDEvk9YU7GXBktnX7tdjWdQSOVcnDUSq8fBnMz/G7XJBUHybyttFiRIkP8eBEHyq5c2C/Lfy/PPP8/TTz/NmDFjePDBB//d3fmnCBrkQYL8RoSEFOLxmFAqI0hKuha/3019/Urk8jDi4i7E09ZG1QUzkRpDyNq1i7ThAcXHnpMvY5a7iPFNRNFQR6G5hZ6L55AepUaizqPNbcDbIFKLQLpkBy51PA2OKnRKG9YaOd2yKAo8e1A6zGx2jWKwR064TA5SgacKR+MXR+E1GrELNqZFG2mqeQuXy0ZW8yfou8rpUKqR29wcZCSpxr3I6eFE23hEyUxmDtchUQZKkjV3O2nyp9OkTiPOIMFkFhH8XnIkNtBpSJBYyej5jjkpGZisKciKItGHKDhRVoBdDEMmihjUVUAUMnk8IzK11HfFUt/pRCtXcKVjK5GvvMKEwmUcVerpJxeQSSDEVALegGEU0bKSdnUYqZZGXIIUoXAelzZ1EIeU1/acT49KQ8qme4ntKMUrUyOVJoHPy8UlhziVdBlPSa0MaTlChN9JrBhDZijgycKSdwFRqxdxfscOxOj+PH3LN+B1QeNhCEmATy8HlQFt7S4cSHBI5MR7bdxY+gFXhw3nufDBFBVexDtndxJbfwDv2fcRBl2PdOKT7My4gJK6Q2yVhBDfEyjnJS9ZQfooH92VKhxZOVR01aHx+wJ13tShcOW6QD16tRHsnWDRUdJVz+COKmIa2jioiODdnPl0StVM6D8TvSGKePv33Lx1OdNSi1maNg7H9pe51V7NVZZy+oWayNKFcJk6G2febXx+ejnPHXwGyuL5Qh7FCW3AGOoXFg9OM9FbHuEqYHH8UEZ0l3DmuyfInPQIusQCGBdQSA/zOHl5txEncpwHPmNm+lAKo9L6nodItQG5RIrL7+HOogv6vO5zModzoqMGj99HtMbIuMT+nO6oI9kQxZyMEZzoqMHidrC/pQwBgctzxmFU60gNicbstnNL4XTGfvYgGcZYzC4bPS5bnzGukspx+jxoZErmZY9hX/NZjEoNN21+nd/FDSe2vA1bbSel18xCr9Cw/Pi3fcY4gEf0UdLVQElXA8NX3cPKaXeRbozhkT0fUWNu482Tm3hs2DzWzjo3f/DG/Kl8WbmPM131DIvtxw8NJ1FIZFzSbxRTUoq44ftXsXtdfH7+/VjdTuJ14efsf8P3f+RMVz3vTbmTWF0YAE+NupLLsscQqQ4BAnXUb9j8KlIEjl31MvcNvuh/M1wFCRIkSJBfgX9DJnCQH1m8ePHfzJ1PSUn5j/1+ggZ5kCC/EWp1IgpFBIK1HVl3NZ7YPDweS99gIGi0KDMzkMfGnbOfU6PHgw+PXEKYvQzBZyIiETpba5C1myjrCUEpzcAmGMiuWQWCEiExEqfTRY1iDi5RTU1EEikRxbiq/RyUTSAn2Q6d35Bc24zULzK3+2p2mxzIfTBM0OD3munNW0C3xURMWhYnJIOwWXz4PE0gOJEKbjx+BdXHdpBEA97M2dS0BepOhusV9EvS4aqzkq5z4E6fSUK4CnlvD7TXYzMZqCscQlOXi9iy/XSIh2m0pjLQMACzO5H4kHYG9hsEQGQo5CbpmK2YDdvLABHRZyNRHU9Nux2Q0DT+daLDuuHDC/lYF0mpYghXJ4XTf+rViDIVss8XEWVvJtvRiF+dDgOvoer4aq6Sp/CyRsKgp6KoSZmPIIpkN+3l6shxDHd38ozOg770axD97Kg7xkFlJNXaeNISh8LOF6D0G7j0I5xtDmSXfUOv6zA7Sot5rrqJ23pP8kpsLJqT23kEOcnFV1KRMopdXRbyzVXUTlqIVKYiRfTzsEdNR2ghcomU75MnMb7FT5rED+3luHPSaI6bQn7KUQbufhi0Agy/DdLGBW6ON8eCzwPnv8ytsQWc8v0eR0QGAz++iMGn30D43VnQBAy4bmcgr25L3XEY9yoVjbW0Vm6n0GvhvJ4S3Gtv4bQ3Eq/ox5Q1hUi1ASo284kqB4fPjUIiIz8iFeRK3JOe5ER7NeMzR7Px5GoWhY1g2tkDLM2/GIBlR77i6+qDjE4optNh5uOzO2mx9bB84q199/WW+hN4/D56nVampw1CJw8ImL14+Es8fh9SQcLe5lK2NZzEh4hGpqK8p4n11YcIU+pINURRFJXORT96gdfPfhSA2394gzZ7L2323r94Bguj0uhwmLij8Hxyw5N49/Tmvm0PODbxykuP83bNXq6JDgjSLT+x8Zz9wxV6utwWAHrcNip6WpidMRyLy8GyY1/j8Lp5aM8HpIZEk2aMQa9QA3BZ9mhmpg9h5pdP8sfjG1h9/v0YfxTOA9h+yR94ct9nXLb+BS7rN5r1NYe4MmccM9IGs6PxNMc7apAgEKHSn9MfvyhSY2qlytTCodYKJAikhESjkMqpNbVz05bXmJ5azJ0DZ/7SkBQkSJAgQYIE+Q8kaJAHCfIb0dLyJaLoRbTKMXQ2I1caSE6+FolEjsdjpqHjQ1SvXkVc3IXn7BeddjkuVxdqdRwUJ4DLgkUSTmjd68jwMEpQIBPdnA6bi9uhwK+KwCU7H333QYbZ1tGaWEh0WCb68CRSrWZq2h14fFIUUhkkDgdbF+/1fs0W5XRo8GBKmE12ggQyhEC+uVJPjsOLo8qE1ngxcpkbT5cUBJFY60kUWCjfupbC82+g4swJ6i0JNHY6MNk9nHGK2DwWqtscTMjvhy3zMvacsWD70aPdZjbwZEkJfs4wbVp/nBYdSRGhfdfu9vopb7YRH6YiYtwDMORGhqiMbDzUDH6RuN6D9B80G0q3Q80OhiWPZ3jUMAZI4pD1ethv8XJz8vUkRthBvgBJZD8IS6M8Zhiyg2uIlnSC6GOhqYTLu48iIPBRx3bCvDbknX6WJF7O3c7DDE0YwKTGk6Q1NsGxD0EbBeZGfO9fRsvnrTSMGEjcTSPoVEgwS+RU5l+OdsIdkFDMFbYO3glJ48Vtb5NhjOWwJh6TT8Dj95NYtYMXx17PgaZjFClrSQvLQKzppdNlI9LchN3hxNzaDHmpoA4L5J7/hN8XiAxQh0JYCvKtjzPw4JswYTEkDQtsUwTEvpqt3bh9Xn4XGUNC9WZe2/QsNw+9krnNZ7lHqmC9qhRFRDoP1p5kY2ga9vMWUacN5fTQsTxEFkfqShkePYDdK94id9R4EkYuZNv6p9i46XkuHzKPRMt2BuRM6Ovama56mq3dfFa+GwFID4lhXr8x59zXN+VPZUfjGUwuG3ubSpEKUhL04SwqnkVJZz2VplYOtgaUz41KLakh0QyITOGx4Zfx6rEN1JjbqTG34xV9XJ07gbyIJACeHHEFoghb608gEEgKCVVo6XHbqDG10Wbv5WRnLZOSi7g2byIAHXYTw+OzGZYxnCHiRUglgZzDWelDWV2xp6/PPxnjcdowmm3dPLT7fdQyBdcOmMjYxP7M3/giZredSzc8z5j4PN6afDs+vx8REY/fS5u9F4/fx5ryvdw7ZE7fce1eF9/UHATg3dPf0+Oy8fCej9jVVMLM9KGBrxuRqzYtZeOcxwhT6fGLfq789iXcPi9KqRynz41MkJBmjOGZg2vIMsZRZ27nREftPzQ+BQkSJEiQIEH+Mwga5EGC/EaEhg6lu3sf7ToPankB8rB05PKAweTzORFFL36/8+cdzqwGtxVJ/hUBYxxAEwGaCPR+EVEAQQS7JBSDQUv/ggHQIQdjErZakWrvGIoVO8hNHAiqELY1nCJcG0J2fBjxEVegtdcgOHtBFDB0niVO1kuLJBxp21HsbgW9zdXEesoQRt6LXq1jbP+fw2gHZzrxeH04W4roaKhHnZiDQS0h0llBvSIRr89Honw3Ol0djZahhGq0tLSVopCloPUcRYGO2IQMShpBJpHh9nsQpSJ64QtMXT7C7CORnd1ES+b1VLdKsTp8aJRSut0y5n39EP30cSw7+z46aw0MKwaZkt7pL9GtkpItq8HlD0UZZySp24XbVomzfSM10eNIXbkI8i9l2sTFTEstBr8fBs5n3MkvkHYfwSxIMYy4nYMSDfdVHufe7oNILGdJW387D3TXcFYVTWJyMdqyjYCApLeMlIleoiTbub0khZvyZ7AuLZb08m9w73uLxrKTxPfLZ4jeSL4+nJuLZzH28GtI1/yBMrkRmaeXoZd8QOGACTy8fSm1JTtZEifiTM5D6xSJHfgA0cpwZGHhMOSan++N/cth76tgbgSpEva9DkdWgEIP+14NhLPfeRxkSjrraynf9gg2czvFEhcDu0/xUIWGK7s6mJc9hrSQWBTZo2HN9Vzeupvh48/DY9pJszuORk8jOVYbN3z3O3pDi/lurwZbbw8JcSHcc2QJCyQqqqJ/z5jEAfQL+7m259JxC2i0dvFFeUBcrMrUys4z3zImsX9fm3RjLB9NW8TKM1t5fP+naGRKjl65LBC6njWSLoeZ0511GJRaiv4k1D3VEE2X09K3/HXVQRDhyZGX8+jej0nUR/DahJs51lbFE/s/pbS7kR63DSkCiboILskaSboxlmlrF/Pw0EsY+yd9unLjS5R1N5FujKHN3kuzrRuJIGFm2mD2tZTRYTdxXf9JlPc00Wzrxu33sa3hFBOSC0gzxlAQmcqRtipClBoKolLx+n3MWPcEHr+XjbMf44/jb+K9M1uYlFJIt9OCWqZELVMQow3l7uJZVPW0oJTK2Fp/km6XlcOtlWxrOMW4hP5Um9rocVnx/xhRIxEkFEelc7qrjpnpwxARuaNwBou2v8v7Z7ZySdYoVl/wAMn6/5tl0YIECRIkSJD/qwQN8iBBfiPCwobi9zvxeMxIUieBVNW3TaEIJSXlBgThRwVIUYT2M+D3gMcO0pC+tk5nKy0t6wjLGobMIsPQvA0coSBVQEw+AAnhDnx+kfC0OXSYull38DgvVb1JuErP1oufQnU6IOwGIgy6BbMqgY6WCMJ8rRjNpzjsHEGXbALDBIiVyP/iWhLCVWBuRuzcSYhWjdRvoqO6BlmylhEnutAZJbR6uxFFkYGpIbR17sJmcVDtCiM6zwTiVpKj09CpQ3gz4Q46nSa6O9W0mhIxqkpJPfgilG8iQR2OLfEqYkOVbDvVhccnIvhlNLm60SXkUt0bRuKuJciPfUB97FA+icnnodw4xEg5glRCUqQawRPF6TIJis4qMDfDvuXQUQ6OHpCpoPoHkoquYk3OfF4yO4jsthCtlSMCJ1RRHPOZKYotwNB0iG6ZHnXlFjAkgK0dweeGlJH0Ko1kRhZTkDAS9cE3YdtTnM5/iorcx2h1HGXY+lv4vLceKj+E0b/DEX4UV8b1fK8exqDGHYQ1H+O4WaDJ5sJzfD8R7Q3oZn6CRK7G7fPg8fsCit6mJtj2NJaOCp6VxzMqMZNp4++CH54CnxsQQJAEytq5bPhWX4/9xB7GqXsZJUi5MOMqskUtGzSJiG47VrcTpVSG1+9DNnIhPvSEOmS4Oo4xwF5GzND5JDntoA5Dl17MiISBZAweTotfxKaNQx/Zj5VntrK1/gRvTbqNMQkB41anUJNujGV99SEAIr12oluOc/e2d3hp3PV9NbczQ+PIj0zhi4q9CAh8W32YdZX7uXPgTPIikhibOOAv7r3imExuL5xBrbkdtVTBDw2n+Lr6IC6/h+9qj6GSyrm96Hx+qD9JaXcjAhCrDUMhlXK4vZIYbSgev496SwcnO2v7DPKy7iZqzW2YPXZOddbh/VGsUBRFnv0zpfJWWw/nr30Cm9fJmoo9DInNYmb6EN6cdBt+0U+ztZt1lftZVbodl9eDx+/FL4qMSxrAuKQBNFo6Gf/5w2QYY/li5oM0WrooikqjvKeJ1RV7KYxMpbvDSphaR4/LilKmYP3s32N1O/m8fDflPc0URaYSrtZjdjvIDI3l0n6j6XXZ2NtyFgCTy0aGMRa17L9HVTZIkCBBggQJEjTIgwT5TYmIGEtHx1Zqat4gPv6Snz3fgFT6s6oyggBDbg0YWaofjXFzI1RtxhuXjc/nwKEWicmeAEpA/6N30twE9btISj2PpNwoqPyOzuYWwuUjyNTFUWFt5p7tK3lOZkEDCDGFuFQKOjq3U5SQTJN1FLt75hLtLkcmWult7yBWpvyL63j56NfUmTu4POIqwnuPkOI8g2jx4dBqUeyP5IwYSlP0TJJaT6M0bUEM8dPp6IfJE06ySYnMLfBdl4mceBUZqiaSVRkcqAQJ+WxutnFGgBFRPjISJpCbqMNmq0Et7UUghneHXUGivYRdIRdxw5bXub69mXuB0NAE9LoM2lSj+N22tWhlm/lw1GUkrruXhPTxCOPvgfJdED0gEHb+o8EF8FH1YT5NOA+vxkFZbwtze05xqd9ESVI8D5rjuDp9FucPvApN6Xoku57HaW5Bih+5QgtzVxK/80Ue+u5m0AUiFAAiWjZyOmYYf+w+gU2XyiSnCZwmOL0W5fWb6C6rwOaKo7emjLC6j3lryK24EyOJKTOiO7UNpPdgURiYZvKhU6j5ds5iHB89xnJPOSdUURzURVIqeJmWNg7iBsL2Z2H/a6ANh4VHofk4LnMJyvPG0npiN5sSJ1PpdFGpTQbg4qyRNFq6eHD3B0i3PsHoEjOt33cTfVEB9oRWpmvy+H7lNcjcFhqu3cxluz9hYrLII1WfsPPIZ+xMH0wrRo63VqCQyIiu/B4OvQozXgKFhg9LttHjspIVEsOKAaMYv2ctkoaTgRBr2c+TPJf2G832+kDJsI9Kd3CkvZLssATUcgVpITF/ce/JJVJuLzq/b3ntytsCjwwCCokMp8/D4dZKPjq7Hb1czezMYXxQsq1P/Cw/KoUx8Xmsq9xPg7mDk80HsZhP8sixk6jlgTZe0YcAhKsMvDX5tnPO7/J6qOxtQUDgJymY5cc38mXlPu4pnsOj+1ZR2dOM0+cBYGJSARW9LWyqPcqczOGBa5DKUMsUhCi1fFa2iyf3fYZX9BGi0DIyLod7Bs3mREctU1KKEBH5rvYYU79YTK/Lhv1HgbqNNYe5JX8ab026jVHxuQCsKt0eGEsECd/VHWNczQBm/3jOIEGCBAkSJMh/B0GDPEiQXxmfz4HNVoVOl4VEosDv9wIioujF53PS3b0HrTYDjSb53B21Uecut5+GrnJ0mgiSUq9GJgsBiRTSJwe2N+yD+t3g6AZVKGRMwe8y4YvupFDYwB8SzuemnR+R6DYjx0Jp+EUoI3JQlm4BjQt/017Cw+rplU9AKu/G68miW5OBx23lbPXXVJvGkhiuoijdyMelO3B6fcyJO59TjnEYM4YSEhGC3uXFNcpFTZgPld+E2m/BrNHi8hjocWWSEq1FqFbiQIUHBb2makTXUURJMzlxg2npamdOQiR1IaNoSb2OGJufCMDhaMaobKDOHIfu0HNImnYQMfwhQpU6pJlDIXskiYMX8KrKwC2bX6eytwWFRIa9p5bv7E5G1B8mXKmHG34AwJI8CtvXd1AmNzLG2cJJmYFGcxtOiZxoQWSuvZFanRSvXo5druC5Q2uYd9UrKMLjea36IK9KY+kvWLkr1ErxmmtQ1f2YZ7z9ObhlN9+nTadMr2da1C6kMi97oy9l0pBP4dViaDmGYGknM9qE7eyb6Ixt7Mx4mpsrTiO0C8yPG8H9kkhkJz+jq3ACXl8kXo8f/66lNL61i5LLcjkYEsmVcRnM7D81cF6VAab+AdLGsaT+LKaNz/LY1PtwZoxE3XKafQUX0r/gFt5y2/ng4GdMThvKxfnTWP/DS0h8Ztb75KhtZhIAZ28d3kWr8ax/jnp1NBG6SHpFgW6nlXpzO/6T7zDB3olCmk6tRs9+i58wlY70o+8EJoQG3wAJxQyMTKRfaDyZoXGcVkXz2QUPIJVIUMrknO1uRCdXkaCPAOD3wy9jdEMe4xIHsKPxFBU9LUxf+zgPDJ7LNf0DuelH26pQyRTkhidytruRD0u2cVm/0eRFJNFi7aGfMZ79LWXcmpFPslaBUaklRhNKVW8r8bownhx5BV0OC+MSBzBj3eO02018XX2QTFkd46MNjI82ctIaEGGTIOBHpNNp5vatb/LDJU/T47TyyO6P2NoQUMJXS3/2PNeY26gxt/GlcR+nO+v6tjt8brY1nMIn+nlo9wfkhCVgdju4d+d73F08i0v7jWbG2sf7vPEmt42DrRV8WbmfB4cGBPLcPi8rz2yh2db9F2OLWqboi0oo72nii4p9CAgIQJYxjs/KdjE+KR+jUvsPj1dBggQJEiRIkH8vgvhv0H83m82EhIRgMpkwGAz/6tMHCfKb0tHxAybTcUJDhxIePhJR9ON2d+HzubHbq+jtPYxKFY9Wm4HPZyM8fHRfSO85eBzQdjLg4ZVroOJb/I2HcOVfizo8EfYtA1tboG2/mXhih+Jyu6hr+BSpRKCfXYLQUYrfkIDN24Ev6WK2NUYQ1nOY7JrXkRk99AyZhlIZTfjGlzBpBiE9by4SVQKNbUeoMU9Ar2ikf1wbJT2FmExSRuaEEqZTIPrNmEyn6O09iDFsGi5XG3brMWrN4wjXmumwhmP3RlKsqiBJZ6W0RkZnuEis4RQOs5pm/2hiNTKqzKEY5HZEtxebqGSIrpZaiZxI1T70+nw6HOmovOuQOe2kxFxGgzKE5cc3MjkyjTBlBnnJMXxdtZ9VpTu4Z9CF7KiuYUXF1wyUCYzLn8mNBVM53VnH9ZuWITp7+bh1M6leK41SDXKJlGaJkpj+s0gYeRuulVNpHjadsNpTvC7NYsDg6xh99i3uqO/hoDKSNKmb2xNEJFWNTG07AV4nDVI1zw95kDB9BLvqD3NHfChf95hpMEvYMuNWvqg9QZpUoCh/JrSfpXPvQ5hyhlHuSuXuw1tBEAiRSxkWX8ALccn80HuS+BCI37+JsNpDOOLmc1hdwO3iGSaEx/NQzvns9FpYW7mPp1NySajfSWFzJx5Byg69j7DuMuTNx+mZ+RrTz55ALpXSbjcxIi6H9xKSYPXVHIkexOWqLECk0NLBc6Z9JF/8Dt0po/ndtneINDfgjcolTK1nUfGFLPrkdiSWViZkD2LcwEs5bnFxx9Y3mRCVzNK4JPwZU7B7qujs3oVDWcjFW1YTowll+6V/AKDF2s3ENb9Hr1Czf/6Lfbe32+dlR+NphsX24/Oy3bxweC0qqZzdlz2H0+dhzGcPoJDIeGfyHVz57UuIwPjEAfQ4rTRYOgOGeW8lS4uSkMkMpKQswO3zMvyTe/H4vey69FnsHheCIDDrq6dxeFx4/F4ilDJGRegwCTE8N/ZG9jSVUBSVxn073+dAaxkZIbHcWDCFj0t3cryjGgCZAF4xYLirZIo+r/VLY6/ny8r97Gw6A4BGpiQ7LIEwlY42Wy/hagO9TivHO2uYkToItUxBXkQiUlc9x7t7Cdcn8c6p78kwxpCoj6TZ1k2KIYpNtUeRIhCuDsHktqKVqXhs+GVMSilCIkh48+Qmlh75CghEEGjkKnw+L1aviwvTh/HsmKt/k7ENgr/fQYIECfKfREpKCnfddRd33XXXX22zePFivvzyS44fP/4v6xfAuHHjKCwsZNmyZf/S8/6jbN++nfHjx9PT04PRaGTlypXcdddd9Pb2/sv7EvSQBwnyK6PTZeJ2d6PVBkopCYKEtrZvcbs7AVAoIlGpEujs2omAiMfTg8PRRGLifLxeKz09hwgPH4VSGQkJQ/uO67Z0ofA5KKlqozg8EQZcBjXboO0kndYS2spLaXRMxuGdjlYpJTu0BLezg86YMOxuFxHWwxSFDuEYgzgY/ioaeTcpKjVdrjjizY/hU5XS5jiJ0t+OLmQyuXozgnM/giSXcJUes8kBTYcRrGeoM1oD4mJARV07Gfpa7IgIiERFDiWx+3M2lh2mJGIMp6KG4VdKMHhLEUVwdSmw6yNJqXkDiUmCXqelXDMciSoKsXYvzsQxoAKpPJSciBhaW5NRGsKo88ez9uwW1lbup0iWjUXqJNzg4sKMYczOHI7d5eNYuYshzjZOKsI4evQrup0WVpb8AKJIot9DhteCXZCjlKvZEDucK2c8jkKlw+/zIR90A47KLYRUH2aYtp1b7KARJbzSe5KpiniGK0R2NUVyQU8tXPw+7HiWp4hhR/NZRsbl8MP4Bbx3YCMnOttQCH5u+HghuzTxxGnD+CF/JoSl4QtPRpTKGGswsKd5PSa5hlrk7InPY48mlrv2riNNhI31h0Adhrr5Y8JGJeFv9NPTWsWu8Ej8dHCqvYITZ94n2WfiXVGOTSIjWkzm6ajRyBwCifIozG47GomEEXHZnJeUzxZzPYMEBWmdp/ljdjYPmp2c0YXj0BVDfDE6uZpBFeuZZi5juv0CQpRaHhl2Kf2zCqk+uZWpu1+h+8AKhoWnoFT2Ry1IufZbJ++6MxFHzYeUVOL14czOGMae5lI+Lt3BwdZyzC47eWFJdLrMfFN1kAvSh+D2u3iv+h0ONjWxqzGPx4bP47vao/S4rLx+/FtuKpjKpOQiVBIZzxxc0xcq3mrrobS7EYArc8ZjUExG7S3FLzXi9ftQSGWsm/kQXr+PbqeVmV8+SYYxlqtyx/P+ma243V7GJg3B4/fxQOEM9Ao1o+JzkQgS4n6s9z05pYhnD66h22lFJZUzM1ZLhFLO1i6BcUkD2dtUSpWplYlJhUxIKiBMpWNPcyk+0Y/d66LB0sHHM+6hpKuBOV//AQmByTYJAmsq9qIWs7k01odBdLLDYmLx8HksO/IVFb0tCIDT6+aCtMF8U32I3IhEXhx7HaVdDdy3cyWvnfiWoTFZHGuv6hsXHh8xn5FxuUxbuxiJIDA8Lvs3HN3+b3LNNdfw/vvvc9NNN/HGG2+cs+3WW29l+fLlXH311axcufLf08F/ktraWlJTUzl27BiFhYX/7u4ECfJ/gl90nPwJ/64x4tChQ2i1P0dFCYLAunXruPDCC/vW3XPPPdxxxx3/8r79PVauXMm1117bt6zVaunXrx8PP/wwc+bM+Rt7gtvtZtmyZaxatYqKigo0Gg39+vVjwYIFXHHFFcjlf6mH9J9M0CAPEuRXRq1OJD4+8S/W+f1eBEFAq02np2c/Pr+SVttAMlQN+P0uXG4XZY3dqOhAqaxAqYyktXU9fr+L2NgLEfMu5sDZ4WiMP4a262JgwDyI6k/YqY8JFQSc6jScOh9hWg+uuIl0K3qw26pQ+1QYG8+iphZTyjw04nrcfgOlzefh8bswj/6G6AglGnUlYcYMtNpIKls0nOqaS7rUR2pEC15vNCH1O7AIKlqE4cRH99JsKSDNc4iI2jK8UecRHZZKjFHJ65h4HQ+DPV3MEWWgEOj252HqzKI430imxozCcQH9D3zA6dgp2F1RZFh386gAe45/yC05M0nsTCBWu5NBhjBaT33Lbd2b6R9ZzN2FEyjU7cUnKjhZM5ejFV4K44/hFU3YJdFcEzGeT0xHOKU0sr76EB+2bkbr9xLtswMCioveYsbxXRTZGrjU0kztvnXc29LGfFMJGw0ZDA3J45QqmgiVgU6nmbbkWcwve4s6SSJXhUYi2ttoWn0d30xeSsbZbznjcnCjXgvvTeXLsFHYFUZmm8sY7WgmKnUU/dN+nFTxuYk6uo1wVycl094gdN6npH10PmmiyHkNm7CPuo55WeMwODx87m1mTvMOZECeRs832QNR7l/JUVcJv69bh0wqZ6LOAOGFDCn5EpQhcP4yYtrqWW61MbKjjlt7TnCD6QyKAX9kcf1RLtn3JFJEXCiYWHQRww69R0vxArKyxgGgAC4ZPh/j5of5Q4SX9KG34hf9rKtv4rHeMvwIRLrNKHtrOeAuRV7n4UbpE/iQYujsxjD+BaRSFUVRFtZV7ufdU9/T9GPY9R1SB96uSj5SGxjXHEeTvwIh2c6AWD39VXlIJRI+v+B+Ll3/PO+d2UxeRCIvj7+Bvc2lXPfdKxiVWnyinwlJBWSFxhOtCSFMpWfFmS18X3sMj9/L9NQqItR6rB4HYSo9k5KK8Il+TC47OxpOY3Y7yAtP4pq8Cbx+YiPT1y7mrUm3s2jHu6ikcpZPuI0QpYZLs0djUGp46+Qmup1W9nU7abD3MjwmnbdObuqbHMgMjWVfy1mqTW34RD8ASqmMT2bcB0CGMZAP7/9xD7/oZ3R8HtGGFHZ3HKHTqwUEHtv3MfOyxzAmoT+x2lA+ObuTz8p2YVRqMcjVdNrNXP3tUgC8fi+ry3fj8nlJNURTY24L1HCXSJAIAukhMczKGEplbwt+0U9WaPyvPLr9a/CJIvt7rbS7vUQpZAwz6pD+nZfh/y2JiYl8+umnLF26FLU6kMrgdDr55JNPSEpK+k3PHSRIkP8ZflGkzeHG4fOhlkqJViuQ/EZjRUtLS9//n332GY8++ihlZWV9634aN37C4/H8S4zCyMi/X1lDp9Oh0+l+8778TzAYDH2fo8ViYcWKFVxyySWcOXOGfv36/eI+brebKVOmcOLECZ588klGjhyJwWBg//79vPjiixQVFf3XTUZK/t0dCBLk/xp+v5ve3mP09h7lp4wQt7sLr9dCTMwFhIYORq/PRa4eRGZSEXFxs0lJWUBTr476nmhMvsmEhhYjij5sthrs9gY8XhdKpZKhBelkxmrw+v4k00QbiUOjRiqKxAhlRKpPIRdL2HW6kZCQIvT6HKJT59Gpy6dOnYNO2IogCCilZuJ1hzGqTKjDYynp1FDZPRCtNhUAo1aOTiVDyzba2zdgsZaySz2bU86JdPjSqGhOZ6Suktj+oxHih6Kr2ED0hstpPf44/WQy+ilERuuUSIRAjqtUIuATFNR22ehoW02TZRf+GS+gSxqARqvlNYmdPZ31qP0eersrAfD6Pdx+chcPdNupdPVQ56zjhoJZSOWRuP1R+L1uvH5w2mvwutpY3/Q1T/rbef6yt0kNiabTaaEIF7meHnQSKU8nTMV2+kv22I/zTstmdF9czxm3nwJnO5faqnm6fTc6v5sX+w3hh0ueYrO0gzllb3Mq9Tqs019EHHYbHiRUyEPYUL6XezMGsdtdytCMkZB3ITMcjWS4e3jAdJKxfgtPT1nEvOyxUHcAnktGEH00xo/j0sPrmb/rY3ZP3EBH1BB8cflo5EoeHHoxa9tLeFQex7rwAr7vNxfX979HVbYeIS+dfvHHmByhJVmlC9SVH3AJjLgT6/x3sOu0jE/Mx+pxcqS9kksLZiAXBFAZSYpMp0xh5JAuCW75nipO4p58K1mJBbB7Gb7uSrqbNhGSVIwkNJXZR9dQ0LAb3DaGmWsYZW9EL3qoMCTju3kvigFzEXLO59X5A5GNuxepsxdp80kA5maN4KLM4TTZulFJ5cSrDcyr3cCttgqeGHY5Hd9W8tbxg9SdbWGYz8ik5EIARn16P6c6akkxRDEiLgeANEMMI2KzeWz4PP4w6iosHicLBkzmrVPfc/WmpVg9Tnx+HyCwq+k075f8wBcV+3jn1GYcPhd+UcTl8/Dg0LnMSB3Ema563juzBaVUgUQiQSGVoZDKaHeYeHDP+yToIpj79TN8VbmfbqcVgBB1NBkhMUxLHUqMJhSA/uFJLDnyJbdvfQOvz9v3KKplSg62luP1+/j47E6mpBQBoJTK2VB7hF1NZ4g3xLCkvINQYwFTUorIC0/igrQhjE8cQHZYAj/UB3LWLW47X1cfpM7chkGpoTg6g4lJBYSqdLww5lpuLphGmErP4r0f8/rxjTw3+ho+Pf8+epxW5n79DHO/eRar2/HrD3C/MRs6ehm0r4SLjldxS0kdFx2vYtC+EjZ09P6m5x04cCBJSUmsXbu2b93atWtJTEykqKiob53L5WLhwoVERUWhUqkYNWoUhw4d6tu+fft2BEFg69atDBo0CI1Gw4gRI855cQdYvnw56enpKBQK+vXrx4cffnjO9t7eXm688Uaio6NRqVT079+f9evXY7PZMBgMrFmz5pz233zzDVqtFovFQmpqYAwvKipCEATGjRvX127FihXk5OSgUqnIzs7m9ddf79vmdru5/fbbiY2NRaVSkZKSwjPPPPM//1CDBPkNqbU6WF3bxqamLna09rKpqYvVtW3UWn+bcS8mJqbvLyQkBEEQ+padTidGo5HPP/+ccePGoVKp+Oijj+jq6mLevHkkJCSg0WgYMGAAn3zyyTnHHTduHAsXLuS+++4jLCyMmJgYFi9efE6bxYsXk5SUhFKpJC4ujoULF/ZtS0lJ6QsJT0lJAWD27NkIgtC3vHjx4nMMVL/fzxNPPEFCQgJKpZLCwkI2bdrUt722thZBEFi7di3jx49Ho9FQUFDAvn37+tr8I9f2j/Cnn2NmZiZPPfUUEomEkydP/tV9li1bxs6dO9m6dSu33XYbhYWFpKWlMX/+fA4cOEBmZiYQqJry/PPPk5aWhlqtpqCg4C/Gzr/FiRMnGD9+PHq9HoPBQHFxMYcPH/6nr/EfIeghDxLkV8Lt7qGlZS0+nwO/3w2AXB6BIIg4HA2ASHv7d8TFXURExFiipT/PpkokchLCfVgdXhLDFTQ1rcbjsSAIMro94zl9xMLwbCkapZQfTnZh0MgYH90KVd/jt/fQGFaM3tiILGo8jQ12JIILmUzPiXoJKVFjkMrVRPSfiP7rBXQ7I3BnXoAoCOipIkTVQaJ8GPLwRKLCNIESbIJAhEHBpMIImku7scshVV+HVq+iK6Kdzu5IvEjY1hqNwi7wdUcvIyJuxB8fTp7nPfo1e/iq4hNa9SJHjKNwizpGZodR22FBIoJGk4lUKqWxy8Oxagtp0Wo87S6kEglbTIcJbf4K701TMWmHsPvYt8glMpZPuBEBAYfPR1rKFbx2fAOV1o2MIII7mtoYl5CB1d/I5f0Go1T6MSg0LIhOoUl/LT1tB3hVGckLzZsI8Xvgx3rw5tgiPHkXEdZwDIAEn51JKgPa8x4MfDEqAx51KFFDh2Pb/Qie7k4UYWkIdjuveurAOAGcJjyVW9kUGs/EQRLmVlYhj8gElRGkgSFWXH01gt+LaG4lwtRMcdRYjNoMOqQZiCMfpLh6BZqzG7HVn2VIyBBq7HVsDg9jZ1c3t4bkcVPhfLa07ybT48bjgytVArLmo8zbt5our5cVXQfZnDqKDR1yiqPSkUqkqEffgjDufpBImO20cl3DArLDEojc8zZGRxX+8/rDwbdh29N4m/bQXTwcd/WnxHRUgOjH21VCz54DPOI4wW5dMu0KHftl4TymDkU/9Cb4/EqUH0z7+QEo+xYShyCxtDE7YzinO+u5c+AFnJeYDyXDQRtJv4gE9kxpZGN1LaHdOoZmDMTucbH8xLd0OswA1JrbefbgGh4YMpcvKveyt+UsUVojpzpqqTK1MjQmk2kpxcTpwrhz4EysHgfTv3gck9vGZf1GE6UOodbcTqTawC2SVOLsUh7a+i5vn/87dAo187LHkB2WwOLh81DK5Kw+/wEu+PJJ/KKfj0q30eEwkxkaR3ZoPD7RT4uthy6nmdNd9bTYexgcncHw2BwKo9KI1hg501UPQL/QeFrtPTy0+wMcHhfPHlxDekgs87PH0j8imZ98NnqFhkuzRnNpv1HoFGrG/VjqzeJ20O20cEvBdN4v+YE6czvF0Rm02nvpddmQS6WUdDfSYushQR9OYVQaR9ur+KxsFx+f3cHHZ3eQaoimx2VlSEwWUokE9S9UTPhPZkNHLwtO1/LnwjatLg8LTtfyTv8UZkQaf7PzX3vttaxYsYLLL78cgPfee4/rrruO7du397W57777+OKLL3j//fdJTk7m+eefZ8qUKVRWVhIWFtbX7uGHH2bJkiVERkZy8803c91117FnT0AMct26ddx5550sW7aMiRMnsn79eq699loSEhIYP348fr+fadOmYbFY+Oijj0hPT6ekpASpVIpWq+Wyyy5jxYoVzJ07t+98Py3r9XoOHjzIkCFD2LJlC3l5eSgUAUHCt99+m8cee4xXX32VoqIijh07xg033IBWq+Xqq6/mlVde4euvv+bzzz8nKSmJhoYGGhoafrPPO0iQ/ym1VgfbWnr+Yr3d62dbSw/jYyFFp/6FPX9b7r//fpYsWcKKFStQKpU4nU6Ki4u5//77MRgMbNiwgSuvvJK0tDSGDv05JfH9999n0aJFHDhwgH379nHNNdcwcuRIJk2axJo1a1i6dCmffvopeXl5tLa2cuLEiV88/6FDh4iKimLFihVMnToVqVT6i+1efvlllixZwptvvklRURHvvfceM2fO5MyZM33GLATGsRdffJHMzEwefvhh5s2bR2VlJTKZ7B++tn8Gn8/HBx98AAQmSf8aq1atYuLEiedMlv6EXC7vi0x45JFHWLt2LcuXLyczM5OdO3dyxRVXEBkZydixY/9ufy6//HKKiopYvnw5UqmU48eP/2ZRD0GDPEiQXwmv14LHY+KnwBO1OgW7vRqT6WhfG7uljdaGHTi8Z4iKmorBkNu3TauSUpwRQmvrRlyu9p+P6/MhAj6/iEwiEKs9SqiyAme7EZWtHQngt4AnZDKi/SADEuKRqkay40wgXNhia+JsPXhtUsZX7iekJ5bvtU+iUUrJi/IgdTuRl60hJySLvR2DaPT3kl4wlHB94CUuVFeA1VqBXJ1CROXnaDQ6xKgeEJMo607HZ3aws+EMPqOBaUIMTdrz8YQ7iNbkI5riSM/8ntCoKRjUagy+jxB7NVjdF5GVG8aZegsAXRYPz466Gj8iYV/eBB4rcoWKCG0Un55/H68cXsejO9+lw+MmXKVnz7zn+aBkGyaXjbj+k6ht6MLszeLQhGshModycxt760+wU5DwsejFpU6jyNlGqN9DmTwE2YylHHdYefjsfuJObqI5JBd3/mXcfeh5YjuOQNNROkLTmWRTIouezubwLAxWEwp7D9h7GBuWBh4THHwLLC1Ydr7AvdHTmJMQyu+HXAFfLASFBvx+kEiwO6LRiC209p5H7LUX85G1HZdUR32snJj6U2hOfA09HYTW72Nq/os4QwrwOj6j2WCkJfVa1qvjeaTRjaaxBhsSNBnDuHDuSpqPfI8FL+6UsRxtNXGqx0SSx0K9XE9r80mifApUcf0IlcpYJ+lghRWSj61Chogo+wTUoZA5BWnOHPTtxwgxOyFxCNTtwRwTj0njwYeX37cq6XJ7WE0leoUajq+CntrADSpRwPlL8OfOYvtX93HesTcZNPYBvpr1MLwxGpy9cOs+UOrhy9vILj9Klied8ji4f9dKTneN58OSbUgQSNRHoFOo+arqAHkRSczNGonF7SDVEE2jpQOFRcbOxjMsHb8ACCixpxlj+OyC+zC7HdSZ2nj6wGp6XFZstjIulMSgQkaGOpzK3mYeHzG/77n6qRRbiFLDlTnjiFSHsHh/YHY/wxiLMjyRzu5DtMtE5BED+KrqAACdDguvHP+GiUmFPDLsUip7WzC7HVyaNYrv646hkimYkTaIit5mhsb2Y1pqMQBNli6Wn9jIiY5aKnqbKYpOY2JSAZdvXILF4yBEoeV0Vx1fXPAgMdpQ3jy5iQcGX0SqMYY2Wy/jk/LRy9VY3XY6nRbu2vY2CwZM5rOyXQAMj82mw2HCL/p5ZvRVhKv/uwTXfKLIIxVNf2GMA4iAAPy+oompESG/Wfj6lVdeyYMPPtjnHdqzZw+ffvppn0Fus9lYvnw5K1euZNq0wGTU22+/zebNm3n33Xe59957+4719NNP973wPfDAA8yYMQOn04lKpeLFF1/kmmuu4dZbbwVg0aJFfaGW48ePZ8uWLRw8eJDS0lKysrIASEtL6zv2ggULGDFiBM3NzcTFxdHZ2cn69evZvHkz8HMIa3h4ODExP5cSfPLJJ1myZElfbmZqaiolJSW8+eabXH311dTX15OZmcmoUaMQBIHk5D+rBBIkyH8AflHkQIfpb7Y52GEiSav6zcLX/xp33XXXX+Q+33PPPX3/33HHHWzatInVq1efY7Tm5+fz2GOPAZCZmcmrr77K1q1bmTRpEvX19cTExDBx4kTkcjlJSUkMGTLkF8//07NvNBrPefb/nBdffJH777+fyy67DIDnnnuObdu2sWzZMl577bVz+j5jxgwAHn/8cfLy8qisrCQ7O5v4+Ph/6Nr+HiaTqS+c3uFwIJfLeeutt0hPT/+r+1RUVJwT+fNL2Gw2XnrpJX744QeGDw+UA01LS2P37t28+eab/5BBXl9fz7333kt2dkCb5U8nK35tggZ5kCC/EhpNEhER4/B67ajV8Wi1qTQ1BcIf1eoklMpYqr4rpctdRfhQ6OrajcvVRmTk+HOOo1LFYrWeRavNJDR0MEkSFY3N3yP3RaBWnkdShB+r1YsrbhCSkFzK7DGoNVpial6mIc6Ax2dDrxoBiCCCzROO4BERJRIqCu7FmKYlBCUGtQyv14zDZ8IdmYnTUEBvayRuiRJL3WlaOg5jiPUii5zPmaZsdC4pcUkj6XWZkNGM1eMD0rB5HNycdBNuwc6EIemUVuxEHlJK15QL8Z6NJ843GEN4Oh6PBT8SnBo1Skctja2txIVlUtfuwCxtYczny7kgfQgLCxYRWzkdYeO9MP9T+kckc6LpNCZBhlyQkqXOoaKrjbcn3c4PDScRRBgUncGXlfuYu/txBg68jKwpT3NtwTTeOvU9ciSoFXJuHjGTpXXD+LKjid+HpvPHss9QSeWMSxxAh8PEFUMuZp+3h4GmanSR2YTLVbwyMJ1QuR/JpkcJD+8PjsPgMkN3QH3bPulpNIDUaeXxODVFqVEICWPhtv0gUwWMcY8LZ/F0tAePExOyFcc3e5EIUp4f8SAHDvyB10ZdhEJ8AFnVbpyxGQw1v4++pJx3xj5DlN3KuprDrKs5zK22ShxeN99GD6HLaUPofzVffXUHHp+HyPxnWdywjukOOy2aGGxFFxKy6mKmR44j2Wvlo6Gz4MgKckNzeSLpfGZFJVJ8OBCq6hfk2DtaiL59C8iU+Gp30mTbh1OpQ29I4quQODRNu5HIpJS2GshZfS3U7cGffxk2XQz6wss4Jaj5+NBXmBpKGAdIlPpApIWjB+xdcPxTGLIASr4izGMnJCwfAK1MyaWpg1FY2yhIH8XklCKe3v8ZjZZOjEot0RojDwyZy9XfLuVwW0DIbGPNYcYmDkCCwE1bXmNkXA7vTlnImyc3sezIV4gEpsSmRBvQxnlR6Mazb/9KNm95nQeHXMzVeef1PWvdTguvH9/IR6XbKY5K59aC6WjkSq7KPY+qjmPIjbXYvH7S0q5l2ZGv+KxsF1p5wOvcYe8NPPcyJYuHz2NNxR421Bzm6tzz2N9SxtyskfSPSEYUReZ8/Qeard2Y3HZGxOUwJaWI8xLzueDLp6i3dAAwIjacSHUIOrmK85LyOS8pv6+fYxLyeGT3h1SZWimITKHF2kOzrZvq3lYeGnIxSpmcS/uNxu3z4vX70Mj/uzzjAPt7rbS4PH91uwg0uzzs77UyMlT/m/QhIiKCGTNm8P777yOKIjNmzCAiIqJve1VVFR6Ph5EjR/atk8vlDBkyhNLS0nOOlZ//8/cXGxsLQHt7O0lJSZSWlnLjjTee037kyJG8/PLLABw/fpyEhIQ+Y/zPGTJkCHl5eXzwwQc88MADfPjhhyQlJTFmzJi/em0dHR00NDRw/fXXc8MNN/St93q9hISEAAFxu0mTJtGvXz+mTp3K+eefz+TJk//mZxYkyL+aNocbu9f/N9vYvH7aHG5iNf/asXDQoEHnLPt8Pp599lk+++wzmpqacLlcuFyuc0TY4NzxAgJjRnt7wDFz8cUXs2zZMtLS0pg6dSrTp0/nggsuQCb7n5lwZrOZ5ubmc8YxCIxBf+55/2vjWHZ29j98bX8PvV7P0aMBx5XdbmfLli3cdNNNhIeHc8EFF/ziPqIo/l2RvZKSEpxOJ5MmTTpnvdvt/kXP+i+xaNEiFixYwIcffsjEiRO5+OKL/+ZEwf+GoEEeJMivhMl0ms7O7QA4HFFotamo1fE4HLW43d1ERIxBG9aGy2YiNn4S7R3f4HQ2n3MMt7sbrzeQuyqVKlGpYnC5OvB7G7Hb7QBER0+ltreQU+Uy4sLiaO5xkSVxoPSJhLRocGbNIlQrRyNx4/DJiKeRtNQkqs1q4gvuwqCREQscKO+lxx5OqEaGtP/FhEjVhPY2YXJqqHb0YFLPItZzhDylmYwYI2E6OSb1FA6cakfrbMfhi8CPgFamxe61k2aIA4WW+LhY2rtKUcYMQBFnwKtQASCT6Vhd3w+Ly8qCrB04rSIebxdTBw7jRKcViSDg9wmUNLuJEmTIFBoAfH4/glSOxufh1pQFhGsSWXLgS5adN4srT23G5feSE5aIXCJBKddAeGCwXDRoNtcNmMyLB9cwP6qddlcLFwyax93hKXxZuZ9Wey/TU4t5dHhghvijku2cLNvJyK79dJR9i2PUIhRhXgwyGSGtx8Fhg6nPwqH3cNraWSGN4oTVxxsxAwjZ/zrnR8fRQgImcy12bwweSy/Rhjju2Pwq1518j6FyHTKPlRe1+exRx2KvP0G7V+Sxre8zsuMUN/SeRqkNo+PCh1FHTab8w5uJ83tIihtGl62HrYpIyrQh4LTi7azm1WPreSv+Al6zHiR8w+8IE31MFWS0XPs1r398I26fC6tEQY9ECYYEOH8pQw+/x9CO3czSXk5B+HAu8LVSn345ZuMsBrda6Z+gxBuXz2d7t2CQ13G6zs09g2dTu/cEEbtPsTs/iTk9JWDv4ka7nN2mdmapDtDjtLKz6QxDmlS8X1bINY/eiiCRwLXfwssD4Nt7eNwBgyY8w4z4XG4WNLTt+4RbCqaR8cMj3Ht2A6Rv4KUjX/JhaeAZOtJ8lpnpgVn23w2azbaGk2ytP0l5TxM7Gk6RZIjEoFCTH5mCKIr0OK2IwOXZY8kJTyRBb6QwOhOJRMEVpnF8VLqDZw6u5r3Tm/l0xr14/D7u37WSY+3VDIxK5+aCaYxOyAMCAmxK+2F8IiREjUWvUDMsLptVZ3egkAYmhk501nKsvZobN7+Ky+vmloLpDI/tR4Yxlru2v0OIQsOWi59CI1PSZO3G4/OyoP9kRsbn8MzBNZzoqKXJ2tX37E9OLuT5w+t4cPcHfDT9d+eMCwdayynraUIukaKTq1lYNIpH966ivLeZ1JDovn7/lBP/30i72/v3G/0T7f6nXHfdddx+++0A53iKgD5NkD9/Efyll8M/DWv8aZvf7/+Ldb90jD8Xh/olFixYwKuvvsoDDzzAihUruPbaa//mC+pP53777bf/wnv1U1jrwIEDqamp4dtvv2XLli1ccsklTJw48Z/KuQwS5LfG4fP9qu1+Tf7cGF2yZAlLly5l2bJlDBgwAK1Wy1133YXb7T6n3Z+HQQuC0PfMJiYmUlZWxubNm9myZQu33norL7zwAjt27PhfhU//b8exf/Ta/h4SiYSMjIy+5fz8fL7//nuee+65v2qQZ2Vl/cUk6J/zUz83bNhAfPy5AqdK5T82UbN48WLmz5/Phg0b+Pbbb3nsscf49NNPmT179j+0/z/Df+cvd5Ag/4H4fIHwa0FQoNX2w+u1EhY2FJerA5utHJerg/BCOTZbDy53IyHGEXTa07E4vOhUUpxuP53t3+JytREVNQ29vh8+nxOpVE1M7Dyae6RYHV4QoKU38Ogq5RKiQ+T0ukSOyMbRLEvHWwPentPYfZHo/d2EearR2rwMzhwR6KjXBWVf0W0bidM/jIyUcCQSITARIFfhd3nQq5rwuRWkhieg1yXRVdtNbZsVnWAH9Nh8sYCATAJDskJRysPRqwN9MoQWojXk0NW1E1PvPmAfItcSZgjhi5YNuLxeLkg6Hxl+9L4STrcqqLH52T//RZQSBafqrNTlniWyw8GOnWvpn5tNZEgcNq+T0FgPZS2rGCGpRvHiI4xIPZ9dHjUXWioYO24BZ9pSeK+nh/gjX7GpfA9LJtzMtQMm88TO1znQ1Yn8yHN8OeQC5OpIbpY5mSex9n1/BZEpdAgiUkTKZDqo2snd9fGMNEg4f8AsRmTNwZA8Gjbehwo/6aHRCDIJvrPbICSJM9o8orVDOXL6bRSuUNTNaWgUfjJMPYx0tgJQk3sxaywCbkHKjN5qrraU8XDEcN7R9eMacxlyWzcx+zcg9i7n+a7KQN7xNR/AkRXceaaaMnnAkxWr9NNqaWKk3oslqYDy3hSyT26BvFmEhiYwWiklzufgpY5dfBJRTM3Wp0kV3Yg9dTyjycJjbuEbbTpFSXGoJaW8VFvFisZwds57mjM9Xbxb04FMELgxfyDJhiieueMZTkw9ybr2U1zSEsr7oWm093Qjlen5quoAL42+imR9JF2WPXRHd+J/bQjSOw5DaBJMepJGWw+f1Bxlhy6MGUOv5K5Vi7C4HZjddhriYtmimstH+9bR5LQB0B8X92y7DxJS2auM5MbvX2VkfC7lPU2kh8RQ0tXAd7XHMLsdmFw2+q+8jWv6T2TD7MdINkQy6KO7cfm8XN9/IvcMnsOdA2dyrL2aY+3VtNl7abX3snjvx5T1NJGkjyQ1JJp4XTgAV258icNtlUyKi6fLZeOPkwIvCpOSC9k053GWHf0Kj1hNvC6MRF04+REp7G0+y8vHvmFu5ghGxOWQFhJDtamVN058y9yskZjddmSCBEEAEZHyniZq/0SdXSpIKIhK+/GF5y+NqmvzJpBsiGJoTBahKh0nO2px+wOG6U+h9//tRCn+sdeRf7Td/5SpU6f2vVBOmTLlnG0ZGRkoFAp2797N/PmB9AePx8Phw4f/Zg3gPycnJ4fdu3dz1VVX9a3bu3cvOTkBMcP8/HwaGxspLy//q17yK664gvvuu49XXnmFM2fOcPXVP9ee/yln3PcnBkl0dDTx8fFUV1f35cj/EgaDgUsvvZRLL72UuXPnMnXqVLq7u8/Jjw8S5N+J+q/kRf9P2/2W7Nq1i1mzZnHFFVcAASOxoqKi71n/R1Gr1cycOZOZM2dy2223kZ2dzalTp34xz1oul5/z7P85BoOBuLg4du/efU5Uzd69e/9qKPwv8Wtd2y8hlUpxOP66ON/8+fN56KGHOHbs2F94u71eLy6Xi9zcXJRKJfX19f9QePpfIysri6ysLO6++27mzZvHihUrggZ5kCD/yYSGDkGhiESjSaSzcxe1tW8RGzuLqKgJdHWpkctDCQkJCDiZzWcQRTc1PWFYnHIMGhn1bRWkGZ0oFNFotckIgoT6+vfx+eyIijGcaU6g125lYHoIUSEKPF4/NW0OpAL4EUCeQ5q/BLdXILZpD8mig0YhkzZNDkkJhfh8DqRSNViaoeUYUm0hCCG09LjQshW7vYqh6ZfQ1NFOj8WAwxeDNiySDpMLu9UKXg8Zp3/PyUEvo/CaEXxuLERQ11pJ/+QIHHbzj+dQ0d6+Bb/fCYKA3RNLrELNwdpjJKoEau0ShudO4fNDZbjNcaw6tRalPwRJTwoFySEUpRkQPT4+/vQr8ma0saviNJ+ffy9KmRJT71EK5KCwRiLxunlRaaPG0U7/2t1scrYipMUit0mpsPSypvw9LB0/EL/wMDcPupxj37+CWxTZeHQNxyPyeatqHdKqtbBnCVy3iQHReXgvfp0nv32Cq0JDudgs4vC6KXWHsKWnG1o+J1z1LV/kXIi04QAh4x+kcsdrSLsCs7Rpp99lk1ZGvCKUcJeHKH0H+vdHMi/lKsrTbyZNrCS1ZDULhz3I4VoJw8KiacpOwdngRG+IQ6qeCBXf0hmqxDR0HnF7vkKTOBEMsTD2fsZqU9lVtp9x0VFcEicnO2kCLTtP0eLqxBAxAIZlwZAbUMkUTL5hAz27l/Hdyc3slBoosNRxq7mEdomCQlc79/ccYZeuP+6oXCoUWnq9DowyD4dbK8iPTGVychEHW8v55NR3XLf+OnSCBPWA+dx96hNeM+TiDtHzQcs+vten0iXIKWg7QdnRNXyoz0Qm9uP2+s/pexUquoLT25ZSHBrPzYN/zF0NieZ0Rx2nWs8wMjmO4TGxPL+nkqtzz+PDkm2UoUQh+kD04/S68Yp+ojQh3Fl0AWaPgxWnt6CXq7m+/yRUUjk+RN49vRm3z8vDwy5hQnIhG6oP8c7pzdyQPwURONhagfhjhvJXlfsp62kiQmVgdHwOq87uxOFx8dL4BZR0NyAicrirl26XlXpLD3qlAblESkpIFI8Ov4yRcTlMTiliXeV+biucgVIqZ2fjadZU7EUmkfLEiPksPfIVE5IKcPs86OQqrB4n75f8wKLiCxkSncnBtgquzZvI5ORCBEEgXG3g4qyRzM0cQautB6VUTqgqkFenkMqZmvLzi1eHPZA/qZYqGBLzywbbfxvDjDpilXJaXZ5fzCMXgFilnGHG37Z0j1Qq7fO8/Lkgklar5ZZbbuHee+8lLCyMpKQknn/+eex2O9dff/0/fI57772XSy65hIEDBzJhwgS++eYb1q5dy5YtWwAYO3YsY8aM4aKLLuKll14iIyODs2fPIggCU6dOBSA0NJQ5c+Zw7733MnnyZBISEvqOHxUVhVqtZtOmTSQkJKBSqQgJCWHx4sUsXLgQg8HAtGnTcLlcHD58mJ6eHhYtWsTSpUuJjY2lsLAQiUTC6tWriYmJwWg0/i8/1SBBfj2i1Qo0MsnfDFvXyiREqxX/wl79MhkZGXzxxRfs3buX0NBQXnrpJVpbW/8po3XlypX4fD6GDh2KRqPhww8/RK1W/1WNh5SUFLZu3crIkSNRKpWEhob+RZt7772Xxx57jPT0dAoLC1mxYgXHjx9n1apV/9Jrg4BnvrU14LRwOBxs3ryZ7777jkcfffSv7nPXXXexYcMGJkyYwJNPPsmoUaPQ6/UcPnyY5557jnfffZfCwkLuuece7r77bvx+P6NGjcJsNrN37150Ot05k5i/hMPh4N5772Xu3LmkpqbS2NjIoUOHuOiii/6p6/tHCRrkQYL8SgiCFJ0uA1EUEUUfIEEQ5DidLZjNJ3A6G4mMnEhs7AX09BzE4ewlVogkOUpDj9VLnPYIiGa8XhcWSylqiwWJy4ZPBmppI0nhqfTveA+ryUVSdCpd3omY7U4i9CI6tYaqNujQ5GO0l9AliSHOV4VNlsLg4UNp6zyBpXcrXskgLKYo3KHXkx6qptos5XS9lZSwRAzSWiQSBYJnN6FKD6Gy0zhc17G71AGiglGHr0aSNIxpSV1ITn6AUxHFVvkFhMm+o75BgUziBfygGIndpSEqNIWQkAHI5WHYbJWE+XbyQmES+zrtHKh4l8dLj6KX6bB4reQbouhymrDYtZjbS5EceI7xSfHYZeGk6hR8WLqTG/OnoNEk09keSq81gcTbD6MNTUVbtZOd2/zEjr4bj7+dIbHRTI5MRTj9Bp3WbtrqjjE0MZ9N5/+O7/auYE7xJaR26diYUsOU3l0oeqvA3sWBljJWl+9hvahBiB7OrRkRfFt9mPk5Y2necD+zzWXcFn0eDyYNZZ9dxUK/lCORRXyRXMSg9v00RoSQ1H6cMa310HYa+s8FQUpCXASeoQuRrb8JFwIGezu3eWbTbvgap9RNqFpFlcNKbUcZeqkaq1QesD5cFkifAN//Hg6/x5zL1zBnyDweem06CQeO4x/uIkcZQb8Dq+melIt/1JO02E2sOvQF87LHEDd6EW2dvWQ4LewJy2O7KoaF/YZjrNyM19FMwew/EJo+hsnAdFMbs758iqs2LeXr6YvYUXsElyDBgA+tP5DXu71qPzf6nNwcl07IwPl4Q+LYa/bS67LxWtkxvLpMpKKP6+3V7Ol/OT9lajsOr2BRWzt+BEo76hgdn8uy/mM5b9v7rK8vJUWdTrJGydejLiEzYxyTU4qQWdtRSuZB6hjGiX6S9JHsaDjNhjmP8ta+JQwL17K/y8apzjren3oXGcZY3ji5CY1cwUtHvuSZUVdxXuIA/KJIiDIQQvjahJtZfnwDp7rq2ddcRqI+gnnZY6nqDaSNqH/Mu/5g6t0c76hGI1Ni+DFtoviju7gocwSPDZ9Hs7Wbxfs+4dOyXZzpqifTGEteRDLeH73de5vO0uWwcLyjhpVntlBlasXqcTIgIpkHhszlYGs5xztqSDVEk2iI4LrvX0ErVzE7Yxgrz2ylw25ia/0JjEod2y/9A2XdTdy0+TUuyhrBHUXnAzAhuYDnRl9DuvGvi/b8tyEVBJ7KjGfB6VoEOMco/ylm4MnM+N+8HjkEPEh/jWeffRa/38+VV16JxWJh0KCOGGHNAACyGklEQVRBfPfdd7/40vvXuPDCC3n55Zd54YUXWLhwIampqaxYseIckaIvvviCe+65h3nz5mGz2cjIyODZZ5895zjXX389H3/8Mdddd90562UyGa+88gpPPPEEjz76KKNHj2b79u0sWLAAjUbDCy+8wH333YdWq2XAgAF93n2dTsdzzz1HRUUFUqmUwYMHs3HjRiSSYIXcIP85SASBoZEhv6iy/hNDIkP+5YJuv8Tvf/97ampqmDJlChqNhhtvvJELL7wQk+lvi9L9KUajkWeffZZFixbh8/kYMGAA33zzDeHh4b/YfsmSJSxatIi3336b+Ph4amtr/6LNwoULMZvN/O53v6O9vZ3c3Fy+/vrrf0q07Ne4NgjktP+Un65UKklOTuaJJ57g/vvv/6v7KJVKNm/ezNKlS3nzzTe555570Gg05OTksHDhQvr37w8EhCyjoqJ45plnqK6uxmg0MnDgQB566KG/2y+pVEpXVxdXXXUVbW1tREREMGfOHB5//PF/6vr+UQTxp6SofyFms5mQkBBMJtPf/OELEuS/kc7OPfT2HkAiUZOQcBkymYbOzh24XB24XG2EhQ3Hai0nLGw4EokSk+k44eFjcHt66fjRsyyKHtQ+JXENjVgyR6CJH4dMUNJ6ZilWjRz8IobQYsymk4AXh9dIo3USIfLThKqraLLMwOvy4ZLqmVQYwcGSAyTo99NsHUiPIxO/IGVSQQS9Ni9nGqwUpemJNCgQBAFL91E6On7ALwgYo66lpkNKl8WNw+2nX7yW3DgFvorv2WfPpcOtQSdvxqBoxKiPxuHRUtMViYAfXUwruRHJSKx7sVrLUSii8Yoq/J4GLKKOy3cfRSNX4vV50MkEOt1eXlbMITvyJMl7n8Cr1FB2yVMc6+4lO342oZIYFBoH0z5/GI3Ty5oJd5GUExh0EUX4+BLoqYPrNtEjUfDJ7nepKdnAAhV0DxyL2VzDaLMUTfok6oUkGjvs5BQOJFTs5PW6Ul4/sR65IOH89OHckD+FJEPkz1/qOxOh8RBdM1+lPn4Y39Wd4PbwSHReG5RtghOf4RJE5F4XEm00JA2B8Q9DWBrIlLB7GWx5jGpFGNNjpzItNos/jLkKx5YHWVzfxPfaJF43HUXw2PhQk8Ed8k60ajlpyiRkJV8G+nDJB5A7i7pPryH57LrAOkM8mJvwS2X4JzxG9Ym13CxL4rwBM7iibT8hJ1axzJjPD+oE1resp0Gm55HIkZwXquYOYzz24VfS1bUXuWYUN+z8ENHZy9q6L7Ai8I0iigOqaGY7Gknw2ZkbOY6JMj+vzH8NVl0ENTt5OHw4X2hTyPKaWdaxC5kgoEkdRYSlBa7+BpQ6xJ56rv/6KVS2Vm63V1M5+10u2PkkT5jtHI4ayKPjb2Jw3Q/w7X0w7kEY9wC8lAfmJrj9MP7wNCateRS7x8WGC27n8o1LqLO5Gejp5eKJi5iVPoR9zWfJDkvgsvXPU2fp4L0pC/tqmf8pm2qO8Lsd7+ET/Xww7W6GxGRxrL2aN058y8KiC/jk7A62N55mVvpQ3j29mdHxuQyLzebFw+sAkQeGzGVYXDaXfPMcI+KyidYYGRKTxcj4HFac3sKXlQe4Z9CFfFd3jM11x8859+sTbuG8pHxePbaeV49vwKBQE68Np7SnEblEymPD5rGyZCuLBl7I4/s/IUkfwYfTf8f2hlPcvOV1JiQV8NqEm3/l0eqf57f+/d7Q0csjFU3nCLzFKeU8mRn/m5Y8+29k1apV3HnnnTQ3N/eFqQcJ8v8LtVYHBzpM53jKtTIJQyJD/i0lz4IE+d8Q9JAHCfKrE8jd8fsdOBx1hIQUEhU1ma6u/Xi9NpzOdtzuLhyORnw+JzZbFUplNGp1Emp1LFZrOSpVHEZDIUKEDEPYj+VurG1oEybjsZxEqY7DbDqKVKpDLjeAs51+URX43aWIfpFxyS5OdoeDoxvnoS8JFROocUwm1GgkXahCGZGEQu6n+czrpEsEolTXg6AEWyd6VQrtUjWi6KK2+TgJoVZyEybQ1AOJESoOVVtx+kbQ6Q68MPsJIVy9HaM+hV0VASO2nXIe2PYpBZGpLCnKx+Fy4JcayUqdgc/n4LPyA/g5gl8U+WOmnujICBafbsPo0yCrUuMJS0eWfwl56deTlw4Hy3s52W0hNtqHKJVg1srZTxd6p5XPy3czs/M4sRXfA1D37gxm6osY5zeztPsAJYow/O0RJHU2QFMFnFhDkuglQZAxr+c27ohKYFzdTrIK84hSKcjsNaNW/Jngh6MXAO2ePxAx6yEeqFwPGzeBXAMeO4SmoOyphZQxMOpuGptP8fTxzVyXP5X11YcpUEQxp/9cFB4P4U4/3X4fak046n5zeM77FffGF5O46TMQfYx1dSLxOnAoNTilVegA5rwNubMASL7oDar2FuDe+0fcYTnke2wIDhOePe+QZavj7rz+9M8ZR3LVGgS/iyGinV0SKTIkhOBneEYy0xPDqTt7HG9vKbg7qOgsp8bchsrnwupxoFPpucZSxmh3ByvHPMmj3hZeqjnE0PNfxCW62ZExk0GRuVxbvIDxJRs4ePIrlof05w/2cuTlm0D04Tm7gXcxMDgmk/cufAzvH4spF1R8U3WQKcVzeaRyH6/FD+b7umMUasKRS5Wg/9HjmzkJOs6CLgqA1yfcTLw+Aq1MSZohhmZbLYcVoczyuNhUe5S7tr3NuMQBPDLsUk501DD4xzDu5w99wSdnd7Jy6l0URKYyNbWYKI2RjTWHideG0eO0YlRqSdJH0uOyUmfpoNtpIV4XTpQ6hF1NJexqKuGeQbN58fA6upwWSjrrcfk8eP0+Fv9JGbW7imdxV3HgO5qeNoht9afwij6+qTrE/pazfTnqtxZOx6DQMDI+F4/fy5UbX8LicfBl1X4qe1tYV7WPNnsvE5MLARiXOIAvZz1Mov5nte//y8yINDI1IoT9vVba3V6iFDKGGXX/Es/4fwt2u52amhqeeeYZbrrppqAxHuT/S1J0apK0Ktocbhw+H2qplGi14j/CMx4kyD9L0CAPEuRXJjx8FBKJElH0YjD071vvdDbg81mx2wNCYqGhQwE/anUcdnsD3d17iSSekJZe1NnTwJD980GrtkDNVvQZ09AnXIq/YgNyWQzyyKHodAFV8c7OvfS6IdwpQ3b8fQqR0iWNJszXjELVSrWkmGiNhviUgIjHkYbjDPF04BPFwPHTJ8EfB4JEjnr+EsxOE0ZVPTZbNyEhBWTFJWN2eGnutiCVKAjTmHB5HIQo6gGw206Qn3wRbk8PsZYDZOnVnOqspc6UhqmtClGRSGaKiFSqRioJ5GbeWjidTOs2rF4Pr5sPoIrzY5NUID9ZBabGvstPjlIjAnmxOhaPmM/q8j0MjM3iw5JtvH5iI43GMJ5AwCORIu+tRaEdQKtfQptUg1mqoqCmBF1HDSJCwMiztrMqZiQnTB2oyj8l19mGamAx4MW35w1sLgFtQg60l8DwW+G8RxDXXIfMZkLoqoHyTYGOSeQgVcL4R+Dsehi5EL5eSELbaRQRo1jrdWCs+JYXwotQj7yVYbH9MH16P8c766gufYXUNU+ilmtITB8LYmAiR1J0Ba66nXiShmI4+gnooiE7EKpM42FoOc4XfjWfRZ2HQhHKzJEXMq18P4X1H+FPHskFs5cEvPLzP4fS9VRZRMSqY2yY8yGXZI3mop1PILH08IQnjFM/fM8HY6+hxOLiySHX0XX6A8L9Lo4oUslV6Pg0fBA7Gk5jn/17po5WYTv9ObXyerrlbu4gkivtZu5vqMJjyMYP3Dv7WaK2PQmOHj4t3cYyh0CkOoTtFz+KePcZappKuYRu7q/aQ0RENh+VbAdg2PgbmDDmHhD9uH1epDNe4g8HV6M/s53TtQc53NvGAyOv5LLsMbw27SFqW86yu72a89OHcLC1gn6h8QyP7cfohDxGJ+Th8/v5w4HPOdhSgcPrxuwOiMO0WLvZXHeMj0q3s7/5LJ1OCw6vG5fPw8nOWt6bspAPSn7gdGcdV+aex5Ij61BK5YxPzMfucZFhjOHhPR/RLzSeOZkjaLP3Eq0x/sUYIBEkTEguAGBKysC/2HbVn5Ree3n8DTx78As6HCampRYzK30o5d1NFEam9rXJDkvg/yekgvCblTb7v8Dzzz/P008/zZgxY3jwwQf/3d0JEuTfhkQQ/uWlzYIE+S0IGuRBgvzKCIKEsLBzy8qIog+HowkAjSYThSIEmSyQ2xoSUogo+nC52lF5FChdnj7jrA9NeKCutToMuiqQNB1GrVTQKHSQlHQFCkU4RuMA/H47Op0Rur9F8NpRiC7awkLpkRvBJhAfpuo7ZJQmi/fcaaSrJIyKyaetqwy1TIsNkOrGkp0QitvdhcvVjlqdBIDUX09e+FeotEU4bKcQ8NDjSEQiUaJQxpAUrcHT24qpsoErktNZ2yBHrh1OsqsNnbWjr2yGTCIlQm0gLzyJ8NTbMbd8SvegyUQfPUhDwTC29XqIrjvO6K9uh1mvEm1UEm0M/Ohe3G8UF/cbBcDM2AwaD7ZymaORLaNmo/B4GHPgG35o+grfLQc5dXoQQ4svR9G0H0q+YovTx2MOgWsK8kjPGo9k21v8MayYkbZ6lu8tIVlnZHLBcuJV6UxdPRqlsx3kKj7XZ9GRfxPXnnyL+K+W4Os/G6+5FrnVhKS7BjbdD5Ofhg/ngCjiQWBsv/GMr/yG0J7jbDZkcvf2d/h4+j08POBmzDYPLv9efFFZyHRxUHAZGJNAkEHSEJSAEqB0I1jboGF/IKf8u4fB1MA9MhXXSJRcn3MD71fsJcGgpRCQhKbAyc9g00O0TnmW6+uquDZ6HgtTBzOx5nW82x4l0tgfw/GdKNQ5ZCUMocLt4bXqD/jk5EmmSVScirqRCNsJdog2PnNLcHtN7G8pY0rjTrRbHiM6awikjmB+9lharF24fAG17xv7n0fU4begcjNkn8+Gnk5QRRKuVFJT8wahoUOYljGEWWsfocJiQS8LlPELlYgM3no7NJzBh4TCU4dIDYmlytSCTBDwiiLZXgubao/SaOninsGzSYnNJiU2m5ePfs3yE9/y8NBLuDJ3fN+93WLr5oOSbUiFQO7rlrrj9A9P4rlDX7Cp9iix2lBqzIEaryqpnNTQeO4fPAetXMXy49/i9nu5JHMkYxP602Lt5o4f3qTa1MrUlGIcXjdVva3cu3MFXr+PJ0dezsVZo/D5/Uj/JNf29eMbcfs83DlwZt993+O08uzBNYxPHMDU1GIAzB4H5b2BsSE3LIlxiQMYlzjgHxtsgvx/yeLFi1m8ePG/uxtBggQJEuRXImiQBwnyL0AQpCiVkbhcbcjlGiIixpyzXavNRK/PRyqRQfIkUOgQRRGHowGlMgppbBHE/ljawe/FGpNJDx2AD4/XR6fVSbRRR2nHQLSWKoq9ToSEYYRE5BByfAXhWiXJhsNYm8M50ZlDXpIOQ+sesg0DCI2XU975PbWm8ziUv4wOt4mJZRbyItagVoUSHz+3r59fVx2gWO3H7rOhVobjcHbg8Wvw+11sq9vPW9u3sVXeiaFsI2NHP0NCRhS9HR0MPvIEgteJb/j5+MLSOdvVSKfDTHl3M0NjRtPqUeGwuYi7aAUnao6x0ehiSfPb7GwzsGrza9w/5CLSQn4WsLJ6nLSXbCTty+t5oGAC3f1Hk2zqQRQiECWb0PpcfFyxk8GZ17P8cCmTsoeRMHUU1W9MoTu0iIPl29EmFHH66lfpddl4/uAXOKsOctZuJT+0Gb1dwi6JFpcmmcmhGSw7+BVv16xGI3rZHT+anP7jCP/0TkSpHDQRgbD1ripw9kLOTNr8AppTn3EoOpfJ9nYu7z7JNn0Kh2u+Jks9AYPvA+z+PKQ37oafwuscvSD5cUg2t8C2p2Hi4yBIYdND0PFjzU2VEYlCg0phoCAyhbH2RmaZTtMYN5Ow+FGomw8iuC00V35NlT2cZl0VA0Q5ypPvI/OYkJpNnJpwG9fTg5A0m9/t/JAIhYb+pkp6lLmYw1Kwqw00WLfjFgKRDK2bNtCw+WuicqVQfYph414ifvMj1DWfwq+I5Fh4BuN0jex2ddCiS2d63T5Ins0gn4tFA0aC7wQStxOHo4EZMWpWOB1Mi4umvrUOXVcTuq4SREHC13lX4rd4qDK1kKAL5/6soRze9zbFiUUsbCnjWHs1dw+cxa6z3Th9TmK1YaikcmK0AUGtn+qoGoVeFhePpc4p48PS7XxWtosWazfzcsbi9Hn4XfGFPLp3FXKJlMOtFVSZWmm0dvHe6S0URqVxsLWczyv28Nzoa7h/10qS9JGMiM3m/sFz2Fx7FK/o61Md+67mGE2WLt49vZm3J93OsLhsnF43fzz2DSIQpQlBIki5LHs0B1vL+arqALXm9j6DfFJSIY+PmI/JZWNWxrBfa8gJEiRIkCBBgvyXEDTIgwT5FxEePpq2to0oFJF4vRaam9f+mDeeSGvr15jd8YSGX0BqdKCsj8VSSnv7JnS6LGJizv/5QBIZ6px5OLoP4jIdpbRmHxpZGybLZJxuHTqvAwE/CJJAeLZCj8zWhtPuZJ/mcqRiNwmyNsJbfmC4MgRz2DTqW9Q4faHkGTS0OLqRCD4Q7Xg85+Zi7e4w8WJTNUvHTybNEI799HJUUh91ybn8P/buOlyKK130/7favXv3dndlb9joxt0hQIAQCHF3n3gmmXgyk4lOXIgTgwCB4O7ORre7a7t3/f7onGTmztx75pwzd373zKnP8+RJUr3Kumo1vFVrve/rlT9iD4rYiyfRVVJAv8+AEA7gD1vYPPUgYz1rWbb3G7q9dt4edz8GTxb5ymxkMiXji277ZR9XDZjCVQOmwLjLeKV8G7sayymwJnNP4XhQm0Cu4M7t77G/9Tyfq2NJTCkCwNLTTJyjGQZdzEGXF2t8Ice7L/B2/YccdOby7pTL0Wfm8VBHJTstAyi0piITZFg1RrY3lSMi8ljZpVy240FC3dU8EF3GT/p0rvnpOYpUZnKCLtzGZLqH34QnLpv+MZdj3vc5uLvounoTuw5+hDeujMunP4tq0+PMtFeymxA4WpkdF81RpRxLoJORx6+jRQU9UakIzUcgNh/8bli5DBDgkRZYdydUbYZza0BtQrQ344/JQ63QQM5UmPJbFn77OM1V+/m4ay82yzBOFD1BbNsRyjrPUqkw0y5X8/mse/nu/E5OHd/MMLsf79SnsGmy6QnvxuPtRnX8DTzuMKn+flpFBWkjLkJlyuNY0M7LZyLZxxc5apjbtgp7q4HPY0vZe9FMPvbbEet2kYVIjq8Hr8ZHm2Y817ij8UVHU6cKsWLydWgOvQFd5xAv7ERo+QPizbu5dMBcel1rWHj8c84Keh61juBqhYbJaaUsmf4Ar69+mm6PjVu0MqaF+pl281o63TYm7f+CqWmlBMPQbfcTDIc5bavj5JWvA9DjdTDx64fRKxS8UJLIkdY+ytInsmb6Jbx9dj8qtYmDbRW8MvF61HIFdwyeyyvH1iIIMp4Zczmfn9tJeXc9KpmCBdkjaXf3MS29FLP6Vlac3cb+tgt8X7WfYQl59HkdPDvmCpasf5EDbRdINFgJhEM8vu8LrhowmaUF4zGotDj8Hp46+DUAk1JLmJw2iMfKLmVYQs4v97tcJuPS/HH/8N8biUQikUgk/z1IAblE8k8iCHIslmGYTMX4fB34/T2EQm5sthOAgkBIRyAk4vKG2H2ulxhjNLFKI3K5HperBp0ui2DQQV37NlJiRmIyFRFqPUic4zQ9MWoUKgcjw6sxujsIF12MLHl4JCiPLYKWQ/i0GkRBRKWWY4yz0tdpJKgz0dCVgUGfxKRUC609XmStagakGUiLuRZBUOLxtOB21xMVNZylyQuZnTCF8am5bDy3i6mKAF6xG0P+TOKiCzAoNWjUYYTmbxCR4wlGExLVBJCxRjuLyvpX0CpUlPdVkGPKxWqMJCN6aPeH7G08wfOlwxlduBRQIo/N4zdlsexorWD/sa+5+8drEXKmwvJvyLUkUt3fSvS1GzAqnYTbtmFurIKWs4RmvsbIlGJIGEijq4+smgTGpOTR2rYbq1lBakjPlaXzEeJ+TpZ3YT0r3GcQh44iseptZF0XkAHz1DI6vZ0ssJ2jV6ZGHfZTH1vEQyc2MKm7hLen/QmMJeBzcHP5DmpcIl5tNmUdFeRmjYULPzBGCMCgy1ifPJFtZ3eS3ulE01lJpjWTdGUWfDgNMX82tvzLsACi2oig0sPQa6D9NOGSxXRZ1ZzubOSeDjkfpqYy4uy3tMUU0OruxaLWM/SyT+i09zNz9URk4QCywUtZKs/G6xA4ue4miltOsiRhOk6DgEavI3X0XCzOQXQ3rCSklvOm8jyhEydJDzmhpwLLrmcZJVNB0nzmpSQz9vRBotVezszJ5drAMa5TT4AL6xEiM/JxKQ1sHjCdkpCL+wqS+fhcLbPqt6NZXQFtJ2Hyo/SHw+gR+KZiP2/Un0Hj7uIhZxt5gpzgwGUcb3IyqnA6gXAIm8+FXqFi/tHXEQUBoXQ5H53Zwo6m04iiyKK80Rzz7mJT41HUShmN9i7S/DZc6+4jQBKxKgUpOiVLUq00hr2IrnPcnhPDHScaqOpvJducQEgM8bsDK0kxRGNW6xiekEe2JZHf7P4YOQLtrj6eH3clOqWaiaklXOhtps3Zy7vlGwmEI9NJml09vD/9DuSCjBEJedTZ2jnaUc0zh75Bo1DxwtirqLa1oZOrcYd8xOstAFxeNPGf+bMjkUgkEonk/3FScUmJ5J+kq2srPT27cbsb0GgSSUlZjsFQAMhISlpASd5s8pL0BEJhvP4wLq9IMOjAbj9NW9sanM4Kdtf8iMxXx6G6ddR1aZH1GjB5XVjlQ7CqUmm//XPqX9iBKJMTFgX2X+jjiHwClN1JICuXwuhVjCmQIVMo6LOacemNNHV7qekQsejkqHxdACjkMmQyA3K5hu7uXfT1HaKl4zTd/SJ+h4lQWGRE6ki+ko/lZNylAJTEZJBpTkCjSSIr63bSm6sYvv9eyuK7idIr8Mj6EICpSWXsrm2gQXaCvKTIPPqK3iZ6AkFq2o+x/sB21h1po98VIMEQxYjEPFIVisi8+t5aRFHk4bJL2H3Js2SeWYmpuZrUovtQX/wJ3a7pdD37GLw/if73JnP0/Ca+a/ie24PtpCVNIC2sI6mnibrwCTprP49cmP1vUNRyiOieRoKKX38SJ135FS8OvIy8gJ18uYz+GY9iH7OUMUkFzMocyvOHvuVlRTyOUbczKbWEFH0UV6YVk5U3hfCAefhSRyG3NSJ2nKXa3kVC0EWaTMOXhmweNA7knoZqenLHUlc6jPLqr+mWqWnW/lxqrWA24r3nOVQ4D1/YQXJKGgEE9N010FeH7ew6wqJIWAzTjoLvtjyNkyAKnQVmvMCy1EKWJ2ah6qlBQ4j3dGEOxw1h8vnDXLfpdQR8dCJS5/BQEFuMcebz7Ci+nIPFy3FF56EOevm4fx8TYuS0o+KCyopm8CQuS57Dke7myFt9AH0cvx90C9vdAl5RybYuNxfL/JREp0JCSST3Qd5slpiGMjRpHjtcDmx+N3Mzh+OUqZCJIS5t3sGLjWvJt9dhVutZf/FvWTF+En1Dp+GZ/hDIZPT7XABEayNltp6ftIzC2CT6fE4q+lpoq9rOy64gjyg8aDQJvF7ZwUsX2pCrYjCZByPTl/LYyEvRKdQ8dWAlCfoosswJ3FY6h6sHTOWVY2sAmJhSQrvbxsH2Cna1nP3lXkjQR5FnTeayggm/LMu1JDEmqZCDbRW8W76RP068nmuLpzIsPoch8dlMSR/EVUWTqehrxqD8NXeDRCKRSCQSyZ+T3pBLJP8kUVEj8Xqb0WpTCIV82O2n8HhasVpHo9NFkqa5Al7WNx5kTN4gEg1aenuyAYFQyIUgKElQODna68FgKcFVuY8uVzqKvKFYs4fT39lPwC8joNAgxg2gqfEzTIKPbvdAgr1BFN42jKYMdIKewPEvEWR5OGNHkJMg4PCGCDQcIqdhLZlxg+lgOGsPq0mKChKjiQQTcrGdeKMahSoFuUzgXLMbg244PkGO3R3EpPv150QmUxDVtBpV9znCHT8ysexhJhLNpaUD2V7eS0ivINbiZk/zWb64sIsHS8ZxofpLUrV6nKgQkVHd5qK9z88Lo27Akj8Mx6YOtg+cSmHNa6SlLEPTcBJ2/z4yh7tkMURnI5rSCY7op2N4HH+q7eebc/toxcgVW57ClDCI4gl/wKt9lT5ExLbj0NIJI2+FgrnsVJuR7XqD2WoLHUOuJivoJ2XwJALd12A98RG2+q1kVPl4X7BQO2Q+D+xeAcCprno+nHQzk6pbMLfUEK5YTZNQi62vkcFAsPMsSWxkbcdBlK0iw1IXE0JGTtNxmmbdjsF/Hm1MIuawH4XPDkA4HGBVxQ72bHuN17r3EtRZWDHyQT7ww0vqLeTXbGR52SOMyJ9IzME3uLvvJBXqWKyOVvhkDg80H4mMjjAlQd50Eib/lh0nNuKpO8a+lnO09Y/nkTNdtHlc/Hjxb7lr85u0OMOw7yvU2hJOyCopDvmw99ag97dh8dv49MJmKi0lnG05hT4qFUdiGZklF/PQ8Gvpcnbx/rldHOo+x1GMFM96jcnpv2YX/21qDocCOUzNG0+uOZFzfa2MTFnEvf5mri+YjU2Q87lfQfD4Wm4vnYvgMuMqmYEhfhaiGIRQpDLBgOjUX7b52qQbuNDbzNjkIr712NikT2O/oCHQ18aZkB+jSkuKMY4Pa0/xyblv+OOE6xiRmEeHqw+LSo9WocQT8PPZue10eey0u/o40lFFtMaILyhndOKvVQ5WXtjDya5aXpt4A+6gD51CTU5UIr1eB++Wb0RA4NriqTwwfNFf9PnKvla+q9pPQksUywsn/oN+SSQSiUQikfwrkQJyieSfRKWKQq/PRCZTYrefwW4/A4DbXYfVOgKAL8/v4uVjPzA/u56nyuaiUsVgsQxFLtdgs5WjxsnEtFIUgpGKPUeRIWDKkQEiloRo+GkzarWScNhLMNiNRg5pimMoqpqIEgTqM9yI4WoCjk7SxTq2+VMIa2Jw+8N0JSaSZEpBHpuLz29HJA6310ulo4AUkwjuKuLUlVjjrmH/hT5iTUpc3iDBQAsdHScwpI9HJotkQj/b6KSv+DnyB2zHOPBq9jSfRdd+iswTq1HmPUFCUgpD0mJ5YM/H7Gw6zaiEHEbnXkSUOQeTMROv38eZunoCoUS8/jDIFLQnl9EXcIEoZ+3hL7h4x9N4tTHcYh3F+PJN3JiSS2z4QwJGKw3ZMzB1nyDTZccS9jMqYRbD9n/DoOxm7h5yC5m7n6fp7C6mGAYwUTjI4zd8i6rqAIc1cfSi4NXWTu78+FIKAnbGzX0BbLWorJlojn6NEPSRo1ZzT+kcPjy1gRMd1Rz/5m6CgYH4/SpSvr4WS/F4spwt1ClMBMtu4OIELZrN53DLjCwI9WF2dXC1q5YY53L82z4kO2MqnlsOYDHE0uzoYXvltyTIexmsEAnKlCiCQVLPf8dPqnyuVcdQ4qvl8YrPYfgCGHEDlb2NHLL1kefrQmg+QlAbi0wMIAv6qFRZ+bB8G78dtZQhlWtJ6a8hs76AsuQSKnsaSTz2IReboziiN9DTXM4YTxtC6XKMAS/GA6th8OV0B2PI69MyzbsfAfg6IOdrVTbJLc08enA0ilCAaxe+jd91jolxemICR2luriI5eTFC5WbGbbyLcbkzuNrVz8G2CtKMsYQFgQ9NhVx96B3M/Q0c9ig4pImnVOvH1baBjNRpaLXJ9PYewhhuQy4IJP5cyxsgRmtibHIkf8C8nNF8cn4X1f1t3D/sYobEZTMkPlIO8Fh7NQpBhlImZ0HOSCamFDN71e9odfVytmclN5XM5N3TGznWWY1MkPHu1NtINkYTpTH8sq9nx17Oyc46pqaXMiPz1wcNVo2RCSnF7Go+w87mM8z8X0qcDYzN4NmxV5Bpiv9H/5xIJBKJRCL5FyEF5BLJP4HLVUtb2w/o9dnodFn4fJ2YzUNRKIxoNHF0dPyE0TSEgYZBXJTWxYKcYfT2HsDlqsLv70MQ5Hg8DcTGTsVgyCUQsBEz8Dx6Wx+Klj0QX0C/zEaf6zAJxrmoVMmkpFyO01lJQ4ebZq0Ca3w6qanDERRm7NXliMFOFCotWoOCQEcXgikd0iPJ1dLDQcyGRhTKdE7WudCbMzDIDhIO+2jrE+jo92HQKJgwwEpz40oIBbDbY7BYIpng7Z4AXUI+uYVl2EQPN255E4UY5mTLFpLNI8kYfhcKuYwHhi9kREIuC3JG4rRX0917hihzDmcu/AmbvY7hAx4gISoePr2W1xQpnDemUZhxMbt61zJBpsYQDvJ58zo+jU6E7GFgTkUWm0PsoQ3cV3WEZXIdJjHIi1FDOen1cvj0ZuZkDadgxgt831BJi9LA96KWx4GFuaOYl/ARV6x+AnlI4LAmntf1uTy4+Xmu6TqMtnYnjP8N5M/CpbGQ7unkyt6TvBk1iPyGHwgpT6LTayFtNBbDAMRUP5kTHiCcMZbWo4+icvSgtOh5UmlHDNSjDNgRdj2PpqcZelagK7sZ9DH8dtPr7G89z4NF6VwlOJCFA+APkOjr47FxlxIluxi+Xgq9NbD7ZcT5rxNnVrPYZee4aQwBtYKd+8KUJKqYY9yG/sx3rImfzhRrPLMz43EnjIToOTzZWo1Q8TuU7m5u0ZqZuehuYjq7MHVXIox4A9bfAyE/HPuE3qiLadIX8YMmlq2qKH4sncPoM+vY33yWg3Izn0blM7PyAM8Pv5QeMUBF2w5eO1dF+6EzfDFiAZboHNyJpRxrrAag0dHFH8Zfw9iUAZw4Wczmgys4oU0CMcTr5du4Lk6JVhMJvrXaVK7MLeT24WWYjZFkaGExzBP7v0RA4HejL8MXCnBDyQyMKi1jkgrY03IOZ8CLQanhFrORm9vWsP2Ajzu8Sm4vncOSvLG8emItAuAJ+QFQyhQMicsiz5qMrbmJH394i7IFlxCbnkm2JZFsS+Lf7NsDYtLY23IOrVz1Nz9flDv6H/QrIpFIJBKJ5F+RFJBLJP8ECoURhcKIWh1Hb+8+QiE3KSnL0Wji6e7eg8NxHpdPRmtnKfMT5zAqKQqv14TH04DLVYlSaSUU8uDxtCCTqZDJlFgz0olmBGFHGw65E6+njVDIRW/vfkQxTEXPOKyqbszqWrzxEIrPANEMYQFn3lIONzkpy7HgO/wpI/ffT5f9NgLTH8Tp07HvXBtRmmoGZgYZPyDv57OYDEBUMIxWrSQ5WoMyFEbmVxJWhdDpMn453+E5Zty+MCadgmBYwcUxiZhd7Qgjb6Fwws20Bnp5ce8mriiaxNKCSAm4Y7XfY7PX0W+vJcqcgxgOEVZpuXP7e8yxFHDGr6InJJJmTuP5WffTWzCK+E2/ISgILBtxGeij4a6TyAHz6e8I9zlI6r4AgsDBRY9zxN5Lo6OLAmsKhAKM6DnDuhgD19rO09DTwK27VjAxtYRTYQG5TM6SCfdgP7GWIeHmSOkxcwriyFsRa3bQ/vF8bOo4Po0ZjgxoFTQkmJRob9oKvbXI/jQcFFrImYLs8Eckb3wfUSZH8LtR1h9ABASAjjNgSqZFaeTmTW/x0vQ7mZ9dhlwQmDFgObKU6fDdteDpRXbZt1we83N27txpULkRyleCxoS2vRq1rYNDpYvZ2l5D4pB4ZrlrIWs6/rLbecTtZPLup1B0nqNn+DyaXnwCnWsP8aV2ahUm9IOmA6D32pEFXPDTg7DoQzj4DhgTyD6xkkflUSDCRYWTSYjNJuHgy+QqjLxR9hBJvc20Onvof3sGKYMu4Yv40ezrqQGcNKit9F/5E7E6E/E/PEOzswcAk0oXSUo34gres9nxt5xDKZNz1h1ip2wks1Mjx6TVJpGaujxS371uK26TBcFQyKqqAwjAxNQS3i/fxImuWtKMsRhlZirs9VyUPYwnRi1DbW9F8DkoEoKUxOQwKqmALHMCn5/fQYoxhgeHLyLPksjo5EKSfn4Df3bXVir278YQZWXildf/H/v2nYMv4uaBM1HJlf+VnwiJRCKRSCT/Q0kBuUTyT6BWx5KRcQMAGk0SgUAfGk1kGKvFEqlHrNYUkuJTkhyt/qWdxVJGb+8egkEnMTEzaenYi9fbjFyuxefrRJtwET6Zjr6urZhMJSQnL6Oj40cCQQeiv5dU3znsUVo0unTwadh0thuFTKAgRc+cAVYEhQyfyQGA0+Ogvf4o0dFjCITV+IJm/P7evzoXlUJGVoIOAFd5F8pVhagyjaiujyIYEjlc1Y9CEWJP/x7GJg+gLDGP+fEyVA6Bbyz55PQ3sLe1iq11Z4j32CiYcC2odBRkL+Hk2Xfp7a8kJXEMRbnL+KHqAJsbTuCMLuHblEwa40tJNFgRRZGaU9+Q0VeHfNj1HOowEKo5yKhheRy395CRM52YARfjbNtNZ98+DL5zTEyd9utJ9DfybfIE2kMKNscMInPzU9R4VcTrLbw84TpitSaGJeQye99z0LSboDWXx3MuR3FwF+Nby7k7aQ4ZAQdX42CLNokb4ifiUOrZ6nMRF5MLkx/HoY2ms7OW7K2PRYJvBHB3E0wfjksexFR7IrLcmMQfsi/h7f1PEbviRwqnP838w8+C0gXj74M7T0A4hDMcZP/3dzFRdKGa+yocfhf2vorg7qFq0rP8/vD33N24nVt7z9M68g6SDu6Basic+gQHqnbzg8vLQn0MliH3wbF3iQ7bWREzgmghzEUHv8XgughFCNDFQsNeHH2NvGwuYUxiAWPLbibr02uYYathWfxswkotsvH381F3Lz81nyHTFE+5vYMthgyu1Mdyw6A5VPZ3sK/1AjdvfYt+n4tv5j7A1rKLuHffl/iicxiVXAiATJARCocBiNGYaHP3kWz8dWj6L45+iHL9fYh5w5DPe5sVM+8mEApy/eY3CP9cFNwqS+TSpIWUG07zVfX3rKk+xMW5o3j2tsMkWrP49s+C5t1LX0AmRJL4Lc4f+xe7Gj5vMVqTheKJU/+e7i0F4xKJRCKRSP7TpIBcIvkn0+nSgfQ/WyJis51E4apieO61f9HW7/8567nCSFVXIs1988hNCJAZLcPnbUavz0ShMOH1tiEISlpaVmKxjudEnQZnKJqwoCLJpUWjsML5d8jXjKdCMYTGDg+6d04hN6mIvedmKi25nO0fgcoWIj9TxfgiNaGAkSMNsWjaeplYbAXA7Qvh9Ycx6mU8sudTLEodt48dgaYw8rnHH6Kj388511k+a9zM7uazXF8ynRRdNO3uFl49exB1VTlfznqcwR0C4/ddidixHXH5d0RH5TMo/3Lqmr8nZDsGieOY7evA23OYEWILKxKLWPPTSyxThhg38W6ud4osSRjP/RMfpqPcBfIkPt76Gr/v6STLHM+GhU8i18WiP1+PzhaGbx+HeW9ATC78cCuLe1vYGj2GdmBcxXesnPg7ujImcMeOdxmXXMSwhFwYdSs07EfRW8XJ5sO0qmtJ0aaT4q4mP+TkVlsdtybnUNlygl5BiU6phk2P0nzyG6bFT0N2+gB7ZGqs8gCE/DjG3UG4cTfq/sh1xZQMi97nmdaTKLUqZMEgor0ZIeiBXc+D3wEznsUZ9PPTF1ezy+Om3tfDdf11CFFpnJj3Pp+c20bq9jc4ZCrgU1MBg0MukkoWQdc5UGppUEfxh+5ulijNdKePIS6xFG65H1af5+qssXQcei9yLE1nEPrrYMSNkDWJ+6tPsav5DKsrdvNC7jDWCCaSDbmk1/zEPXt+4q70Yq5MiUNVsZtcIcALMhXaaQ9C8QKsgDsQGQo+PlqBQh5LlMaA7dhzPKpqZ0sohi31J5idNQyA30+4hm8r9jEnazhV/a2M/TlY/wtKHWGlBoxJaDTJDNPrONJRRRgRtUyBIAj0+nuxBxzEmbTQAmFEHH43z9eWY22r46aBM3/Z3MoLe4jWGpnxv8z7BtBboihbcMl/pFtLJBKJRCKR/KdIAblE8v8zQZAhk6mRy3V/9ZlKFYVMpiYubhqubgUywUdVuxKZXE9RaiQRnEYTT3LyInp7DwIi5xpdyJTplCbasbtl2PEiC50mTaGkKCcRnWDkXJMTx5g+EtpBLh9GTv5c3HUO6jo97Dvfx6SSaLx+I75AN6L46/HsO9+H0xsiPzPMutrDaORKrlgwmVfPbmCeEEN2VCLjshKY2GxDa5zKj/XH+M3uj/lk5j2MzpzPKN97lMYXYtVqCSjl+JUm3NoYpnx+L1PTB/F89gA8fh+azpNQAKrU4SyOSeWMYTI1nTa65VrW+ezc2HGcZQPnkBuVxDmPk5frPmC4RkdCQjb0dJJsiIHeWrTbXkZ7dhX1SWVMURcx8cgqXgx3QtNBsmLz2eE+QExvC+4Jd1CaOojz3yyF2Ekcaa+KnLBCg92cRos7Aa/fjE8Z4BVnFdf6u7ht2ELY+CBi8xFyXK0Iggzh+Kdw5jt6w2FEUSQkyNmjTWL+5a9D+yl+Eu0sbj4HoQAAnRkTsKy9A23jfs4ufJiwTE5ubRWKmAyUHife6FzOtFdx7OQqbm7cxExByTlzErvOvUl6cxXm9nay9Bns1yaAINAjqCBnCiQPhitWsb/lAjevfYE59goe6j8B/SdYm38xG3e8ymu9Z1EOvgJr0BM511G3R+qGT/ktqI2M8XzHhZZyLus5hcZeziBlIuMFD+3qLIJiJ93l39LnbubW/CL6Bw7h6pZ+BHc54fAsZH4fv6tbxcbUUmZlxaA1DiDFGEOH3kD8wV3kGWtY3t7Go/s+Y0JKCSNkIRLiC0g1xZBqiuGmLX+isreRXEs8j466nHRTHCi1yAJeLM4gp/o6uXrjqyzJG8sNJTPo9dr5vuoAjZ5mXqt/k2OXv8K2zt20u/u5adAsFq19HqVMzo0lMxAEgXpbJ08dXIlKrvglIBdFERARhL+sBvrQnk841FbBl7PvJ9Fg/Qf2fIlEIpFIJBIpIJdI/n8nl2vJyLgBQRD+6jOrdRRW6ygAilIhyqDkVJ0ds06O01lNSIhBozKhVsqIiirD4awnTnea/nA26QmpdHYW4nSeJ0wY/4gbOdbn4WxtPalygQL5XkhVAnMQCJOXrKbT5v+lfJndEyQsgvzP4pN4ixqlM8CLxz9FKZPz/LirWFmxm68u7MbkUNKtCTChw43q7A/cO+sl4oqnc6SjiiS9mebmrdw3cCrxsaM5WmMnnBDLb0few9Tsifh3fkC/14U8aTipTccha0Zkh+Egst4qLOFErhjwLJPjdBT2VaIctIz71ZEs2FV9rTjDTuTWZBbG9XBx8mjMUdMJvV6CTAzjLZiCs+gqnEc3UmKrg8RMQrGFGHpqMIUDCIjIT6/GL9OS5e5glOCjXR/PNRtf4/lTbxDt6eZAbBRqpQ0wIyCyQp9NsimfI7lXUJgzlhZngN/1HoGND4EYYqBSy4+tP6KY+CgZRQ+AzgqNB9Cqk3mu4GKim84SG3Qz9sxq3kwcww8pi+g8UgvAyc51qDwO3GNv5AmHl3U//ZFriibxTfwoyrwdpBl1nFBp6IlNYURzJXfaTrNwwm10G5PI/Gox1Plg+jOgNvDYvs/wh4NY9dHQAwhyVAoV8SEPypAf0dbC2zEjMPttXHb8U+g4hZg9iXs6m+luO8313aeYGrbxR10RS6bcw6j4dI7UbeatnlUkCALbo4tZ6Y0ir6mXI7V1xAtOwkV2ZH4nefZ6cmr7aBs+lZC/h66u7RgT5xDSfIc6Oo8ErYU2dx+cXcXS7n2sMmTjSV+LVpvC+Z56er0ulqVoOdhWEQnIB1wMWisklGDva8cT9GP3ObglQ4lCYeDywkcQELBo9IhikA8nzEOnz0Sp0PGHCddiVut/6WPpplhuHTSbOJ35l3u7pWUlgYCNtLSrkMu1vyyv7W+nw92P3e8mESkgl0gkEolE8o8lBeQSyf8D/lYw/rckRqlRKcyE/I20t6/F6U+gwzuNGUNi8XiaCfjbUcjCpBmOIpPNJyFhFjZbKuGwl86Akqs3P4dBoefFgQ8QipmAXBeFKIZoaPgYUQwxvnABGk0MAFaDiqx4LVbjr/NjB2YYAfiqTYlSpqBo66OMFBXYYiZSYujE73XiTCzE2lMLKcO5PHkIKcZopn//JBNMQeZbRTp762l3TMMTjuanmgsU+328nCmSnzuUPp+LqJE3/3rCrm5k9hbSLXVkFFqBJX/1neRGJXH08j8S2PkUzSEtdlsjH22/n+dCPgIqPS1DRoNaZOf4S4n9fD50xyK/vwrdywWEA27kPjvq3maC9XsJxCbzetN65iTM5IC9g6BMgQyR8cEe5vac4KAmgU+N+fRoo3nh0LcEEOk8t4VEcxqhvmP40segL10GSj05mx6Bxp0w9hbY/QfY/jRTkofzmqkUh7mQVa0/kRD2ICYMpLO7HYAotYF38+ew2KpA33ISv6eZeH0GC7JHkJ8/Ciyp4OzEXfUhoRQFTlUih0/vIaHjLEMGLgRjXKT+uDISUN5ROotA6yp22U2UiYv5Y+deZkbFk7l8BXeseZQEfR43XHMXvpAf5WfzAfAoNGxrriIQVnI0ehhnVfBTQMZV1hQqW9YzwODio4HzWNXSy49qJw5ZN2ttMRyXmTiOiYaPl/Ow2AW3H6Orfy/BjuPoG87Slj0axWPfUDjERpGjmR+Xf8XBlvPsXPcQ8xJn06k0kF3/JRt79BjlIo8NzkWujmdczqhfL3bWBADG6aw8PvJSttUfwudXEwq5KExKxe51cOPWP1Fk0nNZUgCzfxCxsVOYmzX8r/rbnUMu+otl4bCfcDiAKIb+YvmHM+6kz+skzRT7d/VRiUQikUgkkv8IKSCXSP4bcXiCnDtVThxt6NIS6fGlYdbLCQYd+P3dQCQ5VuS/I/T6dGo7RE409DM4JocMo4KReQHk2p/n0/4cgIRCXpqbvyA5+RK02lQUcoFBmaa/eRzvTL2VQF8DqjeHEhC0TEjKwe+1k5Y0EWvBlfQPv4MLvc2M/Lm9IAiYjZmIYjVudw1lWRcR/fU8pnZ3sbF/GKFhBj4/vY5vOr7kh/mPkmVOiKyYMhRuO4xgjMduP8fJ+u0UWYcRkzLyL47H7arlC08PH+33kmCIxhWEapWV6CGLcYkK3j69nzEZU7li1O0Qkwc1O1A5O0AQYN5bcPY77AEfcm8QIyLLcsrQxhaQUAXyU1+SM/IGju17l3n2Gmb52iHko14Xy6PmIbzTvh156nAGpV5KjhhkzfanIXcGor0ZvH2RxG1FC/Cf+5b2snG8qTFw78kgf0yazAPOs9zhOsOwETfy4NE16BVqhhTPwUM1HW4v2z1yru07S/4X86GvHiY9Ct1VpNVuxplWyJ62Xu6JHYu5o5tDChV4beBzQE81/HArc4xxbE8w0+IWsMlU3Jo0jb0ImPf+gTcaf+BdlZzYkZfQ3Pw1x8tmE783QHJcAV/NKuS9kz/S6W7jhoIM7k26mDhTHCebXbiCbuyiEehlTdoQ5ieIXCozs3bvCXyhMClhP0FPN/LXS7As/xLOlaOu3s3Hjf18M3sIGyp6UY6+iOt+eoUJKcWYSxbS3HAGbzjI27V2apwdtLjd3HuihrBYxa0eE9fkDcDtbsAhFCBHT3qMkROdtexvr+dU+kUsyItk6n/3yFuc7GqgvEvg2qwJdIQsPLPjfa4qmvxLXfJ/U2trJ1kfjVoReeCUknIZohhCLtf8RTvRW4dVpgCkgFwikUgkEsk/nhSQSyT/jWhUMoYEd6EPdoPuKlLTCmhvX099fQVJSYtJTr4UQVAAAp2d21CrY+nq2oYopKKSjeO5obMJujfQ3bWFtLSrABAEOenpV9PdvQenswq5XP/vHocgCKisGXDzPhz9XQSbPwagqW0PwZCXd9uC7Gg6zcPFwxgVbeXQsj9gVOuwORrQqKNQizICjmaiBQ/T7MepCi+nLqRDLfeikv0vGatjI2XX9tX8wD3HzjLKs42P5zwAyUNBoYJwGJuji+7WRmzyJMbF57LF62Zu4kzuTpzCa/vXoFcoWV5ighnPwp4/wro7QaWHqU/BkOX0KzU8vHsFBy3jeClNxS0TbgZEyB8VCeA9fWQs/QT7hvsxNR9EBHLdXeRo+jiriaE0tYxCr4abKr4GZyufVO7ni6SLiFfIGH/kPW6QqbClZBLWGZGJIlMSc7ljxm9orXsHm87MN8e+Y15/JZ+GC/imoY0jbbVoBQvX2g5xs+0cIY0RuUwJO56FtFEoo/KIOn+QitjI2+OUqFQAOrJn8I3DTvZXNzC7/wyqXjMjZ/7EwECQew9tQHC0o/7TCIy50xAFGVcOnocohtjSXMPoQBedZVOI+uFWMoEtQialvm6yTr0NWZvAksrAU18ihIOMmPZHDnS1s7Oji3iFlqHOGgpd7dSb0tmRdgWzHd9irT1AwNWCsuwmTrl9HNOmYlDqMb50nv1tFZzd+hYzGrfRLsrwG3IBONnv5r6hC3jiwFeECRMWwww6+Aq96jn0CCGuObwGvULPqjmPMSllIEkKJyXKCgKBQSgUBhZk5HG4q5OJGWPxG0Zx79a3aHR0YVJp/yIg39V0hpu2/onZmUP548RIWTOZTAn85b0XDLro7NwIQHb2nT/3LYlEIpFIJJJ/HOlvFxLJfyNKuQxl0Szoq4WoLCAyB10QFMhkahQKA52dGxEEJS5XNVptKoKgxGIwMTMlBrUyiu7uErTa1L/YriAoiI2dRGzspP/Q8di1OnTmEqzOPHr7K5EHPBjKV5OpSaXJlEC4dz/VDpH05EgNc7lMSUXNd8gsw7g5diobW9eToOrlbLCK29PGUzLzfhQy+V/tJxwOkmrKJFnYT2HYDd9fF/ng+m343hmHK+DngYCDhaZ0Cie8zYenN3Oqqx6r2oAIzE00kheuhZN14HNG1vW7QAzT4uxh7vHtRKks5Af6ya04CB03wmcXQ3QOXZ0VXBC0/Njexv2LV8CfhiAE3NjM6dRkTOSanmZeSxzFd4f+AGEbaCwkagx0qC14/A7STm3kx6J5nGmwcXvvZjqGjmdeggybqEUTPZAWWyMHgwruyyvleXU6FzR6+gMhZmYPYJe/n836dJ6YdDMjTVb49hoI+qHtBOis3HDlpyS3VTA1rZQjdYfpqD9MjyaWDeoUZhdkEpr2BN3dPwDw2YybUZavRqwQOZ8wlI25S5gQU8IQmYqfzlVyTdNa/BoDj+lL+D3d3BXyYMqbDL178Tu7UNRsB40Zn9/J9+WbWXnJH7hozTN83NvE5S1r+USuYqj2Eg7ZjtM3YTn20lF4VL2ohH7cE+/iGVkNanUsGqWayRoVuUEHN3YfISDIcRQt4nRPAw8MW0iWJTI6wqJQs0rjIeHMUTwHfHRMfpCQ2IRImG9rt/PGqXUIwEhzFg2t1fzYsJ6HRizm24UXA7Cn4lOeKNDzYaOG20vn/sX9FK01YlbrSTP+n996KxR6LJZheL2t+P29qNVx/6H+IZFIJBKJRPLvkQJyieS/m7iiyD8/i42dTEzMJARBwOWqw+1uQK2OIyqqDIMhD5Uq5s/mqMuJi5v2t7f7HxAKeejuOcqxM5E34+nJU+l1tOFtrSanej/L4jMYNnA6EIXFlE171zHiYkqpqF1FR9dx1P11JCcUcbEYYk5KIfOKhpIUVKLY/XsYfUfk7fWfqa5fS+eFr3lnwnL0hkm8+M1SmmVKfv9mGYqwDw0KVo58gCuGLgLgupLpABzrqGZx9jCuzU0jds2T0H4GMif8umFzCkqZApUgkBQO8LTSSpxCw8G2Sgo8dsT28zwYNZT92kRweVnm9xB73wXY8RzmwnlMaq2hvLsJ5eF3oOlwZJvpY5huTmXaRX/A9WoJBlcny0Utx3QZ3NG1E31bNR5jIpoUHUbLJQjWfh7wvseE/gsk7H6CmozJHIsuY0bOaJYMmMaZ7gZGxKXD5t+CJZ2Wur08HjuBea56JgDfVOylqq+VG7VyhrsbmO5pRg4wdxuCOQ2hVwmIyGRqegcsZNypA4Qb6xGp51hXHR9Pv5E7h5dSE67hsD3AekMm+YNu4YbiSYgygRODL+P2DS/xSLRIsTxIRud5pmhh6frfc0neGHSCDG+UGk1UOm8VLkYuyMmKT6erawcV1bvxavTU1fzEXYteRgj4AGjc9TJeEb4w5OLRGTjafo4ZyWmYei5wuOko09MHMwMXCbufJKyLpqZ0ASptFgPj0pmfMxKNXIlckJFpjmdQ3i38ZvdnbG8qp6xhG0meboZfuZIMnQqvV8kzoy8mXm/5i/upOCadQ5f94S+WOcvfR733XRSzX0HIGIcoitjtp/B6W/F6W2ltXUVm5s1IJBKJRCKR/CNJAblE8i/g3wJunS6DhIS5qFSxqFRRf/f6R9qryLEkEqUx/PuNPf102fbjdF5Apzbg9jnp6TsHIQeh2Bha+5NpTkjH77cRFoM4XBrau47Qa6vC4+0BwOdp4d6Sq3jYYyc+ayxZaRPg4znQsBcs6VC67Nf9BX2kHvyCvMqtOORpbI7LZ6UhF0/YR2s4TFZcEbFeO1eUXvTL8HaOfAiH3mFTygy+6+uhICaby/ub6Zep+NI0gMsWXYNl42/gx7uJu+Yntl/yKN4PlqF0VPFC8W18e2o7huT5mIQQV9oq8Cg0XDnlPkrjIqMSmPUiAFcFfbx1PsS9QiwHZ7yIRqGCLU9Awz4CY+7muuQ5BJ2dXNd7krHGVDSTH0e/5hYwp0LiRXD6O+Kj0rmodCnhhr141FtY3d/LcF0HI0wxyA0xFFWuxX/4eVQ1exEROG4pYL82EY85jYaqA5zubqDD1U+ewsdsdRRa38/z1t+fiGzy42SPv/+Xr9Ky/Tme9lTxiC4PFSK3D5yEzVZOok7AOOV2wt54woe+o+f0agJHnqFtyDS6BQuXqXp4TszFIVPxxujBfNAmEAoHWJo3jkt/fIFvwgJrEqIYnVRIl9tGk9NGevxMJrj07PjuVq71dnLjlyH09ibGDF7Mp8TSpuxmgaeBh7MW0GfzQ7CbR6vq6fAF0ciUnFVryCpcjNqi50LvOV46W4M9BE2ObnYtfpqLPE2QMQ5UBh4asZgxyYW4tj/HLbo8puz9nJuHzCU/fhoqVTQOv4frNr1OliWBF8ZFpmr4Q0FanD1kmuMj/1+5Dq2thXDVRuQZ4/B6W+nq2o5MpkUm02Aw5COKIoFA/3+ob0FkiHy3x86ivNH/ofUkEolEIpH865MCconkX4ggCBgMef+hdf5tPu3opAI+mnHX/7lx5Sb48lL00+6hQRPC7XMiCEqSE8bS038evz4f7ainyPB2YtSn4PP3Ewr5OVzxLRbrEDJSomhs2YFRn0pm2ni2Z/zZ2+rx98OFQsif+Zf7PP4p2sqtkfOz5PPU6T8hIjJBDpcnTONToZOc3uPQXQFxhdB5Hur3QXcl1w6+GlP6SObnlFEx/z2uPvQDff39JNccZL5SB84OeGMo6qtWo3LWIPN7KFOFOWSMhaCXhV3HSNbAFdla1F1b+Tbk45K8sQTCIXxBP7rsiUyuPkVQrkJZdiPIZJBQAq5OvJZ0EuyNtCsMjA/2o/eEEQrnRh46VG+Hj34u7aYyoht9BxRexk5DCT9sfROf3c7etc+ybtHTsOkRVIAjKRdjaxXD7XW86XdQrbBQ3VfFk1Mf5qmDX3PEXsVLsZO5zVXFVX3lnFDFkNF8nI0XdtHtcXB76Rxk+19njgh7Y9SkCWFGfjaPjqXvYaw6ieXsbg4nTeHZpExmVqxG01uNviMbU0I6UXFRBFvVBIAVvjhSAvWYzdkcbD1PEAjKFHze0cTA2iO8fXwV3V4nSkFJqqDg8ag0FPYgp3x+XNpkKs5uo15hYEpKMS5auEMtY3RxMQZ5PzVOP73+IGExTIvHwQOWdLIEFapwP39KtnPkQhUFU16GE5/Bj3dD0QJY8glpplgu0Qxiu2MSWRUNbG+rZO/GNzh2+SsA9HodnOlpoMtj++W2emL/l6yuPsDrk25gdIwB25CZ9A2aSHrKlQCo1fGYTIPQaOIxmYppafme+vp3CYXcREdPICpq6F92jb4W3jm1ketLplMU/ZdTQu7a8R7eUIAh8dm/PACQSCQSiUQiASkgl0j+x8s0x5MflUxZYv6/31iQgSBgdAWQGWKAZkQxQJ+9khGl9/zazpROdU8dx2t3oA45eLSym4y2Vfy4+HmizDm/NHO5O6io/o6EuGEkZU+C7L8xhz1rImRNgmHXoSmYTXLL0/gDXsLOZvpkBvqi8mDqY5A+CrY9BXtexlF2Ka7ptxA7cBG36+Jg40OEHD2ku/t50FnN8H5w37CLU0dPY+g8QsnJb8BnB2Cus4K5C14n/NogPM4uPOYoDlFAc/MJvPvWcObyz3nh2BrO9jTy7dwHCcgV/Lb8LeSVn8FNuyF1OG5PM701r/OU0Yah4TDygBO0Ztj1Ipz8InJe8QNgyNW/vNWva9rC3nNbuaEgBaNCIMeowRN2oF3wNh+f+A6bSk2RzscwTZipvc24DSqGqoycDQVYVjCe1ZVy3KEA2+NHkFM4m+taGolFT9+hbwmGQ8x3VJM2+CrUbcf5Y9E02PYkAYWSY/WrCZ4/Q5pfxgEPLD27GqW9hp4xy7CnZVPf5+LrbhX2ny/H8a42ypt/oMYxE4vzAMXdDXyfMIac4ou4f9dH5Bk1zEowsrKpj25glT/Eo842itO0HHCG0IV8CHI9mfooHAs/IE5rorDxU4Swhgqnj3yjmifG3MKq2uNcljeMN458wJL0aKJUcVzech5T2kDQqiFtNBRehCiKhMQwwaCD7CgVCrmAzh9kdt6YX/IRJOiiGJVYQNafBcMpxmiMKi2aUCft7TuRybTIlUYEVWSUiEym4LDTRIbMSJr9PC53I6IoIpcJKBS6v7pN11YfZkPdUaI1xr8KyO8dtoA2Z9+/O2ddIpFIJBLJ/zxSQC6R/A+XZoplzYLH/q62/vRhdF37DuaoIQzWpOL2duPxdmMxZf5V2x9PvE+erJ0+eRI6hYJ4Q8xftTlf/TWd3Sdp7z5OYvyIv12PPSYXrvwBiPxgtTh78YUCPNN5iGmWHIaO+gMfd7fBma1cY80CtRmP3oDp1E/Itn8MV62Dw+9RKJPz9JAbiD2+G4vbz8od76KOvQZFeh7FPxWwV5OAWa4kPX8u5rV34nZ20S7T8pmmmPmFD3DfptcQoqxM9fajlMmRCTJ21h1lxokPMHjaIeiCcJC3Tm6lom03d+TG4YtOxIgVqrbQ5+7nuNxCstLCAzGjuXz8zSwuGMcz+97F2tNAlmMXo/Qa0mPjEZEjECIcdkPpZaRbiznZWcvdfgvfDDDh72lhWsalHFOqWXViHZ1+Bc+Nv5pVZzbz1IlXCaqMaJNm0+VzcUXhJDJPfUra9i9h+Xcw71VoPgYyFYqihWSkTOAtbxpVnhC3543lpmNqhqdM4bqUUfzp6AbK/Qq2Nq/m4eKbsfvcWHorCSFDUZRFX3Ysh8rPkdxSx8SUYiYkFzFI72JyjJIUv5vcV/cQE5BT/9urGSw34eitJCHo4pzaygeV+/m8+hCppjjuylISr1ExIUrLRG0vKtc5fjtqKbXHDnKrtQiDORF1fzXqWa9COASH3oW0kVCymOs3vc7p7nrWzH+MpJTL6Dn8EoIqzH2DZ9HVtR2DIZ8Ldh/7Ws9zoPUCD5ddQp/XSSgc5ts59yB37CEY1KPVpiMS5r1Ta4kxJJEXlcz9uz4iWa3js0EpyNQiXzR0MztjAEnyvw7IrymeglmtY37OyL/67MqiyX9X/5JIJBKJRPI/jxSQSySSv5vH04DH14LMocNgyMVkSMFkSPmbbQdlTqOhYT3jChazfELp32yT1XgBt9xHfNYszlR8Rr+9mhGl96NW/Vn989YTEFsASi0Ar0+6ke7uaj4/L2erL4Ro6+Wlw9+RG7Cx+OoPMZpTiD7zLT5rLkJfN+hjcc57Bn/YSXbKLKob9rPZ7yecNhA8EBQFmmfcRe+hzYzrP0fDkY8xB/oxKDX058zh6kkPEhVwYhRkeMUgqh9u4sOSRQSWvsQdX97Be+56vGoz3H4MDr+LramaTd4wCxQKJhz5iWPKGNYPu48fOhrxNtXymCaOSpWFgxe2MEJw8mVVOQpB4KNQNbaikbxc0U4YLW9Mu/uXucpliXkc66hmWEIej5wtJ96ayV3RBUT1r+GtKDunWj3MzBjCzLRBiBUrEF1d/LFkMk1KA0uVYVQjlkFzdiSIhUh990daEBQqioA3c8I4PDbq3TZUCjXG2FxGbnqMEbZWHsm/knezLmZO0VRKFVaOr/yIpTm53KJ3EB+08I5NSdiQy9hT3/BwjobyHjvNZ06R53OhdauQ2VyoU6+hv+sMb6R2Y3XKeNIvsDoA3nCIMQ3b+bbdwmF9El9MvJT66k/Y23SMJ89Xc7arnrGihacypxMzIJKoD0c7HP0QZEqY9Cg6ZwfZ7g4C4RB6QyI/LnqakBhG8Ndhs50kELCR2xXAHPJh1BgREPjqwm7eOrUBv6+LBbH9KBQmnM5zAIhuGy+dP8iuJc8zN2s4xWdWErf+a9oXvMK0zDyixEr6+o6g06UDcKa7gWxLItFaEzcMnPFf62ASiUQikUj+x5ECcolE8r+1uuoAgXCIJfljATCZShAEFTpd2r+77qR/G4Lu6ftlWafbhivg/WUerbVmP+P76mHYE+yu/RSnqw2f387nFYc42HaBl6ItRK27HUqXw4K3AJiQWgypxYR0MbRX7mVYfA6rTFB4ZgMc+wgqNyKv34Nj1Hxkdx5AY0ijp09OMACm7b8jL20IeWPvJXh0BZ86zpOfnYHMOoiSxmaOuzspaT0MfgdorQw7txIMJjj8HgfVJgKhIJqgG05/TdDdS6Xfw9SMpfw0+VrQWRG3P8uD4QBXy7UkejLxWHPYE9RyKiQjIFehlSuY7+9kZOt6dOPeQln7Pb9V9SNYMrmxu5iPNHrO9nWCv4ePzh8kx5LEWyfXMzltIB+e2UKxOY5VjT9w3p7HpX29JGnkbKxYTYoYhn1vQFwBbrmIViawpXoDt2rMqI6+S3DIVRwaegtD5Gq0wP6W8zywewWzMofy6MglBD6Zx+xQLL1yDRa1kUW5o/DXrkAedHGzu4rsxn28FLRj225n9KEazk3IRIgy4m6v5brEMqxd5Qzd/BuaBkzgIWcygmDhixFDMLwuktga4PSaq1hpHUVbjJ7nZS08NOQyctz9VLSVc2VPKzVRceQPmE5h6nju3LeaFm83clk/IcJsF3rRntvA/bqLSTRYwZgAl34OTUdg0yO8fuZ9EMMIgaeA2F8SE4ZUBQSDTvTqVDRrLmNfxxmECQ8hCAKF1hTitBYGxJei0zQRDvtQqxMIBh0kRBfwYloS8rCN34+/CleMHKH6IClrHiZp0KX0D5uHXh8ZEfJT3THu2fE+c7KH8/KESCm+Pq+TkBgmRvtnD5UkEolEIpFI/jekgFwikfxNnqCfh/d+CsDU9EFYNUYEQY7JVPS/Xcfnt3Ou8kviYweTFF8GB9+GjQ/B3Fdg2LVcsu4Fer0ONi36HRdqQT7ic8amh5DH5lFm/g0+vx2TIYU1NSuo7GuhMn4mZcZEiC/+q30tMZtZMuZSsCRCznhO1uxEtusViodfgSc2hUDuCBTySPm0+No6wtWbUHTU4xIUTO5yk+3r4bgmjoV7dnDXzN8SJswQeRgUBvA7YfDl4LWBIVIXW64x03H9Lq5Y+ywjRRcPnl1NrGkIhqCbR2rK2b3na54Z+whHT60hKJNzVJPO00YVN1xYg6/FwHltKjcPmIqxZgVGoMF5BHfmAJYcfhFZeBdr867G5gyzNljOkmAarx5fy1WxOpLcNmzOJG4MtDOm5RRhrZULIQiJYVo8Is9FDSUu6ObKLb9FO+pWXIlZlOddxomqXrpPryIlOpc73Ap2bH6dxWqBZy57i8f2fk63185n53dwSVos2SEf5rCfHpmawb3nyPlqMe65z9NpiiK8/yv8gpzLcmLwJUTT093JlGW3MFhWhbLvAKohpcRq2uhqj+G0dTwZvgYElRxBUIJJRHZhD+7Uq5hnyCIk7kXw2jHvfJbZFz/MBEsC+rwnGJe1kHFKLaIokh2TS7C3heuKp5Kgt/Lhmc2srzuKSq7k+XGRhGt47bD/NTDEI4jhyAgKw5/VCA8FkB98j+jza2Hiw9BxGoUmCiY+CMCrJ9bR6ennk3NbeS5fRZgQ6a4YlKVXkQp0de2kqWk7en0uLnUP1pQcrCe+hK4q/lRZT4bJzRVFcYzZ+SQHWw7zTV4ZO5pOMyapkNmrfkcgHGTHkucwqrT/9Y4okUgkEonkX5oUkEskkr9Jq1DxSNklBEJBrBrj37VOb38FbZ2H8fp6IwG5EEmq9W//HhibQbOjG4NCizfgIqyIIxwXgxxQq8yoVWYAXpt0AzX9bZSll7I9KoNmRw9X/tl+jtcepH7VrSwM9cGDdXRmz2V53B5kYogNzmZSF3yAftvT8FkODFiIpvEgFMxmj7mHx7wCNkFOq1yPIIbZoolnw56P8YpqvhSVDLFmgasLsqfAl0tAH8PBRV9iictjx6eX0aLLYkM4xLMaE990bAbgKpkMp8JCbMDFze5aogJ2XiBMSst5jCEv0d4eLhu0jLnqn+fIq81oEsfgaTlM7bSr8Z8/zgdz76CtfRW91hlcu2UDWzOm0af0sdWr5OILG3i0/xSIIj/M+5jHD36NHhFCPr4w5FDi7+F6Vw3U7kBt1hOr1fB6/2Fy/b2wfDPFqx+iIaRghK0OtjzB2zVfsDhhOkOjTeA6jnj5N/yInAsuO+4fbiGpu423d37Aa5o0PplxL8/EFnBldICozv3UTPAyatRkZq3ehzOcxG0uLZmpS9kiK0Or0JAb3c3ClCgyU+bQ23eUhmET8fbPoCxspdDahKsriDlhHjExQ9Dp0jEaB4BMwRfnd7Kt4RT72y6glMlJN8fz0ZktKGUKRibkopTJ+P32t7jr8IsoBy1FyJ0OAy6mSpdAUuZo9EoNAP0+F7aP5pDWcRIBEbz9sPz7SMD+c46C64un88rxNUxIKSa84wWMIScv63KZlziYHG0JKlUUMpkGnS4Vv78XZV4Z3D6P6pDAFxtexqBUk6fuZYSrFSHko6rpOH+sOswbk24ixRiNN+hHJZP+eJVIJBKJRPLvk/7GIJFI/rf+o8mo4mOGMCD/Cqzmn0uvld3IRks+aTFZFAFvTL7pl7ZTB2kQRVAqZH+1nUxz/C/D2h/a8wkxgouhsSkMiMuDjnPcvXsFndFl5OqDlAAGhY/B5kzkATuGiVdHNtJ0GMRwpAyavRlyp3Pc4aHj1E9M0RvY4RIZHnZTJygJyJTokaEY8yCMvCzyZlypA2smzaZ0rjm6HgNr2d91iGhDFwMC/aCQIagMiH4XN/Sc5CpBhlc7iqiAnYBSx+BBFyOrVnPK3sFpUzKTFVW80xLi6SFXQspw4oVUFNWv0TdkCo60Qpq8cuKso1GeWc/S/rMsOXmemvG3YtKHWFZ9CCbch33AYhZYksj1dZPzw/W8bS7hXfMALlILHI8fwvDW/SjMY0GhJNEcD63nsPXU0aeNZnXN96gHLoGG/eT7+3g8LpGtuNlr05OXGwWhAAVtW/k+by6n+joQxDDJOgvNrl6+qaskpaKVCY5anrIO5fLv3sXa0IyYHMMfjq5GIZMTDIcAuCcvnmStks6O9YjICIoiW3t3YlRaGd68B1dsMSMP/EDUyR0Mj8/g7iIfFstgPjm7nUZHFwCBcIjVVQc42FZBbNDN9ta1XBE/jZPqaG7wu/F0XCDx6jVUrXsA25lVfFJ6E8/M+g3BcIg/HFnFSEcPCTIF6pkvwICLfwnEAXD3Mj8hk/lLnuPhPZ9S1d9Hk8LACo0V1fO1pJ4aQNoNTbxnbOTWgbmYAz18e+wTFqnTyBt1C78bdRnPHfyK63dvYUvGSBK6qxnoaKA1eRxFMal8e9FDv+7L0w9qU6QcnkQikUgkEsnfIAXkEonkH0Ymk5Oe/GvpshOdtdy9fyUphmi2XvLMX7RV/Y1A/G95uGQ46u4tuFp/hLh74ehH3NhzjAspY8ld+CIAWk0Mzw9PIWbzW2jeeAcsWaBQAeAfezOqmIEgU3DLmkUMKVhE2azf0edzYTm2gtD2pzgy7ht6dSWYQwfhrZFw8c9ZvG87RKytlamrH2V52z6UwBJnDSBASAMxuTzk03BGE0OZtwN/SMnI67aiNCUxo3IjNB9Eb4jleRppjx5NssIOyTdGapX31GCtOo7KbeelcBoHml5i79IXMI4axKqjm1lov4DZZWPZ0GLUg0vZKivh9tVPc8ugWdw5aAHCvj9wd1c5l0bH86rNwR91aTw35FYOGDIYEsolJ1kO8mgOy0x87oOmvCt498QHkS81Jp8Fsx5DW3+CMcmFkWXHP4H197FQZWSRdQwVKgshdz/1tnbeSk4lqqmZ2+MnkRubzeiqIJO+PIL56nSe06o4acxAobcSpTGQG1uATifg9bahVsfRLubTEljPqbbTDBt/H+ZgBTR1UKT3s6HuOItielAo9Lw88Toe2/sZ3R47Vw+YwiX5Y5ltthLa8jgKMczdA6exLqzheaOZ68ffxLVf3klmXxWP+7poU4gAvHVqA99V7edA5nx+HwryeNxQplZsiEx5iEqPZGh/ayT43XDjdp458gItUSnkzXyBtjWPMMRRTZcgIpeHiceL8cIGgpnJhOVyAhWbWGspIFYfzRh/N96gH0vmVXB+E1e07uKKab8BQ/Qv9629eicN315PSeH0X/IfSCQSiUQikfyvpIBcIpH8X5MblcSsjKEMjM34D6136sjn9J37kRFZI5hWt42VyUW8eeoC9+8YweSZT3K5zkr/wGU8dXAlk1IHMqV1L9EnP0Dd1YQQDnLE2ctnBUu5w9dP6s7nIW8B9NahcrYzru0QyJXE6yyQMQZShlGWIBI+/Tja898AIqy6EdJHw5w/om47wRv1qxAjn/BNzGCWDLsUISYfNj/GvGA36uzhuDvVPFyzFqpX4tLFcXPelaQWXcNScy5ytRfT6TMMatjDDt+3vJi1gEejrYxb+AGG/Fmod77PIK+TT85u5+oBU9As+BO1mx8g5cI6HDm34JCryRCPsDwtmoGaTmrr3yZtxFUoy38gMW0Ylx/+BEXmeNwGM2d7LrA8xUmn6zSdlTu5266kVK3isSm30Co0ENNSjpA5CqVMxpgokZMtBxAV8UxJGw1poxACboxiELkoEqU1MjqpkFEn3oCWYxTGhJk0chl5U4awOaGDeWff5Q9OgUZPPfNjJtDlsZEqqnG74c06H0uLJzMuMZ8UYyxH2quYmTmUcCCLT1Qh5KFelucUE6uxotdnUmLS/VX5vWnFM6B6DcQsY+ToGxgJ0H6a2pbD7PcFqFLF8fiCd7iodBkAhdZUEnRRlMZmsr7uKOVVO5m670lIHhp5W+3qAmMSqI0Q9CN3dpCmsUDqEJ64+FmY3kMgRSAoH03O5l0omvbQnr2UqSYNMfU7aOvt4E3rEMpbNyEAaO+Ghe9D26nI/QI4e7poOX2CDxrWsy5hGu/7Aoz7z3YgiUQikUgk//KkgFwikfxfY1BqeGXS9X93e3HzEwQbGjF2djEosIdw3UZkiAQVqdSG5RyS6ZncfgomPcKT2/7ExsYzVPe1Mu38++jc3ThSCtD2tvOtNofN/T0Uy6zcYK+IJJf7Nwo1uHvZU7mLqC2PUehqQdN0CehjERG5K2YMczxNTD/1FR8p4ri2cAIMvRbh2EfUKozUh2Ww8REQADHMoLHXEZ8Rg8yq5LithLEdR9C4uyjvbaJGIeOqQg9yrYzeUDyphnROmGKod/ZysnkX4w41Yrv3PO6AD0IOzrbu4e7KHTw/5xHiRT+4+jm6/jvipy8iRafm+pLpEOrD5aolWLyIxrih6KzZlEx8iJKTXxH64RY0gy9DLpPRmTKakzYjeruLtICXA6ffwxBjIj5vCYluD5bDr9IbLSC4/dx2rIFYnZnfDLuasaE2/pi7nJ31h/CfbyG4fy0tQ67lZa+anfo0Xs8dxca6YzzisNEaPZRYbx+L4jNZnD2aDee20XRgC4LFyp4eLR62MjIx/5cpCMFwiB/qzzPUnAeOA5hsF/j65ZMMmlKDLU/JaYWJB0dcgjvoY03NIaakDuJ5axnJ+hgeCoeRh4Pw2UKyXJ18PvV5oqKMBPPn/fIH2bT0UgbHZWFQarkkbwxD9Ea48AXEFsGpL0EMwajbqAqEcDWdovTOE6CJ5C0geSgASkBJDFq1FrGlipj2XjSJoxETS4lKm87vZQJCgzyyraYjMO4+SB9Dr9+NQamhs/I83TVVjBLVlId7SC5Z/g/pSxKJRCKRSP41SQG5RCL5f4MowsG3UYZ9WIVL8MpVaEJ+QODaym/Jm/IsIwMpMP5+AAo13bRZtIwzB6H0MsQDb+HPGcOhgIFFXU0U5U5icfZDCHIFYtspwiEPckcnrwfU7PriDsY7G7nL1YxbpkQXDoAuhtUxQ9iElc36dEbq21hY9RMcew1G3oo49FpSLqzjwd5jYM2G3hpQGdDlX4pZ46bXoOdOdRvrlOfJUKp4d8JClDWrqDm9jwvJJVR6Fbxz/VZuDwUY1nyS2EMv0RA1ip72Sva1nidVp+LtoelceaiWjw58ysNxhdBxmsrsSZRqVXhCkBM3Hr+/F5lMhXv/u2TveZVTmgQSZz4JqSOQp49mbtIwHq+3s7b1DL5QkOsSsznhdjCveg/hxESi+vv4odPJFMcGrAsf51DlZsa7e9kFDDz+DlH1J6gdfBy7Po88uxWPqCTpyHvs0BfiByq7zjNA52KuRUZMTx87dcmMK5jH/YMWkmmM57aj3yP2wZL8sVxeMBZszWCO1KrfUn+CM00/UdsRzTKrj1BXJ2JYJFB3kDdEGa0KA+NSillTc4iN9cepbj5F4oUfWWnM4bNzO/iNTsZ1rk6ILSSnfSOd8RN4bt/bZMYOpTgmHXvlFm6uOsmi9EE8k1UMnnboqcLfV49SUCCIIaj4iWWKHNxNTWwvmk3CvwXkf8ZmK0eZXoquPBatsYTXej0Mm/U6S9IGwYbfRIJxgB3PIO54loB1MursR9jt3sW42Tej0ukZnjSXhZ52SCv7p3QfiUQikUgk/z1JAblEIvlPcQa8dLj6yLYk/pe35fW2Ewj0o1++GufeSkytT3OqLZrdPTlcNDKKLJONySOvAqWWsN+FsPZ22nwCpzwC0fI+SB6IcOlntB5ewe2haFJDId5rP8DZlFLKHBUEN95Pd8kYjGUPsm/n95xVmJitVHModjBDy66FDfdCfz1zuy6wL2Yk6/UZTPB3M8vfybG4ISQd/4JEvw2VoID8WXDxe9BbC0c/Qla3h1ifnaix93JlyUyOjL0SsXIdR46tY4ugIy9mBK0OgV6PnS/2rWB52gAKjAZmeGLQOPvYc2g2f7KWEKPTYm+LY6KzlSVT7oSY2yAqg3tlCk70e+lRJVACOBzncTjOE332OwAyfN2w/l54tA3/lWu556ubuWZIHqGwnlUt/azobEGlUFLugFtatlCWsoiS5BzOBgr502e3MHvSTYzPL+R6y1R0VZ/i7W7kO1eYw6E+9uFmjusMQqCdm2RBKjOGEO7bhD5mNL8R2ol21WKRy4kbfjWc+Z4rTUmoBpah7NuPR9FD7I6n4ex3cMUq6KuntGYDuUNH40dDRsYdsHUYNw+TcbjsIi6t2IQubwofnN7Msc4aBsakcX2MA29BOl+0RPIN9Mg0oNBCTw06Xxfdifl8WetEXldHSAwz39eBQhWDvmID7H4QZEpCgCocwK5PxORqA5+DWVYLnQo9UWrDL/dgMOhGodDhdTXR1bUVuUpP5v2VHG4+y0db3mRX0xkmN+6MJAscfgOc+ByCHgREBFUMcpmaUfZ21N8sIWXZV6AxAen/5b4hkUgkEonkX5sUkEskkv+UO7e/y/7WC3w+616GJeT+l7bV3r6WYNBJSsplGK8aw7Z9QTr3HGN1uo+GhCL+eMlvIg3PrcVV/g7GC/u4QRvH3WE/QeVIOP4ByNWkT3iY4dXHsVg1XOcI0LrxFdboQ+T3txB7+Ef8g27h7ZzBdPiaKGw5A0EPBF3wcDO8MgBVwM0fug8QlzOFY/4uCjV6rlJnkStPYF3bhkjprO5qWH0zDLkikghNpoBwEEV8Mb8ZupjODb/BevRDbhBkvJe6mEpnIzkhN/VyHdtP/cDyLXdhThtNWsBMGIFD6jhKFSYstYfZ2tTEbd4OknUGXB4b+t0voQfei5/CYU08xqjhjE8axJZTa9mnzGaaXsGH0cP4YvBkHtr2DsMT8jgnaNHKZUyNN6GVCSTUnaCoo5Yn4sdzQhODWa3k4cJEQmERsSENZ1ImZ119DDLoiZ38Gj2jnsG9/U8UN+xhsyqOh8K1hC96haKfdiOuOYf11EYMN4+hseRS7m+DY+oY9h//HMPa22iZcR1WuZYHm+XoZOfo1Rq5W66GPa+ArZEEWxM9JdPRpE0CmRwCHsSgj1tryxEVibySVMzJqo8RgCGxGQRNbSgNRbxZu4lVIQ25ggmCPiAMMQUMLLyC38XYaHX2srr6ABMLR/J0oAd7iw93lxK0Uch0Mci7zmEQwiBXgSWNpy95+S/uP5vtFF1d24jWFGL57EbMEy5HNWAqACMS8rhywExGJeYifj4DwWcn3F2NLDYPfA5EZw/K9q+RucpRO84DAjg7fg7IJRKJRCKRSP7PpIBcIpH8p+Rakqjt7yBG+9dDfv+jzOYh+P1d9NoaqG2r4rbK41jTDPT6BMqx/dpw40MY7S30lk4jsasPWctRqN4IsfnQ34Rpx1N8rNCwL248CW4t53VxxJddAlXrkMcWo1v3OLqGvVj/bXuGBNj4UCTIG3kLbH8aQa5iU0cNrapYliq1lLr7Ge5piQy7vnoD4htD6bF3cCIgMg0gHITSyyF/NjTsw3z0Q45p4ghqovjd2Kv5cdvLPNZziNroIgYFekCpQ914gM9lSspSFrK6ZBaFLjfpfUbuii5jqDmGL7RWZn7/BJOtw7nX18hkTyuN2jjqbO1MThvIIGUqmzSdPKxNZXxUAu7yb6n0GWh39/PBnEeoqVrJCVs369qcPJCSyZiW/cR5e9mvSyHsD9HRLSdZH4dwz2matjzF3c1tDK/4kPcWPcs9O9/ncGcDT7rbeTBUS8vcG2jTushybCc+uhe3KwCtm8GsZXp2FktqT2NIHw2ly+mRGzHrtTw6QMPOLi8Xjb6d7zPKWLj+ZkSlmrbLnicx80pk8kjNcFEmQ+ezc232cOr9fu7e+SFWjQGTSseK87sxlYzh+oGz8JXo2V51mmNimIuJZFRXddWiUiVwaf5AAO4ZOj9yTe2tGHf/gXJlFD+O+R2/S86AVTciG/8AFM4FlQFCAVgxF+RKuHItghD5o1AQRYSgl9iaChg9EP/pL2jqqyUp8RpCci3O6a/j3/IiduswMm98E86tRfjxHvCD3HE+sn+tFWL+aw+oJBKJRCKR/M8hBeQSieQ/5eGyS3i47JJ/yLaioobhbD9O+NN55MnVLIkaRWHxPPLj84jTmcHdG0nMVrQAUWPGMng5wivFiICgjwelAQJuABRBHxPOHmSCpz+SwG3odAi4EeytkVJmcjWEfGBOg4SBULkhEqQNujSyDb+Lt4+vpElhYIynmTHw6zofTmdn/HDGtR0gr3F35OBji2DWi6A2QPJQ1AMvpez8OpAZIG80MzuPotu6lSxPC9x7Ft6fTEvbea5Kv5hBKpFbU414ZDFsFcajcQgM6ziO+GoJgZgpfG3M5WhiKTcVDMB24ii/P7qa0rgsAs1HuadtN9bUoaS0n4G2k7wy+Ho0465CJsjI1gfY3S/DHgzR3dJCAAGtIRZZWCBRaYCzCprFTvYevxyTPprMgJ1SXTwfHPiMw+1V6OQCojmab8xDGSfX0uj0MZRGFJYA9fPvQGZ3YGk6xuLYMdySncELW9/nvWmPsKPuGKPlbQyJcjM8sZjVlbt47+wu1idO45lhRXhwEQy5Uck1tG9/kW40BNTRlCUVsjQul1ZXD7FaEyMS8ynvqmdCxnhUqmgK247xUO9p0gpnE2g3ofTZwNEKZ3+Ashv/8mYKh1AB+aZoCocvBKUG7jkDfjchbw+y9fciKNTQfjrylj7kx2QagMGQh8zdD8nDfsmY3hWshSQ92cHzxOvHYBg8nxZ5KinHn4ZP50PriUjNekEOljSwNcG0p/4hfUIikUgkEsn/DFJALpFI/p+gtXUgdzsw4uApxzqYcS/EZwNwetPTPFZ/lutt57iocAp8MAUBEb/eguo3ldB6Ej6eDQFX5E11zY7IRrOnQNZkmP4MbH4MznwPumhw+0GhZGvjSRy6dC42p0SC7kPvgd9BZnwu2bp4UA+Gmm2RQF2Qg7Odsc5OgoKM+JA3so9lX0aCcYgE7aPvgJrtkfa9tWhHXIe7dSf++FzMthbEjnLi5TIm953jFvs5jLUC7kteo8agxGu7QGrAgT8c5N2pt3LbtrcZZlZQpO3j0lg1n3f4idIYMLYdJ9bfAzWbCQN+cyoDZj5Jnygw8ZtHyNUKvOM8xlJFKtbmw3gEBWO7T5MYX0qGr5kcXxMV7i6eic4nzmZn95Bp8ONdnFDFsC9jFksKc1BrppOfWMbh9iqePPAVlw+9m7tTkwhre/BExZLa3AA7fk97/rX0+Zy8f3ozP9YeQTloBpemmviytpGp5i76U2MoSV1ObFYxwaAblcoK3dUk7H6OKGQMSV/GCn00KcZoXhk6D+1HU6lUWbnuwXOR77T8W4S2E1xdupBQQjHywzbCgAsZLzZU0tL3Gm9PvQWNQgXdVWBrRrjvPCaF9pda9ACelfNoGTkToxniD34P1/wIDfvA3ghROcg2Pgo+OzTuB3c3nPoKU1ohsvzRjMocjkKtAyBlQDH8eJA6lHSnjEQR8pE89XHi0kf83+8kEolEIpFI/uVIAblEIvmH6vU6aHH0UPJ31B4P2hoJKRWodUnIU0aAXIUQ8sPQayB5yC/tTkUXUNHaykFtAhe1nURwtBMomkVoxHWR7cRlYy+7mKh9XyLU74GAM7LiuPtAJoORt8HJr3jJr2SfOYdnh44l99iX3KXPIiTIGPnd9SQWL4CAi4DWhOiz4Y/J5Iwpj46iOKZ4WlCkj4Etj6MkjFIE8mYhNuxnz773EEuXMyG1GD6aSbC/jeZLd5K4+27UbwxFvGErrUPG4wqGSVVosF90G2GFijt++hSdPhq514bp8Le8EApzddsp7kiYzFOGAh5pLqdbhK9bbCwOtnH/mW08dE8V5+3dnJ/0O0rOf0da5Y9s1yZzl2Ucn/Z3UBKTTnFMGnqFGsbfgra7lslBCwoxzKnGb5Bji7zFXfolUc3HufLsdvIDdmzCFE6rExgQ6ONurYKRg+/+5btvbzqOSaEk89z3OE52UTfmAV7tPIPBb+TDUJCVpVNxJQ+h09VPOBRgkk6GzXaSQQYDPlHJFTm55GaMBUCptEQ2uupGKnRJvBo/DkQBT9AHQKrOQFgMUqJS/nqTNOyLZLTXRyMvnEeTJZvU/hqCQ6/ju24XuC5woK2CSSoZrJgDnj64aQ+UryR8+H18qaPQXrUGwd4GYhghHITEQZGHJ95uaC+PjLA4/G4kH8DSldBRDjuew9hTjTF3Cagtvx5PTzW+0fewqK4an6jg7a6dnDu8QgrIJRKJRCKR/KdIAblEIvmHunXrO5zsqv13k71tP/wnTvecZWJGBoXZ1+EO2VDmTkHfdCwyJ/vEF5Ha0HEFLBuyiFR7I0PPHAG/AMWLUS58nzpbG69ve4fFaQlkGzREAcH4ImRNhyPZry0/Z7mWyeCK1VRt/CMVTjuV3kY0Y2dy36kmbM3HSAg4IqWsbtqDrOs8yu+vR/Qe4mVziCOaeJL0OawoWUbahfXQdBAyxvOngIo9lhE8Vv4lr3a3MyGnBKIyOWCZRXOHnPzEGxjSX4NMH0+8+RJmr3uV5AMP8GJJLDLAkzUJQ/lXkeOr3ooOGKKLZpla4EIwxMvndjFACNIg07KmW05c4VLilVoe2vMJFX0tXKeLZqlcz3ZtMiICb5z4kfnZZTw/9iqePPAl4ze8xtiUAVxXPI1YpQr5/AegYX/k+DMnoCqYwyOCwH65gVHl+1hkyuF5hZmLsmYw8t8uUm8tY1ddzjpDCna/g/OqWH6qaadGsANyvp3zLjKnk6jyH5k38nKu7jzIyjPNXBVrYLTfjWrxF6CP+csLHw5DTxX5QS/pOeMJVe7DE/RHLlNUBrKbdmMO/jz6oP0MxBfD8u8hexLIZKTefpD61tN8vOd9Zjvr8St0jE8eAJ9cBJ4+vo8ZSl5YxoDyr5GF/Mjr9xDqPI8maw5Zhw8ixOTD2GWQOgqUOmg/Gxn6vuSzyEiH7Mng7oG8WZBaBmmj4bvrIstTy+DdcSjNqYwouAaXo5PRDe2EbFX/kL4jkUgkEonkfx4pIJdIJP81TYehvxFKFgMwPCEHV8BLkiH6f7tKKBTA6zxGrhpOtfdSnKfj2IknmXzhp0iDU1/B0Q+wJQ3DdMlHhNUmDhjS6R5xN4s23gYKDchkbKo7ztbGU0SptRQXzCOQfxM1HYeJ669EE4bKqs8ZOPA25HIVvy3fSrWo4OPCkYz86W78o2/k2sl34v7ueipdZvJNySBXIt/+LBTMRQgFeNJt41aVmgZXL9X9baRd/SOcXwtJQ4n96jos6EggxBvN66FhFU2Dr+HWnk6ia95nhWxYZM44oPLbKDKbebDue+ytYXqTh1MbdHGVQklYY+WC3ECivQlrYinL637EJcpYmDiDR8QuNob1fCa3cjQUxQ/AqMQCLGo9c07+idiwl4f7TxGVN50P2yro9Tj45OxWLvS1IiCiCfRyZVo2on444378PbMMRh5JGAR7/gh1u6DlKDJrEYJhEOqghxiZmur+NlqdvSQZrNB4GLspnQNxQ3kWM9OTisnwyxgeiuJIRxVWSzKW765mgrcNX0wynwhRrDdqSLM3cyCkpeqHZ1lRdgM1XXU0te/iirQSVrZW0qrP56HeIzyYO4zrh8wjSm3g9RPryDTFM+enWxB6ahFuOQA/3BJ5g33Zt5H53uEQnF/LyiOr+Fowc4VcwaO5g34eBXELVaLAy+FYRlYd5IXlq2j5bAmZnnboroDEgcgOvwu1O+DYR/BAHSQNgw9mRB7GZI6HgDcyF3zdHSCGI7kBmg/Bme+guxIKZkPCQGTxxbwTY4GDT8HIW1HkTIFza6Fo3v/dviaRSCQSieRfjhSQSySS/5qVy8HVCTF5kDiQ+4ZdzH3DLv6bTSt6m7lj+3tcmj+W/MSZ1PU1c8mI25HLVaSnTac/+SSWnkaEonls7WrgDmK5/tOrmK5Vs0KZRbTGyKJrN4Elje7ylbTv/ZhlKYO5dcAUYvx28PSTlTSJznHdHHdVEug7TW7jHgyJwxlRvoJWUY8xPQdBDKMWtGDN4sH4CWxR5vOuLoUJfQ3UOrrJ6vsRgGxgpXAMnVxO814H7VOuImgJktSwlyVdRxmgtBATcBD8+fz0nh6iQ3Jy3UHSeu6E9ftg6hM01X/Eg0kBsg71EERgUNjKl+NGUyufiilmPt99ciPXyNuJqt/D0vgZtCj0JKrhe0wMbL1AnimPqyr3s/GnEJ+0t6EQZChDXnzIMIR9nKo7wG/G3sJ7pzfh9LkwhXzcaDvL2BEZOBznUff6GNtdzsXtbXQoS9C21WFqOQ0xBYyMSuFI1df4tNFsDNj5Xe0RjrSeZn3pMAw/3IoBAVtYhcM6lM2tZ3D4PXySM5DCI99i6inlQnoZnsbdnPN6aNTFc0lKMpdkDmTN1rex+1yc37WBPwrNtAo+cqpe4Ep3M7OTL+Leac+giisgBjjb3chbJzdgUeuZaDahDlgRVEqUZTdB9TZIGRb5gg+9C5se5iq5DmXiOJZe+QndciVKnwtz4VxiMidy6bntzM0ajsqSSOYdBxDbzyBkjYeqrZE34qZkfGml+Dy1GJUDEIZdB0feg84Lkfu4+Thc9Doc+xjeHB4Z2j5oGYy6DbRRcNMuEEVYeRkQhnM/wIV1kYdSN2yPjOqQSCQSiUQi+TtJAblEIvmvGX0HdF2IBOT/jsr9m7k07jIqz37KNTUfMnr4DcjOroJBS4mJSkWx7GMEQw701SPrPA+xMcgVWooNZh4tXUKGOR6SixDFEOtrt/G9MYsRHiexX10CnecBEbU1i9TeWsy5k/B1n8PQr4Rvrmeup5ep5jTEU5vpH3A3ltpdsPlxVB4HckFGZ1QOe/VW3oou4/3uPegNsWBrJkoMQDCAt34vlu3dRNcc4/mshcxKm8iXLh/LHRWU+nth/INYR93Czo2PRLJv44gEeokl7HH3EatVEZU5kQ5TBg/lLyA5Wo6j+zDn97/CV6Y8jqtjWROo5vneQ5hDPg4Pn4pZoWElg5hrEvnMXMaLx95nvrkIPSK5QQfvxQynKnMqFf2dlJ9Yy4DoNFocPSzQKvlSoeS7M63cWzqJSdue4/nuCpyx6bRnD6Y+JhtVr4vCZSt55dwuhmNgatVqZsvsrMqeRZLGT7f3AqGicdT0i1zZupcyUzRCzmwCLccoCtqQiQG8oouUWfej1bzO2uPrOd1dz9SUAViOfcRK+wk8vXUEdaVckzGFE+5qRI2FFmsqT854AJVKAV9fAWPuoih5KPel5JIRl4s3aTbOoIN4UzoMzobBl/96AyUOAo2ZRK+N+zr34V13B/KKDfxkzueiuw8SpTFw18CZoFAhimH21/XR48hikmM9xpJZkYR+PVV0Tl2Or2szcoUO/Zzfw7BrYN+rUP41ONtgzF1QsQFCxyP7TRoM+9+Eyp/g+u3QXx/5XJCBxgwll0Dr8b+rD0gkEolEIpH8OSkgl0gk/zVj7vz72oVDxIlagqoorhbdCEEfwv43QJDhz59Cd/d2BEGJwXAH6GOZLA9wpHcHBkM81BzjihnPQnQk6zoBH+OyB9De1sPs0qth7c2g0oM+FhztAJiq/i3Tuj5SK1yhRd3XyKd572OwpjO6YRtR579ltF+LS5dKVdM2hhaNxpQxmBWjruW2/DHw8SzoPIdbG8OnhVfyW9tJFEE/lbYuNHlTeKluLbKeXpCpCJ7+it68EowzH0erToDqrVC5EQrmsnHzW/S6eigbdDkFKYMpiMnBXb2GfoWMqCgtNzdVcUf7TkBksEyJEA7Q3e/gqNZIml5Bij7EGBlsTx7DHaKDT+1u1uszeUObhbe3F3fsLJTuWprstXR77bznAZARj5702BGcyZxOl8vFIIcDseIMz3vMRGXO5lqPm0+qD7FZoWEKIuawj2/K38A+8SYcgQBdQybzxzMtLJarWNC0HRz1YG+FSiUklNAWbyDUvYWUrV9w76U/MCQum1mN2+DYxxgAw7SnQa7iimHXsG/nh9wckvPiuKuZnzoQtj0dGf6vj0EI+blh3+/AEE+geD7OsQ9y984PSdBH8dCIxZR31fPSkVXcVjqHMWPvg62/JRzyoqjdhgKR6fZqhPq9keD4vQmgNuG9YT1ub4AQCQS3PYu46Q5EvwMZEL93FXJbC1y3APRAfBHkzYxk60/5OTnbJSsic8kFORjjI2XOfE7wOyFxcCSbf8ZYGH59pLyeRCKRSCQSyX+CFJBLJJJ/DpmcIaPHkOdxosu/DeeEBRhqTiDoo/H4OgDQYYbNj0feWAoyDM5OiMmNJNtSauHYCtCYEZxdpG5+iSsH3U58fy00H44k37p6PXx3TaRuef0eQESs3UH3spfRON0Y1j1Js9hLUtCKKdiNxtnGQmCRq5bO2BB2t5EH8sxk1R0FsT+SdRvQ5U/nxXlPQNCHY909zGssZ0b+OGSeOhytp3jTNICH+06g2/ws/WVL0Q64m3DOZOrUIjjbqLY1oxRgztGf2L7vFQy37EX75XXEp+WjGnIjKSUZyNt2sCu6BG9eCTlhN8M1+RiPfs795sG0BPTEmnK475oHCIaCFG99CW36aIIHviastBBSxyIXgyQr+1laMJZvK/fT63Xw3rTbyLcms65gHp+EDDwxaik5BhW/a/gCvc9FuizAwzlDKDr3AcLPl0kQwZw4GUP2BFps9cjVP2EoGgiueiiYGwlSL6wHXTQWSym+M1+icjnRKJR8dGYLf+ipZZ0+EUvJwsjDGkc7HH6PpwZfxPGckUxLK43saNRt4OwABIjKgoK59MvtdOck0l35JZsbzgMwJa2Uwxe2cryzhp3Vexkz/k5CR95BbmvFZ4lHYchA43PAJ3PxT7gXpRhG8PajeXMCpYOmEFLGYPQ3gNdJy5xbEZUaUg9tQ3D1Q8AHQT9sfChSe/z2w7D+ftj+DCz7CkxJv96/y1ZGMrj/27JlX/3f7C0SiUQikUj+h5ACcolE8k+jjE4jas1tcOpr1NdsiCTJkquQy0No2+uIKV8JnRXQfBSu3wpeG2x6BHwu6KmBdXeBIKP/ht1UjHidVvM4ihUhclOGQ0IxbHoUzv2AKFdx+6gnGV+zgdm0Yws243V3YPQ7uLrmSfpcnWgsCYTC/WDJQBbwoh98PUGdgLarGfb+Ea8gZ0naQv6gqCcveRhudz24ejC2HmdRwRSIyUI89gkbR19BnNdLz8kLaL1uLLtXEEqYQ0ugh6t2r8IkijwX7yKgUPJMq5otidOZaDuOOOdBrB2dUHw5d217h6qkeYRNySzUqmlUyLjs2CqKXC186+5grXwCkyvW4ywYz9rKvQinv+fT1hquN8fykb0ZU88WBlss7G+vp6KvlZAYIhwO88qaR+hRRaE3xvHA2RVYeg6wNqqAFW43T+sD5BRkc9WuF6HtAmFdNH0pZZgvfhuF1oIcSDNnc4mnkYqqtUztrYWuikggmj0JKjcTJU8FbSk4VsD7k2mwTsArU9OsMGBJHx256LtegqMfEvv/tXff4VGVef/H32f6ZDLpPSSBJCSQhNA7SO8qIIJURbC3tWF3XV1717W7IFhQEFERBGnSJJQQAgRICAkhvfdkMv33x3HZdXX32ee3rnEfv6/rykVy5pw5Z845yfCZ+76/97dPMm7YDZz1C8ek0xPnFwalmexpaWS/PprbZq1AW7IF3AX4BCXRzZ1FIg56B8eSeuApumoDGV38KRjdKEnT8B5+F1NdGcROgNBEXG4b5QEuLHOeI/TA5yjF+wnN/gaHNRivon7cEF2vYU1APO/51PHqgifpEdYT3h4NFUch+yO1MGHeZmguUz8sMPn9zc1rVr+EEEIIIX5GEsiFEL8sjwfwqq3YK6eBzojv2N/ju/19tcsxgKsD3hoBM9+B+nNqFW1rJIy+n3KtD9N2/Jlogy93mroSXF2gFuvKfE/tmo6CM2E8GdXn2GdJYrKtgxCHP6YTn4PXRfSIW4k++j40nAOHDXrNgZKDWKzJWCJSIKgFzC9SHhTJwp5dyPP2I6HrcMrLPwevh/iGs2gKFBh1H+Dl0uMbOH/xjZzotZnUgrexm02EvT+VwEvfxaUY6WqrILC1jTazL9cmxNJqCqeubg/4a/E/X4+28jiN9jbK9L6EKvB6QTUKMNW/K9Sfw4SXeVY/zmm68dGpT/hzZQchgX2oxsDFhTt4SG/CkNaN1LBgnuyIo638OKf0/niBXVjw7Wjlzb4X0//o8yhlBzjc5uCcpSslAxeQ0J6Lb+oluB02NiZOwmCqx5n/JbNS5oHOAMc+4eLjK9hljqKsz5VEZ38Af+oPPsF83NSI8e3JzGwrUlvXm8tYbfuaMp8wUpvyObzreV4+l8trKbMIrDiGUpaJZt+fOHXkS54IHcrBYBPaSU/wzr6PeezwyxSe/piApVtIqA3inX3vUWu0sKShEJNGQ2P6eMYXHcFk84AlBE3lcdzAKmsPas7ncO/oZdSEGHBp2ugwWvHEDUNTvB+3wUx9r4vwNcWi3/kKStFe5lW8Br6JGLPt4LWB5fvZAKyRavX5xRuhrVbtmSGEEEII8R8mgVwI8cua/jpMeRqv1kj16EUo7XWEbl6GEtAVes1Sg+7qOWrr+Bc3qF2kY4ao01GNuBOdw4ax+DGCGvIYe3oc+EaqhbiiB0BgV7j0VQz2Vj5/fSS1ERMxhvfHFDMN8jKhsgBqTkPpIfZ0m8xt3mBuy1zHkqaTcOYbmi97hsYAM4yfi87tpF+QH5GjlqIJScboKqLxzBY0Licdg6/E5HagKBpa43uj0epI93NiGfkkJz66ivCmWko/u4GbfaKY7GNGf/oIpcFxxCQPweW2Ex4yHrI+RHt8HZzayIdjHuZmYxq7S3NID+7C6KgUZubuwZywiA/GXkdsVApndt9ID3czwTo9s1JnkOpqYfSeb9G0nKPQfyY4znNrwTpibFVMiLgYraLlEp2bmNihDEyZAFOehSOreDQwmMv6zaVniA91dbvJNwXyWIeZZR15RIfH0tp4Dp6OgaXboNtIPAnj6NVzBsGR6ZD9/QcZkX14VZ9Eq9vN1PZS9IFx7DGGYbO1MLUxh6phM/Drmk7b8VLK/LoQeO0O3C8koWmpIt3bzvC2UrTndkHuVzxma6ebu4W6Zjvv5e5h2bbbmJ3Uh3F9xuKjjAedAc3Iu6hOO0x4+GRMTgU+W0qd1sRzgX3R4eWuTxagjwiBlOHY7RU01+wjAGgZNBtdn9lYgoeDKQa+vhsvChdHxGPN+QTyN0H6FXDjAXhzCOx4DFJmwvnv1HoFPkF/vW+LvoMDb8C4RyBUircJIYQQ4uchgVwI8cvSqJWpvR47LZFdwB1BcOZmtFOeUgtlgVosK340tNXA0Q8h7TJ4bYBaGO7WTPZMvJH9RwrZH3U5w7KuB6Bq+OW0mSBGcaLXm6HLNIoT78NZtY1BZ76mfcIdWC59FcXjgoheVGuD6Mj8gk3mLlzefh6ru51qnzZwtIE1iKhdn+Ke9jQ+1WXw2VJ+7wogw2bnLVMkI0qPw1f3waQnMfQYjqbhOwyGAD7KPcyzdOEB30SubD1DlLuZ7LhhuGtCuNPUh8v3fodWo+MW3X6s+VshbiSc34uuLo+EiNG02duYXPA179SV4tWbqXE5uHj7m9zebzq5baEMColkVmAtJ8pyGDtkHpqwd9Gc3kR06BSaHY00Ru+gwB3CPQF2EmInMqznXBxuF+eaqsg98D5T6k9gMVgYtudxPHoT9uR+nGltYU3lVsyVHirCHiD28CZwO9UpxlwdaOauJlhvgpz16rXxj4VTn9Mzair5fnHY7ini6MeLuY1g4oxexip14PWiVRR+P3QeaSFx6s9aExh8SRhyPa+cWAsDroXMd4n/y+h1cwALu/SAkXeiNBwCwK+xBOyt2GxlOJ0N2O01mPzTcQZEEtZYwRstWVg9bnRtJYRoemFWTtJqcuFbegbngEXUdu0GjUfw9++HPn4MBMShWEKxjloGVSegpQIOL4eyo9BzOpzbBeuXQtkRsLfAuIf/et9mr4bcjRDVB0KX/SK/KkIIIYT4v08CuRDil+VygKMVjU8QMfu/QV+chX3U7Zj/EsYbi2HnH9UppR6ug0lPqNvs/5PaJd3rxRsQT1OABa2zBa/RH8U/CqevPx5HFR6PE0yhBNVnYWw+gdlQRnlQOB2VGwkOHkVgYH/oM4/LgW6hCWw8l0lx9+dI07gJ1bTQ7mgiv11P2/TLSAsIJzfjTWp8ZmFo2QHAdp8uXORyqsfaXI5119tYT34OkV+R6NeNUFc7gYExtHmbONGjL3ajAb3ipUPRUt/Wzh22Iswp0/DqzbSPXErryHu4P+8A+09uB+C4X08cgMHlxKzVoyga1pz8ivPtDg5UVRDoaCHPEMi+jc9wQ/pkbp/yNObPbyTPWUR1SCQZzQoBbgMzY0dR3lrPtM8fxeZyMNQQzhTAW56F4nagAUrKT3NnxAQe94klyWAg/VwpVJ2BwTeoU4DZGigfcB1RXQer82t3HQmpl0FZJius0dB4DjbfxZDSXezQmCm57E1KDT3RYCA+/jo0Z7ZRnfE2RYdXERmahnHAEkrWX09/ey1EpPPthBf4qOQUbxStJ6StCtbMg4WfEWhaiH/uV2i+vhcOfkJonzlY/UIwb38VJj1J27RHaKvYR2rcWMI2vwx2E8z7GEtjKZa1CyBxKt6RD+BnO0Fz60kqKj4nNnYRDL0FNi+DvS9AR7N6DXUmddo+3zC1V0bZEYgfo05l9rfGPqjWKeiz4D/8CyKEEEKI3xIJ5EKIX9bq2XB+P1y/F2NLI16XE/OOZ2HfW7B0K4T1hElPgTlQbU0HdTzzLYfB6wWDD0ZgXA8jhvxttF+/gZrmwwQH9iXc1AW93gr527HWZ2PNuoVnekzjeWMSRrcesz4ETqxTW0XTLqf/ud30Lz3EAcvzTMzezIsW0FSfZF+3/rxf0c51Sgt9oq6hya8nc0s/pFhnYp21O8khvVmk3QAZrwHwRGB/Gtvhyea9bGmuICN+Kvq2GgY6rXj9u2Ns38C2si8Jd9kw+IbCtOcpSe+H3X6OO45nkd9Ui6/ezGPD5rOt6Dhbi7Ow6izUOZsAuDIunqMNVcwwOOjd7GGnTzgv1dUS6vP9mPu2GpLKjmO1xhLceyklTicWewdFuRuwuRwoKFw9dhElOR6s4b0IyM+Eon0YNDrCNBpWJExnYWQC6bsegLjhMPJumntcyv1bnufA7g84+M0y6LeYhspT7LUmctnJNRfG66PV49TocQTFExUzhNt3HGBUdDw3NZbCJ/MJBcIA6k/ydewoXgoewodVOwgvO8LWoEHss9nYn7aQ0SdWqvN7b7wdFm9EkzgRNA+oc9JvfQSfwG5qd3l7C/7zVqOLHIDZHAPXXqq26Bt84MBbeFqraG7Pw/rmAELiRuLpnoLRaFHPU9osqC9Ui7c1FKljxResA3uzOg958lQw+sHFL6nP97f8omDIjf+53wshhBBC/CZJIBdC/LL0FtAacLbV8UW7nUFaC3HuVjUUlWaqgXzoTT+xnRkc7Rd+9D38Cnz3Mu5+l+NKScXhqMdq7ak+GBiH0xxEmd6fsWFpREZOR3E74ZU+ajdlvHiL91OhsxDlauNk1scUe/2IyP2KEGcL52ISsepMDCs9SK/KTJoCUtnfXkJg1CAaHS4sVgNO/zB09SV4gLW+CdgVLaO7TeV4fSmrmlu4bexz3DRkHrzaF4AqnS+HQvowIy4dLaDzSeaerJNoFBMXBRiYmzqesfED6N1WQtKpXMp6LSDCL5Ss6gLeLcjF6YX+8elcMvEapjccYq45Bh+fWPX1zv0In1WXUn5sNwfyclnun0IkVQw/v4NNidPY3msRJ9rdDJj8IiZTNAxRYPlEelQdZ4frDPoRt1JZlUu2V08fayT4hlLrcnPA2pUodzu6imPY8rcR2lGH43wG3sE3oDjaIGUmdr2JAduX40LDs1XnONZQj0Zj4aYERS2Yd2ItXqB18E1MHLoER3B3Qj/bCnX5PNh6mhmV2xhU2kxz6mi0pmAsMePU16QoanE/FPWr9zzY9SSc2YJib8XXtzvUnFED/IAlashuLkPjcQNenH7hmFpriNj4ojp9XcQYdVz4lKfV51+6DV7rD2sWqD0CCnZC2uUw8y2oPA7haaDR/sw3vxBCCCHED0kgF0L8suZ+BG4nm88d4eGQoQxx1LOyYov62P5Xod+in94udxN8sgBG3Qtj7oce06A8C1PvJUSHxmEyR6mV2z+9GoK6oe9oYm7yFIhJg6MfqcW7Ohop0lpQFAjRaLk/cCD97TUsnPJ7Ug8ux2/AK+BxMTltOlOOvI+m4AM8QLYumYcC+zMEGw938RLXcAyHxQ+7MRGDIYg7QiKpL9iFT8xihtpqOeyCQUmjwGABnREAf5eNhPpcjtfn0nf8Izj0MWTXN9Dd18yM4Bac5RvoiB+P66s7uNHRgP2cBkP6Ap4OiELvKAVFYUj7YdqPKzT4tGLIfhYiL4KRd6n7GPMAXVYvwOgNIc5j51BQMutaOxhVe46XsjYAsKf0FKfrSvjG0EBE5TGMHheUHMKz41GuNfUkP3ISn428i1SgqLmaNmcHQWGJMOQTzAnjKNj3J+bsew6ltRomPg7VJzHGDMLgfRenRkvCrkd5U9GTfGwDZD0D015CiUiHwFg2aQKx5e7m6rTxUHI9ZLyOr07PYGcDDosf1elDMNWWY/n+fOHfBeauhqz34aw6XIDxf4CQpL9W4y/OUAuwaQ1qIG+txmmyYKyvxtRnifoBD0BQIrw+UA3uF7+kLtPqQWtUw3r/xWC0QtIktXDbNw/AiDth/CM/550vhBBCCPEjEsiFEL8sRQGdgcG+fkywlTENG0x+BnI+h45GaCoH/6gfblN/Th3fixdy1sHw2yBmEFz1FUpdAeZXh0H3SeB2qIW5KrPVMehaAw1ZL+Bx2wgK7o6SMoOivF0kORvJGPsk1/mb0FpiCQpPpuu4+/mg8DCzegwnQGuCxAngH4MmfjS9+y3hkkOf0lOvZVjZCfwLPkNRjwYFWOx0Q+Mx+PIqOlpr6GMOJiDiWRpszbQHdie6sZh4jw2Pqw1lwGLQmYi16vlkyg34m0NprdxOjcPNos0v0i24P3drywkrOoinrohpV37Da3X5XOdTReqpTIwx0zB6rVhP7aKw4ASfGruyOG0c4fGjeCPtar5qqMWg0bGmzUFfjZYXjer0XT46I8dqzgHgsTWC10tzUAymtgYMeV8zfNggzDojkb5B8OZwxgIrLn6L7sGx4ONPVlUB0V36ofE41WuxZgGUHoZ5n/A7fwsFNUUkVu0nJbQH4FCv29d3g9eNY9pL/CFH/dDl4uAoQvK+xmM0oRx+F43HhV7rh3/BcYIPbwLXu7B4M3QdBoHdoKMFel6sto4DTPgj7H8NTn0Jl72jjmsv/BZyPoPpr6H/eC76yuOw44+weBMkjlOHOmy6Sz3u/a9B9wkQmgy3HVWvoFYHA65Wnz8oXh0uIdOeCSGEEOIXIIFcCNEpwn1D+FPrSQhPhSE3wME31XG9qy6GmzIutCxTfRreGAbhKeAbAXVnoa4AItPVxx1tYG+F1kpIGAd5m2Dco9D7Crw6I3VnXwYFrMFdoKWYdK+NALeNpuw38e0zHHfZIdrzinjdx8OnZ/ZhrC9gYc0RmPAojtuOklVVwICI7jzXv12dN903Qg15NXkoXQaqU7IFJ6pdp5tKeDBqIssq91L+7gSO6/yZfH4H2V0ncKDbRK7KfAlz5nLQaKjq2ReLu4oQ32mc9PrzUNZWbB43BYYw7pt2L7Wb72Ffu4HtWev4rqoYu62Kh10+JKbN4uYvHic5ZDiu2CFsPrmdgsZK3nEXs/jMRty9ruaK9Jk4szcz4uyfOWiK4KrwsVj1Zq5MGcu0+AFE+4WCrQE/3zDY+hAc/ZD70sdDRC91WEBzGR6vi27eHLKrOvh9xloa7K3EWkPZemcuaPXUv5BCk85KdUsTV8x4HmPpQVi5C9x2uKcIXu0DbdUAGKpO8ERLDjZnB6Gb74b6AjSAR2cAQGmuIPRILXgVtbV71SXwu2w4tweKv6M9Ip6WIZcSfmAD7H5Wvfalh6A8Ww3PJn/wi1ZbuWe+o4b32KHwwQzwuL8f++1Vq/ZvfVDtnr5ovdpK/veSp8C9Rf+p214IIYQQ4gckkAshOoc1HO7O/2vhtsE3qOGwvgA+v4H88U9wy463uCwmhesVBWrPwFUb1XnJvw/jXq8XT1h3tAs/U+cgD+oGI24HoKGjlYb2aiIiL8bjcdBuK8YeHkxbv2t450wVRVWlvLXlzzi9WvTKn3lUa6BrjwXMPvEe1OZBSzkvpy1lRc527ug/net7jlK7PDeVQkCc2j1+2O8gWh0jznW74MQ6ntlyH1q85FfnURozhnaNgRxrLC8XHiXOa2QyoBx6F7yXoOk5lJbKDNx5u/n2/EbW+iaw3i+ZQFMMD7X4kBMcw/X60yRH+/F6WQQrIobxJJDgH0GWsx+39pzA5n3vc7AijzpjA6ntZbzYYxBNu59FU3qQ1uA+DB68kDuMMWwrzmZgRHe6B37f+8A3TP134uPUjryHh/Z9yPD6WhaljIFbMikr/Ri7o4JTjQoN9lYiLUGMiU1Xw++mOymyxjDfrx/JWV9x5sQeliaPYE7kAGKj0qDiqNo6XXJQ7Xp+9ENm1R9X99dyBroMwBuSBJP+CLueUz98ObMF4kZA5nJ1PZ1JPd+Vx3E1ncAeHIXLLwxd+gIYdB1UnYTiA3B6g3rvGP3guUS1wJtWp853X5YJLrvarT8kCboMVCus/30FdSGEEEKITiKBXAjRef4SxkFtxdQaYdMd1BrbyDz7IedbashurlPDlLMdgrqxvLGez9Y/yp/GXoef7RhNbaeI3PUJphYb40NG0zOkK2+kDsf+4RxWWHtw9aJVJARE4nA00BTbB5/iY9R6/Kg2hVKg88OlaEhyNqFxO1galwradrWad/pcegd3I9YaSlpwnFpULmE8rJn/12Pe/ghcpY7PxhJCXfRgAvBSpzXzWMrVLOw7HZ8rVzFq59MU2otJnv4KZdXb8M/bwd6KOmZPvh7vs3GkeTQEeBx0dbXRqDdS2JTH/OlPsaFgFwqnSPU1c39iECN6LQTgpYQ0PIOm4zb40O6ay9q8vYxu8rAzdgShnyzAagpAsZXSNm8vxKThzv6anNrzbMrfxwN7V9HFL4SPpt594WUs2/0eGRW5HK0uUAO5JYQIezDaLQ/hjRyHgg6dRsNdNQdg7To4s5m+Rit/MIXykSYIL17+nLeX/RFjWZ/zNhxZqXY3/122uoMuA9Uu4LuewqM30B6dhMUQicYYBFOegbzN8N0rYAoAn2DoNgp8Q9VtZ7yBX30hJos/2gFPqUMRQK16bg6CkkNqeG8qUYdD4FWHLjSWwOUr/nqt/lKbYNa7P9fdK4QQQgjxb5NALoToNCdqijhQkcdVqWMxaPVqca0t9+HwD2ZgoI5V468kJbwPh41eYnES/nIvBvh14zlrXwqLDtK3+CPoOQQ8Hs57NVS4XNRU5kNIABGOJoZ52wn4fsorgyGQWEcUSsajzDBFcE34WK4JH8NtYVEkH30LInrDoGvx7vgjittBraJlUtd+TIpKRh0pDri+r/KuaNUW2YFLaXfa8WmvgdJMvN1GMzHhSgxuB7HmAMbG9GLL1qfZemY3D9YfIdhbg3vWO6zxG0iwNQY0WhSnnXiPi6a5a3n2yNdoPE4ONTYzO3Uk98f0psPewM7v7iZcoyPeP1wdA731QbL7T6HK10qxaSTtLgehXjehxXsB0Iy8G7pPwDc8BYCr08YTWZLBiD0PcRdwXcLllFVmEB0xFICLuqSSW1/CsoGzLlwbfU0BtNcxs3Qnb0VMpM7Wgv30xxg8DgjtgVJfyFxvE/vDBnK2vpLU4FimxKTizrGjAdxd+qOrzlVbv4O6wej7oLWKOkMTTfHdCTq6g6DGInXMdvIUuOorsDXA2ivVf/9WUDyGn7qByrPA61anLCvNhHsKofKkOnwhIvXfv0GFEEIIIf7DJJALITrN4wfXcqzmHF2sIUwJioA3hoLbTsS+9TgXbyBR78/hHU+xqLKGXvY6/qAPID8gkQ8n3skAjRs27SOoogpNRT5d0uczo9XFgIShMOBqKnwimJh4ETq9BRw2KM9CiRmCK7IvwyqyebjxKPlaX2ZqAmHcI+rc6C1VZMVPpP/pT7Ht+CPsex5PcxmV4QmEX7UdbdrlnPMa2NaaQ++gQBr04dzx4R1ss52gS/VxTNPfYHNYIENLyykuz6Wx7Bgrqoo5bumK1evm0fytuKrzyW6op5tbD9V/BmskXnMgVxzdTjM6Yv0ieDRzMwdrq3h5zLWYjIEM6nMnutwtND/fE7tGTxigQYMHDR/kHcTt9bBr8i2wfD0eSxj1/a8mxOynjp/e+hBmSwgzfQy4PR04FS1WZxPHTr1LRGh/tFoDV6eNV6uf/63+V8N3r+DvdaFFwelxsTT0Iv40YiHhR5arQwgqj/NCeC+a5j6j7g+o8qmloyWfwOjJ+L09Um29vrdInULs4pfwaSuko2wLPokzoDIHVkyBac9Dz0vU/V6/Rx1+AGoxttVzwGmDRZ//eMz3/lehsRhih0G/K9Wq9rGD/oN3rBBCCCHEz0sCuRCi01yfPpndpTkMD4yEr+8CRysY/dDYmzFufQx0BmKLMkiLmszIyCTuCulBUUsNq7xess58y0vhY/ldaCQDKo5haCrm6YheENWdDYWHuOfQRh4symTRkT+podDRAkNvQTfmAVg9hwWaDspbSnnO1A9vVS73nN0KGa8Rf24nWYYQSiMGElO4CadOT3ZCTxKzXydp0D3swESqn45gXQeNXhvDbOWUt9ZSYQzl0+KzPNu9P2uPfkw7GsL2tzFRMXIcAyW+XWD0dZwzh7Kh4BCBRgs3lnwGtnq8cz8kZM+HzKrOpMBvAmc8LqKqjsF3r4J/NCFps3CdfwJdWyXe789d7yGPkF64i8DwSmwpM4gwWUDRUODxMnPN/ay79H56KG52HfuCh4IHs6z5NNP8Y5gSMBRMfvTsPhmNRs+Woix6BkUTYPTF//veBAAEdIHbsnj1yFcoJae4rPswtIpCcPIkcLbBud2g0aIvyyTEZL2wWUjiXGy2MizGaIgZrI45/5v5vC2WeCxJ388zv+tptTW7+vRfA3lk778eg9sB5zPA41SL95kDfngDXf6e+sFAn/kIIYQQQvw3kkAuhOg0Y2PTGRubDrlfQ97XYAkDSwgExELqDNp3P8+LQf2Z0XiShcl9CA3py5GqApJ1Gt4sOMBhrR876ysZAKxyaPnqfCEvVLxIzMClvFe1k+paH/A4aXVradT6sMdr4bL40ZjiR0Pht7TG9WdmtwgqWqxguYEzDWUkddSxLnQwiUkToGwvDt8gkgpPUJA2iPryXJ4/8gVDQqN5/qLLmdRUx+jq3RjxcEfICHp0GwIpk0joeSklB1cw6sQekjRO0BjIcUNhcAprtj3L21Xf0ttRxwfJc+hqshCgC+D69kJGNmSztUTPF+bubG9u4J5tD4Oi5at2B3UVhUy2RBHRVg7pV6AEd0d5fTDD8HIscSwE9qbw2r3cuPFpLm8+g9llh7AECvpdQ23pWY5rLYxyNrN2zFJMUb2xGszsLD7O7d++S6AWmtzw8JC57K/I5abeU+kZHANF3/FQeCR3jFyCUavnw9O7OPXlHaTnrFbH9TcWq0HZ6/1+/DZotT74+n4/ZdjijT994e2tsOU+NbAv3QbR/X96PZ0RbtijtvT/fRgH6DJA/RJCCCGE+C8lgVwI0fmSJsG0F+DbJ/HU5lE99FIsjafIb2viy4hBZBqCWOi0MS8whHk77+N8xuPcam8iMaQvU8YtI6etiC9NUcS5QynxRpBUnEuHq5Wrw8fySmBvGr0afm87y6Gz+3DHDmXR2IeoCu7BVY1OEo+W8HLjfnbEz+b2tgYGR07kuUXvEnhsNXQ0YO1owBfI8myiT6+59A7tyuAuvQipLODO/CzCA/twXeMJ7vVRiEifpL4eRaGh60iqT2cSZA0hvKGYKp0P+RlvE6jVEe1uw8fjYmVzM2XtHpSNTzPCHMPysLHYw1K5ISSW0KJd0HcRRPbm4dPf0RHYl+ltR8FWA30XgkaD2zcMZ1stv9u7im3xQ8ltbaRU0VOpNRPXWAg7f8/VPS4mvuhbytw2/FvLUVZOhnvOgcFMWkgcg00KbQYjzc0dZFTkse18NrHWUHoajfDFDWhQsD5UxfbSHJ49/BmpBj2f6X1gyM2QOgOvotBuK8bHJwZF0f742rbXQ0U2xI+5ENopOwJHP4DiDLj1yD+/N4Lif8YbTQghhBDi10UCuRCi82m0MPAaaKvHlfkGgbtXoOlop5+9ladqM0hwNnNvQATZ2//MSw3lnPcJZ6S9mdk1h6GtiiWmZJo9CtdFp6GU1lLjpyNhwh+YWtdIkK2W1MojzKg/Rh+9P9qYNLCGYrfG0vb5o9gsEQRf8Tk5ZzNxFhewzxDCh3n7uHXIjRA7hIb9bxB48lNG2Ku4ct39dItMoU/NMVzfPcO3cVdg8+vBIWMYa4u30Hp+N7rooTjsbWzL38tD6Sm4dNGczanl4rLdDE5YwiSNFs/pZvKSZzCzx2xey96EFzCFpvCdzQEt9bxWsYVgv0i8l37E/vJc7vfrQZOtkYDerwNesDfDhlvRGCy4HO3cZoQNLw/m6aABTAmM4PeDpkJ7DeRuRNNazZiyQ7iskdi0RkxeD5rvg3GYjz8rQyNoqdgJqVfg7DWXfuEJTE8YDCZfGHUfGHxAZ2RwZDJzkkYwIjoFDM2w8Xdg9KU+KoKGhkMEBg4hOHjYj6/thlshdyNc9i6kz1GXdR0J016EiPRf7BYTQgghhPg1kkAuhOh8n9+gjiOe8iyGXU/gVRQ6FB23BY8kPqYPM3sM5Z6TBznvqGFR5GS+K/8S7bzV6lRoPS9lTk0lp9saqY8J44TuPPPi4zFGXcaLigaeS6TK1sIHwX2xJE3hMr0RgNiyA3xb/Ck+yjDIi+Ta4kO4e46lsK2JafED1Nbc6H7cYulB98ABnNEFcN7tpaYij0J7I+8HdOO5mAjuKK3inN7K2W79aWvax5NHd3Jn7hoa+k5nemQ4J5oL+dQBE+avxRHZA42rA21dIU+UV+A6vZ2t7cc52N5OU8NRKnximBWVTPD5fFx1Z3nn6EZOZbzNSL3CdQPnwmdL1Z4E53ZD1vso0QPwvfkwk18bgE/LOb42x9ASnUZg6iXgcoCrQ51CrPE8b5zNYnXJKVKDutD12Dc8NHgOiqKgjH0Iv4YFrKoswpGfwbV/aeUHGHP/hW+tBjOPDV+g/lA+AMqyIKQ7JpMVvT4Qkynyp69t/GhoKIKIXn9dptHAwKU/7z0khBBCCPFfSPF6vd7/ebWfV3NzM/7+/jQ1NeHn5/dL714I8WvzUi9oLoUbM+Dgm3D0YzJ1VhZGTqRPaDyfXLyM6vZGrt/2Br6V2ayq+AbNJa/ykU8cL2dtYFJcX9bl70ev0eJ0u9iWPpyYpHHgF0XD3pfI2f8OI8YuI+PY53xh93LXZc8QbvTB/vGd6PtORZP5JtQX0K7ouKvbbBZddA3DtB4WnNjDsepzROOh0WWnXaPnvkGz+eJcJidqzzM2Jo1J2lYiD/yZ9jGz6RISwqtnqmg8fxaj0cik+C4MtcaTFzqMl7M2cK6pkhhrKF8GW7go/ySRHifry7+iSmtmXPR0XIqGVZXbGRwSyxJtF/ZjZk/Z54S5O2gOScavNg/mfQIJ43AdeIMnqio4ovVlmh7m+Fpo77uQEJ9AjDr9j05xTu15VuRsY0tRFgAH57+A1WAGwOZy0PeD3wGwf96zBP1NkTYh/pa8fwshhBA/L2khF0J0vqXfgK0RwnrAJa9A4gQGNBTxQbeJdK0/QnveOsKSL+fz6Q/AlgfAfpbaLoN5cvOfcHs9KI0lJHgdDI7uwzBXEzEbb8Fm8KPBGsWzSfPZEjaaZ4NS2azdzbc+PnByFxdrRlO9fg1RJ84y7OH+eFdMxsdtp099Dg1rl0D7ecriF+HyevAJ6oLW7eLlIVcw1KBjlLOW+e2NJAZGM91TB/ZqzhbkkWNJ4lBDCY2mMG4L8OfyXW9yPm0ufVMXUtxcg8vjxuF2oh15B18lnuSxvAxu1mkodLmJMGiYHeFLeqMCfeYR0+qiT95OvvNPIiy4G7mhvSnyfsMEcxQX6Qy0DLiGdWvux+Vp5iVg5JAHSPEL+4enOC0kjhdHX8Pl5afxerkQxgHMOgPPjFyMw+OUMC6EEEII8QuSFnIhxK+Wx95EYdE7oCh0aw1Fm7kS58RHaAvwR2tOYuHmlzDpDHzsLkZz9AOY8Bj7A3ti/PImejrq0Xs9XB6/gCK09AjqwqDwRBwuB6tydxPbEMnir5fhjviWgc93p73qBKUZy3nOFMPVziqubD1L/fQ32WxzMD1xMAHfTwnmfbUPSv05nup9E0sm3YvB6+WP783noCmc7Yvf4WxDOZ/k7mH92QxS7PVoo3qz9tIHKG+tx+VxE+4TgC3zdQ635bDb5sO6Gidd/cKYEq5nWoQPGnN34qMvweF2YWivo8zp4LOibGptzaw7s4+3Ogq4aMFK8Isiv6GcMw1lOD1uZlTsx5X9AZVj7yQ6ZSHKXwqoCfEzkvdvIYQQ4uclLeRCiF8tjdEf/1YXXsWLpnAPlGfRnvsxtYnJhIXp+HLGQwAcLjrMAaeJ+enz8bfbmBc5iZ62Ksb6B1PhNaHxuDhWcw6Xx83HY6/BgZeS4iM8MXcZAbTyxs5QGuytpOmC2V30MYfHPkFZn7eJ8wvjqr85nsbGo7i7xFLq8rC+vppZX99H9JlNBPRcxJLE0Zh1BnqFdiXKN4jMqrN4gmL4/dB5eL1eHG4XdreTovIc/A+/jTN1KCM11VRZrURFJrO07wQaGg8TFjSQB/a9z6bCTD6etox1Z/axOncP16RN5JAzD9+qI9BSAX5RdA9UvwDIeAZdXSGVp1bjGzOcAD+pTi6EEEII8WsngVwI8atzoqaI+/auYkmvCczqfz8c/xRynoEeF6Mbdge+7Wfx8ekKwN6yU9ywayVur4faE9u4PXUcGfOew6IzgFZH8+H1ZJSfZn7P0Uw4uwHD84k8Mud9vHOeI7e+lNeyN9FkbyOz6iw5Wgt7TJHcUnAK5dwfuav/dBYHhUDG63DRMnRmC3W9x6Ed3I8HbXrc2+7H4mimpOIksy+6UT34hiKCTf58c/ljANhdTq7Z+ie+Kz8NgF7RsNs3nl6nsjidkMIMs5Gpe+5H6SjEd+xD1LQ3caSqAKfbhcPtZG6Pi3C4XVyeNBzflJHQXAaRvX980mYtp+r0Gnys/vj5xv4Sl0kIIYQQQvybJJALIX51TtWXUNBUyeHKfJICorjm2F4WBKRzW3Q/LH49sPj1uLDu3gOrcHs9+Go0TAoIZey6hwjWgF9QN1JDYjldX8qp+lLePv4N0wMsgAKKFkVR6Bkcw+vjbuBodSGLt7yE1wtBcz+iV85OjtYU8tzh9VwVYkQ5sRYCYvAd93tWFxbyTsZ6jFo9Nw5dxj2HVlPjG0G8fwTUFcDrgyA4EW4+CMCavL1qGPd6QVHwV7wM88Yys/cVHCw9xu2h0Szy788lDUUMKfuWJ0+d5HxzNQDdA6Ow6E08PmLRX0+OJeSnT5pPEOH9byT8P3VRhBBCCCHEz04CuRDiV2d20nBirCGkh3bjcGU+TS4n53tfBSOv+dG6t2ma6VuzjzFTH+OB7TXotMG4vHCaUtpddt4YfyMzv3ySkpYaxrn92XV/MRrj92NfC3aC3kLf2MGkBMdytLqQHFsLDfZWNCgkBEahXHQ1+EdB/6sB+CL/AK3ODlqdHZgtAXx13YcA1He0sK/iNCPM/mgCY/lLnfMRXVIYUpJMpNfJmNYiSuNG8uzJ3aQGx/LUyCt59/g3ZJbk0+50k3HwI/yDhxHuE8D4uN5Y9KZf4nQLIYQQQohOIkXdhBC/eoVNlURbgjHq9GRW5vPs4fXc1u8SRkSnqPNtN56n1hLOdc98zNzdS2F8Gek3agkyWQnz8Se7upC5m54D4NvZTxDpG4SjqQz3y+mYNVqWT1/Fp/kHKGqupqtfGGWtdTg9bvqFJbB62t0/OJaS5hrePfENyUExzO9x0YXiabfueJttxdnMC3YyNWEIvXtchUGrxvJTdSVcteUlZicN556Bs6izNRNsVv/2dbgcbM3bzdNHN1LvdADwh6Hzmdtj5C91eoX4l8n7txBCCPHzkhZyIcSvXrx/xIXv91fkcry2iH1lp+gd2o2DFXmMiulFiEbLogXpGGeeZEp6+g+qjPcJi+fVMddiczmI9A0CYMaOd6mLm8P1viY2FR2lqLkaBYWi5moifALpFRrHC6OWAnDf3lUUNFawfOJtxPiF8tjwhT86xrSQOLKqzxIdHM0tR47gPnqSD6feRbhPAGUtdbQ4bJS11gNcCOMAJpeNSzcsodUcx1vhw0kKimRkl5T/yHkUQgghhBC/LhLIhRD/Va7rNYmkgChGdknlmUOfsfbMPu4ZOIslaeOZ2X3oP9xuYtd+P/hZQcGm6Hi2pYObevfid30v5WxjOTm1xWwpOoK1yYxBq/6JPFR5hsq2BhrsrfgZfX7y+U/VFVPX0cqhNh1tHg0udwf7Sk/xzoktGLV6Ns98hCjfYD7O3c1zhz/nhdFLGRPTC7QG8ItiUFstp8y1DNPXoO8oA9/gn++kCSGEEEKIXyUJ5EKI/yomnYHJ3foDMCI6hZN1xQwIT/xfP88XMx5iT0kOn+XvZ3riYOL8whgVkwbALY3TCDJZL6y7eurdNNnbiPMLw+lx8/zh9cT7+nJZ0kXo9er85H9pefc1mNhzxVO8c2Irq07uRKtoCDJZifMPQ6NoKG+tp91lp6qtQX1yvRluPoirvpT++WtQ2nPRavUIIYQQQoj/+2QMuRBC/C+crithyaYnuD/agZ9POKOHPsWe0hyCTH6caShjTEwvAk2+vJD5Be+e+AYF2DLrUeL8wgBwezwUNVeREBAJQG39adweO+EhfQDweFxoNPJZqfh1kvdvIYQQ4ucl/+sTQoj/gcfrQaNoANAoCh0Y2Nik49qQcFaf3s1jBz4hyjeInbOfuLDNrX0vJre+9MK84l18Q9BqNGg1GhICInnt6EY+OLWDRyJbAC/jRryI0eAvYVwIIYQQ4jdE09kHIIQQv2Z37V7OoI/u4lxTFQAN9jY63C70/mkM7H07K0/uAKBnYMwPtjNodbw78RaCzVYe2Pc+W4qOXHjso9O72FKURZOjA01AX2KjR2PQWxFCCCGEEL8t0hQjhBD/RENHGx0uBzaXOiXZkMhkvpn1KGE+/gAMjkymuKUGrUb5ye2nxg/A7fXQOzT+wrIXj3xJm7ODt8fffGHcuhBCCCGE+O2RMeRCCPFPONxOmuzthH4fwP9ecXMNTx9axxXJI//lcL2nNIeKtgauSJa5xsV/F3n/FkIIIX5eEsiFEEII8S+R928hhBDi5yVjyIUQQgghhBBCiE4ggVwIIYQQQgghhOgEEsiFEEIIIYQQQohOIIFcCCGEEEIIIYToBBLIhRBCCCGEEEKITiCBXAghhBBCCCGE6AQSyIUQQgghhBBCiE4ggVwIIYQQQgghhOgEEsiFEEIIIYQQQohOIIFcCCGEEEIIIYToBBLIhRBCCCGEEEKITiCBXAghhBBCCCGE6AQSyIUQQgghhBBCiE6g64yder1eAJqbmztj90IIIYT4//CX9+2/vI8LIYQQ4t/TKYG8paUFgJiYmM7YvRBCCCH+DS0tLfj7+3f2YQghhBD/9RRvJ3zM7fF4KC8vx2q1oijKL717IYQQQvx/8Hq9tLS0EBUVhUYjo96EEEKIf1enBHIhhBBCCCGEEOK3Tj7eFkIIIYQQQgghOoEEciGEEEIIIYQQohNIIBdCCCGEEEIIITqBBHIhhBBCCCGEEKITSCAX4jdo9OjR3H777T9a/sUXX1yY+WDlypUoikLPnj1/tN7atWtRFIWuXbv+6DGbzUZgYCBBQUHYbLYfPd61a1cURUFRFHx8fEhLS+Ptt9++8HhFRQXz588nOTkZjUbzk8cphBBCCCHE/wUSyIUQ/5DFYqG6upqMjIwfLF+xYgWxsbE/uc1nn31GWloaKSkprF+//ifXeeyxx6ioqOD48ePMmDGDG264gTVr1gBgt9sJDQ3lwQcfpHfv3j/vCxJCCCGEEOJXRAK5EOIf0ul0zJ8/nxUrVlxYVlpayq5du5g/f/5PbrN8+XIWLlzIwoULWb58+U+uY7VaiYiIIDExkccff5zu3bvzxRdfAGoL+iuvvMKVV16Jv7//z/6ahBBCCCGE+LWQQC6E+KeWLl3KmjVraG9vB9Su7JMnTyY8PPxH6xYUFJCRkcGcOXOYM2cO+/fvp7Cw8H/ch8lkwul0/uzHLoQQQgghxK+ZBHIhxD/Vp08fEhISWLduHV6vl5UrV7JkyZKfXHfFihVMmTLlwhjyyZMn/6B1/e+5XC5WrlzJiRMnGDdu3H/qJQghhBBCCPGrJIFcCPE/WrJkCe+99x67d++mtbWVqVOn/mgdt9vNqlWrWLhw4YVlCxcuZNWqVbjd7h+se++99+Lr64vZbObmm29m2bJlXH/99f/x1yGEEEIIIcSvia6zD0AI8cvz8/OjqanpR8sbGxvx8/P70fIFCxZwzz338Ic//IErr7wSne7Hfzq++eYbysrKuOKKK36w3O12s3XrVqZMmXJh2bJly1i8eDE+Pj5ERkZeqOwuhBBCCCHEb4m0kAvxG9SjRw8yMzN/tPzw4cMkJyf/aHlQUBCXXnopu3fv/ofd1ZcvX87cuXPJzs7+wdeCBQt+VNwtJCSExMREoqKiJIwLIYQQQojfLGkhF+I36KabbuK1117j5ptv5rrrrsNsNrNt2zaWL1/OBx988JPbrFy5kjfeeIPg4OAfPVZTU8NXX33Fhg0bSEtL+8FjV111FdOmTaOmpobQ0NB/6fiys7MBaG1tpaamhuzsbAwGAykpKf+7FyqEEEIIIcSvmARyIX6Dunbtyt69e3nwwQeZOHEiHR0dJCUlsXLlSmbPnv2T25jNZsxm808+9v7772OxWH6yMNuYMWOwWq188MEH3Hnnnf/S8fXt2/fC90eOHGH16tXExcVRVFT0L20vhBBCCCHEfwPF6/V6O/sghBBCCCGEEEKI3xoZQy6EEEIIIYQQQnQCCeRCCCGEEEIIIUQnkEAuhBBCCCGEEEJ0AgnkQgghhBBCCCFEJ5BALoQQQgghhBBCdAIJ5EIIIYQQQgghRCeQQC6EEEIIIYQQQnQCCeRCCCGEEEIIIUQnkEAuhBBCCCGEEEJ0AgnkQgghhBBCCCFEJ5BALoQQQgghhBBCdAIJ5EIIIYQQQgghRCf4f0TxDSaZxO2bAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pl.umap(test_data, color=[\"level2\"], size=10, ncols=1, title=\"ADT latent by UMAP\")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:1217: FutureWarning: The default value of 'ignore' for the `na_action` parameter in pandas.Categorical.map is deprecated and will be changed to 'None' in a future version. Please set na_action to the desired value to avoid seeing this warning\n", + " color_vector = pd.Categorical(values.map(color_map))\n", + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:392: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n", + " cax = scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pp.neighbors(\n", + " test_data, use_rep=\"latent_embedding_gex\", n_neighbors=15\n", + ") # use_rep specifies that the calculation is based on the latent embedding\n", + "sc.tl.umap(test_data, random_state=1) # set random state to ensure reproducibility\n", + "sc.pl.umap(test_data, color=[\"cell_type\"], size=10, ncols=1, title=\"GEX latent by UMAP\")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:1217: FutureWarning: The default value of 'ignore' for the `na_action` parameter in pandas.Categorical.map is deprecated and will be changed to 'None' in a future version. Please set na_action to the desired value to avoid seeing this warning\n", + " color_vector = pd.Categorical(values.map(color_map))\n", + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:392: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n", + " cax = scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pl.umap(test_data, color=[\"level1\"], size=10, ncols=1, title=\"GEX latent by UMAP\")" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:1217: FutureWarning: The default value of 'ignore' for the `na_action` parameter in pandas.Categorical.map is deprecated and will be changed to 'None' in a future version. Please set na_action to the desired value to avoid seeing this warning\n", + " color_vector = pd.Categorical(values.map(color_map))\n", + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:392: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n", + " cax = scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pl.umap(test_data, color=[\"level2\"], size=10, ncols=1, title=\"GEX latent by UMAP\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### PCA" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import scanpy as sc\n", + "from sklearn.decomposition import PCA\n", + "\n", + "# Extract the latent embedding\n", + "latent_embedding = test_data.obsm[\"latent_embedding_adt\"]\n", + "\n", + "# Perform PCA on the latent embedding\n", + "pca = PCA(n_components=10)\n", + "latent_pca = pca.fit_transform(latent_embedding)\n", + "\n", + "# Store the PCA results back in the AnnData object\n", + "test_data.obsm[\"X_pca_latent\"] = latent_pca\n", + "test_data.uns[\"pca_latent_variance_ratio\"] = pca.explained_variance_ratio_\n", + "\n", + "# Create a new AnnData object for visualization purposes\n", + "pca_anndata = sc.AnnData(X=latent_pca)\n", + "pca_anndata.obs = test_data.obs\n", + "pca_anndata.var_names = [f\"PC{i+1}\" for i in range(latent_pca.shape[1])]\n", + "\n", + "# Visualize the PCA results\n", + "sc.pl.scatter(pca_anndata, x=\"PC1\", y=\"PC2\", color=\"level1\", title=\"ADT latent by PCA\")" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import scanpy as sc\n", + "from sklearn.decomposition import PCA\n", + "\n", + "# Extract the latent embedding\n", + "latent_embedding = test_data.obsm[\"latent_embedding_gex\"]\n", + "\n", + "# Perform PCA on the latent embedding\n", + "pca = PCA(n_components=2)\n", + "latent_pca = pca.fit_transform(latent_embedding)\n", + "\n", + "# Store the PCA results back in the AnnData object\n", + "test_data.obsm[\"X_pca_latent_gex\"] = latent_pca\n", + "test_data.uns[\"pca_latent_variance_ratio_gex\"] = pca.explained_variance_ratio_\n", + "\n", + "# Create a new AnnData object for visualization purposes\n", + "pca_anndata = sc.AnnData(X=latent_pca)\n", + "pca_anndata.obs = test_data.obs\n", + "pca_anndata.var_names = [f\"PC{i+1}\" for i in range(latent_pca.shape[1])]\n", + "\n", + "# Visualize the PCA results\n", + "sc.pl.scatter(pca_anndata, x=\"PC1\", y=\"PC2\", color=\"level1\", title=\"GEX latent by PCA\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compute metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [], + "source": [ + "LABELS_COLUMN = \"level1\"\n", + "X = test_data.obsm[\"latent_embedding_gex\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 Natural Killer Cells\n", + "1 Natural Killer Cells\n", + "2 T Cells\n", + "3 Natural Killer Cells\n", + "4 Hematopoietic Stem Cells and Progenitors\n", + " ... \n", + "15061 B Cells and Plasma Cells\n", + "15062 T Cells\n", + "15063 T Cells\n", + "15064 T Cells\n", + "15065 T Cells\n", + "Name: level1, Length: 15066, dtype: object" + ] + }, + "execution_count": 109, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_data.obs[LABELS_COLUMN]" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([15066, 16])" + ] + }, + "execution_count": 111, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.005011777" + ] + }, + "execution_count": 110, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sklearn.metrics.silhouette_score(X, labels=test_data.obs[LABELS_COLUMN])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.cm as cm\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from sklearn.cluster import KMeans\n", + "from sklearn.datasets import make_blobs\n", + "from sklearn.metrics import silhouette_samples, silhouette_score\n", + "\n", + "# Generating the sample data from make_blobs\n", + "# This particular setting has one distinct cluster and 3 clusters placed close\n", + "# together.\n", + "X, y = make_blobs(\n", + " n_samples=500,\n", + " n_features=2,\n", + " centers=4,\n", + " cluster_std=1,\n", + " center_box=(-10.0, 10.0),\n", + " shuffle=True,\n", + " random_state=1,\n", + ") # For reproducibility\n", + "\n", + "range_n_clusters = [2, 3, 4, 5, 6]\n", + "\n", + "for n_clusters in range_n_clusters:\n", + " # Create a subplot with 1 row and 2 columns\n", + " fig, (ax1, ax2) = plt.subplots(1, 2)\n", + " fig.set_size_inches(18, 7)\n", + "\n", + " # The 1st subplot is the silhouette plot\n", + " # The silhouette coefficient can range from -1, 1 but in this example all\n", + " # lie within [-0.1, 1]\n", + " ax1.set_xlim([-0.1, 1])\n", + " # The (n_clusters+1)*10 is for inserting blank space between silhouette\n", + " # plots of individual clusters, to demarcate them clearly.\n", + " ax1.set_ylim([0, len(X) + (n_clusters + 1) * 10])\n", + "\n", + " # Initialize the clusterer with n_clusters value and a random generator\n", + " # seed of 10 for reproducibility.\n", + " clusterer = KMeans(n_clusters=n_clusters, random_state=10)\n", + " cluster_labels = clusterer.fit_predict(X)\n", + "\n", + " # The silhouette_score gives the average value for all the samples.\n", + " # This gives a perspective into the density and separation of the formed\n", + " # clusters\n", + " silhouette_avg = silhouette_score(X, cluster_labels)\n", + " print(\n", + " \"For n_clusters =\",\n", + " n_clusters,\n", + " \"The average silhouette_score is :\",\n", + " silhouette_avg,\n", + " )\n", + "\n", + " # Compute the silhouette scores for each sample\n", + " sample_silhouette_values = silhouette_samples(X, cluster_labels)\n", + "\n", + " y_lower = 10\n", + " for i in range(n_clusters):\n", + " # Aggregate the silhouette scores for samples belonging to\n", + " # cluster i, and sort them\n", + " ith_cluster_silhouette_values = sample_silhouette_values[cluster_labels == i]\n", + "\n", + " ith_cluster_silhouette_values.sort()\n", + "\n", + " size_cluster_i = ith_cluster_silhouette_values.shape[0]\n", + " y_upper = y_lower + size_cluster_i\n", + "\n", + " color = cm.nipy_spectral(float(i) / n_clusters)\n", + " ax1.fill_betweenx(\n", + " np.arange(y_lower, y_upper),\n", + " 0,\n", + " ith_cluster_silhouette_values,\n", + " facecolor=color,\n", + " edgecolor=color,\n", + " alpha=0.7,\n", + " )\n", + "\n", + " # Label the silhouette plots with their cluster numbers at the middle\n", + " ax1.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))\n", + "\n", + " # Compute the new y_lower for next plot\n", + " y_lower = y_upper + 10 # 10 for the 0 samples\n", + "\n", + " ax1.set_title(\"The silhouette plot for the various clusters.\")\n", + " ax1.set_xlabel(\"The silhouette coefficient values\")\n", + " ax1.set_ylabel(\"Cluster label\")\n", + "\n", + " # The vertical line for average silhouette score of all the values\n", + " ax1.axvline(x=silhouette_avg, color=\"red\", linestyle=\"--\")\n", + "\n", + " ax1.set_yticks([]) # Clear the yaxis labels / ticks\n", + " ax1.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])\n", + "\n", + " # 2nd Plot showing the actual clusters formed\n", + " colors = cm.nipy_spectral(cluster_labels.astype(float) / n_clusters)\n", + " ax2.scatter(\n", + " X[:, 0], X[:, 1], marker=\".\", s=30, lw=0, alpha=0.7, c=colors, edgecolor=\"k\"\n", + " )\n", + "\n", + " # Labeling the clusters\n", + " centers = clusterer.cluster_centers_\n", + " # Draw white circles at cluster centers\n", + " ax2.scatter(\n", + " centers[:, 0],\n", + " centers[:, 1],\n", + " marker=\"o\",\n", + " c=\"white\",\n", + " alpha=1,\n", + " s=200,\n", + " edgecolor=\"k\",\n", + " )\n", + "\n", + " for i, c in enumerate(centers):\n", + " ax2.scatter(c[0], c[1], marker=\"$%d$\" % i, alpha=1, s=50, edgecolor=\"k\")\n", + "\n", + " ax2.set_title(\"The visualization of the clustered data.\")\n", + " ax2.set_xlabel(\"Feature space for the 1st feature\")\n", + " ax2.set_ylabel(\"Feature space for the 2nd feature\")\n", + "\n", + " plt.suptitle(\n", + " \"Silhouette analysis for KMeans clustering on sample data with n_clusters = %d\"\n", + " % n_clusters,\n", + " fontsize=14,\n", + " fontweight=\"bold\",\n", + " )\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Downstream task" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "test_data.obsm[\"latent_embedding_gex\"] = np.random.randn(15066, 16)" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [], + "source": [ + "LATENT_DIM = 16\n", + "DATA = test_data\n", + "LEVEL = \"level1\"\n", + "LATENT_NAME = \"latent_embedding_gex\"\n", + "HIDDEN_DIM = 16 * 4" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [], + "source": [ + "# Extract the labels (cell types)\n", + "labels = DATA.obs[LEVEL].values\n", + "\n", + "# Encode labels to integers\n", + "label_encoder = LabelEncoder()\n", + "labels_encoded = label_encoder.fit_transform(labels)\n", + "\n", + "# Convert to PyTorch tensors\n", + "X = torch.tensor(DATA.obsm[LATENT_NAME], dtype=torch.float32)\n", + "y = torch.tensor(labels_encoded, dtype=torch.long)\n", + "\n", + "# Split the data into training and testing sets\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y, test_size=0.2, random_state=42\n", + ")\n", + "\n", + "# Create DataLoader for training and testing sets\n", + "train_dataset = TensorDataset(X_train, y_train)\n", + "test_dataset = TensorDataset(X_test, y_test)\n", + "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n", + "test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [], + "source": [ + "from models.building_blocks import Block\n", + "\n", + "\n", + "class ClassificationModel(pl.LightningModule):\n", + " def __init__(self, latent_dim, num_classes, hidden_dim, do_batch_norm=False):\n", + " super().__init__()\n", + " self.layers = nn.Sequential(\n", + " nn.Linear(latent_dim, hidden_dim),\n", + " nn.BatchNorm1d(hidden_dim) if do_batch_norm else nn.Identity(),\n", + " nn.SiLU(),\n", + " nn.Linear(hidden_dim, num_classes),\n", + " )\n", + " self.loss = nn.CrossEntropyLoss() # Adjust\n", + "\n", + " def forward(self, z):\n", + " return self.layers(z)\n", + "\n", + " def training_step(self, batch, batch_idx):\n", + " x, y = batch\n", + " y_hat = self.forward(x)\n", + " loss = self.loss(y_hat, y)\n", + " self.log(\n", + " \"train_loss\", loss, on_step=True, on_epoch=True, prog_bar=True, logger=True\n", + " )\n", + " return loss\n", + "\n", + " def validation_step(self, batch, batch_idx):\n", + " x, y = batch\n", + " y_hat = self.forward(x)\n", + " loss = self.loss(y_hat, y)\n", + " self.log(\n", + " \"val_loss\", loss, on_step=False, on_epoch=True, prog_bar=True, logger=True\n", + " )\n", + "\n", + " return loss\n", + "\n", + " def configure_optimizers(self):\n", + " # Define optimizer here\n", + " optimizer = torch.optim.Adam(\n", + " self.parameters(), lr=0.001\n", + " ) # Adjust learning rate\n", + " return optimizer" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: False, used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "--------------------------------------------\n", + "0 | layers | Sequential | 1.5 K \n", + "1 | loss | CrossEntropyLoss | 0 \n", + "--------------------------------------------\n", + "1.5 K Trainable params\n", + "0 Non-trainable params\n", + "1.5 K Total params\n", + "0.006 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "08f06514c2df4898aea94c4f7213889e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | | 0/? [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GEX_n_genes_by_countsGEX_pct_counts_mtGEX_size_factorsGEX_phaseADT_n_antibodies_by_countsADT_total_countsADT_iso_countcell_typebatchADT_pseudotime_order...DonorRaceEthnicityDonorGenderQCMedsDonorSmokeris_trainlevel1level2level3description
036324.4704902.311520G2M1354152.024.0NKs4d1NaN...WhiteHISPANIC OR LATINOMaleFalseNonsmokertestNatural Killer CellsNKNKNatural Killer Cells
117818.8433790.789157G2M1386323.030.0NKs4d1NaN...WhiteHISPANIC OR LATINOMaleFalseNonsmokertestNatural Killer CellsNKNKNatural Killer Cells
213914.8913040.556811G11375038.048.0CD8+ T CD69+ CD45RA+s4d1NaN...WhiteHISPANIC OR LATINOMaleFalseNonsmokertestT CellsCD8+ T CellsCD8+ T CD69+ CD45RA+CD8+ T Cells expressing CD69 and CD45RA
317897.4125870.733487G2M1343586.026.0NK CD158e1+s4d1NaN...WhiteHISPANIC OR LATINOMaleFalseNonsmokertestNatural Killer CellsNK CD158e1+NK CD158e1+Natural Killer Cells expressing CD158e1
436443.9353152.522098G11342841.032.0HSCs4d10.352826...WhiteHISPANIC OR LATINOMaleFalseNonsmokertestHematopoietic Stem Cells and ProgenitorsHSCHSCHematopoietic Stem Cells
..................................................................
1506118558.7798920.702011G2M1242093.012.0Naive CD20+ B IGKC-s4d9NaN...Other RaceHISPANIC OR LATINOMaleFalseNonsmokertestB Cells and Plasma CellsNaive B CellsNaive CD20+ B IGKC-Naive B Cells expressing CD20, not IGKC
1506214844.9743690.508755S1242695.014.0CD8+ T naives4d9NaN...Other RaceHISPANIC OR LATINOMaleFalseNonsmokertestT CellsCD8+ T CellsCD8+ T naiveNaive CD8+ T Cells
150638018.8424430.232119G11323590.014.0T regs4d9NaN...Other RaceHISPANIC OR LATINOMaleFalseNonsmokertestT CellsSpecial T Cell TypesT regRegulatory T Cells
1506416308.5006110.549119G11335432.017.0CD4+ T naives4d9NaN...Other RaceHISPANIC OR LATINOMaleFalseNonsmokertestT CellsCD4+ T CellsCD4+ T naiveNaive CD4+ T Cells
1506517467.0742210.661751G2M1372665.010.0CD8+ T naives4d9NaN...Other RaceHISPANIC OR LATINOMaleFalseNonsmokertestT CellsCD8+ T CellsCD8+ T naiveNaive CD8+ T Cells
\n", + "

15066 rows × 30 columns

\n", + "" + ], + "text/plain": [ + " GEX_n_genes_by_counts GEX_pct_counts_mt GEX_size_factors GEX_phase \\\n", + "0 3632 4.470490 2.311520 G2M \n", + "1 1781 8.843379 0.789157 G2M \n", + "2 1391 4.891304 0.556811 G1 \n", + "3 1789 7.412587 0.733487 G2M \n", + "4 3644 3.935315 2.522098 G1 \n", + "... ... ... ... ... \n", + "15061 1855 8.779892 0.702011 G2M \n", + "15062 1484 4.974369 0.508755 S \n", + "15063 801 8.842443 0.232119 G1 \n", + "15064 1630 8.500611 0.549119 G1 \n", + "15065 1746 7.074221 0.661751 G2M \n", + "\n", + " ADT_n_antibodies_by_counts ADT_total_counts ADT_iso_count \\\n", + "0 135 4152.0 24.0 \n", + "1 138 6323.0 30.0 \n", + "2 137 5038.0 48.0 \n", + "3 134 3586.0 26.0 \n", + "4 134 2841.0 32.0 \n", + "... ... ... ... \n", + "15061 124 2093.0 12.0 \n", + "15062 124 2695.0 14.0 \n", + "15063 132 3590.0 14.0 \n", + "15064 133 5432.0 17.0 \n", + "15065 137 2665.0 10.0 \n", + "\n", + " cell_type batch ADT_pseudotime_order ... DonorRace \\\n", + "0 NK s4d1 NaN ... White \n", + "1 NK s4d1 NaN ... White \n", + "2 CD8+ T CD69+ CD45RA+ s4d1 NaN ... White \n", + "3 NK CD158e1+ s4d1 NaN ... White \n", + "4 HSC s4d1 0.352826 ... White \n", + "... ... ... ... ... ... \n", + "15061 Naive CD20+ B IGKC- s4d9 NaN ... Other Race \n", + "15062 CD8+ T naive s4d9 NaN ... Other Race \n", + "15063 T reg s4d9 NaN ... Other Race \n", + "15064 CD4+ T naive s4d9 NaN ... Other Race \n", + "15065 CD8+ T naive s4d9 NaN ... Other Race \n", + "\n", + " Ethnicity DonorGender QCMeds DonorSmoker is_train \\\n", + "0 HISPANIC OR LATINO Male False Nonsmoker test \n", + "1 HISPANIC OR LATINO Male False Nonsmoker test \n", + "2 HISPANIC OR LATINO Male False Nonsmoker test \n", + "3 HISPANIC OR LATINO Male False Nonsmoker test \n", + "4 HISPANIC OR LATINO Male False Nonsmoker test \n", + "... ... ... ... ... ... \n", + "15061 HISPANIC OR LATINO Male False Nonsmoker test \n", + "15062 HISPANIC OR LATINO Male False Nonsmoker test \n", + "15063 HISPANIC OR LATINO Male False Nonsmoker test \n", + "15064 HISPANIC OR LATINO Male False Nonsmoker test \n", + "15065 HISPANIC OR LATINO Male False Nonsmoker test \n", + "\n", + " level1 level2 \\\n", + "0 Natural Killer Cells NK \n", + "1 Natural Killer Cells NK \n", + "2 T Cells CD8+ T Cells \n", + "3 Natural Killer Cells NK CD158e1+ \n", + "4 Hematopoietic Stem Cells and Progenitors HSC \n", + "... ... ... \n", + "15061 B Cells and Plasma Cells Naive B Cells \n", + "15062 T Cells CD8+ T Cells \n", + "15063 T Cells Special T Cell Types \n", + "15064 T Cells CD4+ T Cells \n", + "15065 T Cells CD8+ T Cells \n", + "\n", + " level3 description \n", + "0 NK Natural Killer Cells \n", + "1 NK Natural Killer Cells \n", + "2 CD8+ T CD69+ CD45RA+ CD8+ T Cells expressing CD69 and CD45RA \n", + "3 NK CD158e1+ Natural Killer Cells expressing CD158e1 \n", + "4 HSC Hematopoietic Stem Cells \n", + "... ... ... \n", + "15061 Naive CD20+ B IGKC- Naive B Cells expressing CD20, not IGKC \n", + "15062 CD8+ T naive Naive CD8+ T Cells \n", + "15063 T reg Regulatory T Cells \n", + "15064 CD4+ T naive Naive CD4+ T Cells \n", + "15065 CD8+ T naive Naive CD8+ T Cells \n", + "\n", + "[15066 rows x 30 columns]" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_data.obs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load Latent" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "LATENT_NAME = \"latent_omiae\"\n", + "DATA_PATH = \"../data/latent/latent_omiae_test\"" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "LATENT_NAME = \"omivae_latent\"\n", + "DATA_PATH = \"../data/latent/omivae_2024-06-15_14-02-51/latent_test.zip\"" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "LATENT_NAME = \"babel_latent_adt\"\n", + "DATA_PATH = \"../data/latent/adam_babel/adam_babel_latent_test_adt\"" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "LATENT_NAME = \"babel_latent_gex\"\n", + "DATA_PATH = \"../data/latent/adam_babel/adam_babel_latent_test_gex\"" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "LATENT_NAME = \"latent_omiae\"\n", + "DATA_PATH = \"../data/latent/omiae_simple_2024-06-15_10-32-21/latent_omiae_test.zip\"" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "test_data.obsm[LATENT_NAME] = torch.load(DATA_PATH)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize latent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### UMAP" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "# UMAP representation of latent embedding\n", + "# Clustering by all call_types\n", + "import scanpy as sc\n", + "from sklearn.metrics import silhouette_score, davies_bouldin_score\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Input: AnnData Object, 'embedding name', n_neighnors\n", + "# Silhouttte Score: Ranges from -1 to 1, higher values indicate better cluster separation\n", + "# Davies-Bouldine-Index: A low index indicates that clusters are well separates\n", + "\n", + "def umap_and_scores(adata, embedding_key, n_neighbors=20, label_columns=[\"cell_type\"]):\n", + " sc.pp.neighbors(adata, n_neighbors=n_neighbors, use_rep=embedding_key)\n", + " sc.tl.umap(adata)\n", + "\n", + " for label_column in label_columns:\n", + " plot_title = f'UMAP Plot using {embedding_key}'\n", + " sc.pl.umap(adata, color=label_column, size=20, ncols=1, title=plot_title)\n", + " plt.show()\n", + "\n", + " umap_coords = adata.obsm['X_umap']\n", + " labels = adata.obs[label_column]\n", + "\n", + " sil_score = silhouette_score(umap_coords, labels)\n", + " print(f'Silhouette-Score for {embedding_key}: {sil_score}')\n", + "\n", + " db_score = davies_bouldin_score(umap_coords, labels)\n", + " print(f'Davies-Bouldin-Index for {embedding_key}: {db_score}')\n", + "\n", + "# Example\n", + "# umap_and_scores(adata, 'latent_embedding_combined_3', n_neighbors=30)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:1217: FutureWarning: The default value of 'ignore' for the `na_action` parameter in pandas.Categorical.map is deprecated and will be changed to 'None' in a future version. Please set na_action to the desired value to avoid seeing this warning\n", + " color_vector = pd.Categorical(values.map(color_map))\n", + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:392: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n", + " cax = scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Silhouette-Score for latent_omiae: 0.30979830026626587\n", + "Davies-Bouldin-Index for latent_omiae: 1.3509016191526253\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:1217: FutureWarning: The default value of 'ignore' for the `na_action` parameter in pandas.Categorical.map is deprecated and will be changed to 'None' in a future version. Please set na_action to the desired value to avoid seeing this warning\n", + " color_vector = pd.Categorical(values.map(color_map))\n", + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:392: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n", + " cax = scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Silhouette-Score for latent_omiae: 0.0545005165040493\n", + "Davies-Bouldin-Index for latent_omiae: 6.220562710580265\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:1217: FutureWarning: The default value of 'ignore' for the `na_action` parameter in pandas.Categorical.map is deprecated and will be changed to 'None' in a future version. Please set na_action to the desired value to avoid seeing this warning\n", + " color_vector = pd.Categorical(values.map(color_map))\n", + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:392: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n", + " cax = scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Silhouette-Score for latent_omiae: 0.0528724268078804\n", + "Davies-Bouldin-Index for latent_omiae: 14.65331462685268\n" + ] + } + ], + "source": [ + "umap_and_scores(test_data, LATENT_NAME, 15, [\"level1\", \"level2\", \"level3\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "# PCA representation of latent embedding\n", + "# Clustering by all call_types\n", + "import scanpy as sc\n", + "from sklearn.decomposition import PCA\n", + "from sklearn.metrics import silhouette_score, davies_bouldin_score\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Input: AnnData Object, 'embedding name', n_components\n", + "# Silhouttte Score: Ranges from -1 to 1, higher values indicate better cluster separation\n", + "# Davies-Bouldine-Index: A low index indicates that clusters are well separates\n", + "def pca_and_scores_for_embedding(adata, embedding_key, n_components=10, label_columns=[\"cell_type\"]):\n", + " embedding_data = adata.obsm[embedding_key]\n", + "\n", + " pca = PCA(n_components=n_components)\n", + " pca_result = pca.fit_transform(embedding_data)\n", + "\n", + " adata.obsm['X_pca'] = pca_result\n", + "\n", + " for label_column in label_columns:\n", + " plot_title = f'UMAP Plot using {embedding_key}'\n", + " plt.figure(figsize=(8, 6))\n", + " sc.pl.pca(adata, color=label_column, size=20, ncols=1, title = plot_title)\n", + " plt.show()\n", + "\n", + " pca_coords = adata.obsm['X_pca']\n", + " labels = adata.obs[label_column]\n", + "\n", + " # Calculate Silhouetten-Score\n", + " sil_score = silhouette_score(pca_coords, labels)\n", + " print(f'Silhouetten-Score for {embedding_key}: {sil_score}')\n", + "\n", + " # Calculate Davies-Bouldin-Index\n", + " db_score = davies_bouldin_score(pca_coords, labels)\n", + " print(f'Davies-Bouldin-Index for {embedding_key}: {db_score}')\n", + "\n", + "# Example\n", + "# pca_and_scores_for_embedding(adata, 'latent_embedding_adt_3', n_components=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:1217: FutureWarning: The default value of 'ignore' for the `na_action` parameter in pandas.Categorical.map is deprecated and will be changed to 'None' in a future version. Please set na_action to the desired value to avoid seeing this warning\n", + " color_vector = pd.Categorical(values.map(color_map))\n", + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:392: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n", + " cax = scatter(\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:1217: FutureWarning: The default value of 'ignore' for the `na_action` parameter in pandas.Categorical.map is deprecated and will be changed to 'None' in a future version. Please set na_action to the desired value to avoid seeing this warning\n", + " color_vector = pd.Categorical(values.map(color_map))\n", + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:392: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n", + " cax = scatter(\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:1217: FutureWarning: The default value of 'ignore' for the `na_action` parameter in pandas.Categorical.map is deprecated and will be changed to 'None' in a future version. Please set na_action to the desired value to avoid seeing this warning\n", + " color_vector = pd.Categorical(values.map(color_map))\n", + "c:\\Users\\adamb\\miniconda3\\Lib\\site-packages\\scanpy\\plotting\\_tools\\scatterplots.py:392: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n", + " cax = scatter(\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABMwAAAGtCAYAAADqJOg7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1hTZxvA4V/C3ktFVAQRBAfuva17b6t1r9Y6qrVaW1t3tdZqta2jfu5tax2to1r33nuCA1QUENl7JOf7IxqJgOBE7XNfVy6Sc951Qk5y8uQdKkVRFIQQQgghhBBCCCGEEACoc7sBQgghhBBCCCGEEEK8TSRgJoQQQgghhBBCCCFEOhIwE0IIIYQQQgghhBAiHQmYCSGEEEIIIYQQQgiRjgTMhBBCCCGEEEIIIYRIRwJmQgghhBBCCCGEEEKkIwEzIYQQQgghhBBCCCHSkYCZEEIIIYQQQgghhBDpSMBMCCGEEEIIIYQQQoh0JGAm3ojx48ejUql4+PBhpvtLlSpF3bp19Y8DAwNRqVSoVCrGjx+faZ4+ffro02SlfPnyqFQqpk+fnun+pUuX6stQqVQYGxtTqFAhevfuzb1797I9rvR5VSoVdnZ21K1bl61btxqkc3d3p1evXtmW97SEhATGjx/Pvn37njvvq/Ci7c7tuqdMmcKmTZteaXuysm3btixfo2+Lx+fT0qVLc7spQgghhBBCCPFOkICZeKvZ2NiwdOlStFqtwfa4uDjWrVuHra1tlnnPnTvH2bNnAVi0aNEz61myZAlHjx5l586d9O/fnzVr1lCrVi3i4+OzbWOHDh04evQohw8fZs6cOYSEhNCyZcsMQbMXkZCQwIQJE3ItYLZx40bGjBmTK3W/jDcdMJswYcIbqetFubi4cPToUZo3b57bTRFCCCGEEEKId4IEzMRb7cMPP+T27dvs3r3bYPvvv/+ORqOhVatWWeZduHAhAM2bN+fatWscOXIky7SlSpWiatWq1KtXj3HjxvHll18SEBCQo6CLs7MzVatWpXr16nTr1o2tW7eiKAqzZs3K0TG+zcqVK0fRokVzuxniJZmZmVG1alXy5s2b200RQgghhBBCiHeCBMzEW83b25vq1auzePFig+2LFy+mXbt22NnZZZovKSmJ1atXU6FCBWbOnKnPk1NVq1YF4Pbt28/d5qJFi5I3b95s8965c4du3bqRL18+zMzMKF68ODNmzND3pgsMDNQHOCZMmKAf9vmsYYqPh5gGBgYabN+3bx8qlcqgp9rZs2dp0aKFvv4CBQrQvHlzgoKC9GmeHhb5uJw1a9bwzTffUKBAAWxtbWnQoAF+fn4GdSqKwpQpU3Bzc8Pc3JyKFSuyc+dO6tatazD8NqeSkpL44osvKFu2LHZ2djg6OlKtWjX++usvg3QqlYr4+HiWLVumf87S1xcSEsInn3xCoUKFMDU1pUiRIkyYMIG0tDR9msdDGKdPn85PP/1EkSJFsLa2plq1ahw7dkyfrlevXsyZM0df7+Pb08//s/z9999Uq1YNS0tLbGxsaNiwIUePHjVI83hI84ULF+jYsaP++IcPH05aWhp+fn40adIEGxsb3N3dmTZtmkH+zIZk3rhxg969e+Pl5YWlpSUFCxakZcuWXLx4MUMbY2JiGDFiBEWKFMHU1JSCBQsybNiwHPXAFEIIIYQQQoh3kXFuN0CI7PTt25dBgwYRGRmJg4MDfn5+HDlyhO+++47169dnmmfDhg1ERkbSp08fvLy8qFmzJr///juzZs3C2to62zpv3LgB8EI9ciIjIwkPD8fLyyvLNGFhYVSvXp2UlBQmTZqEu7s7W7ZsYcSIEdy8eZO5c+fi4uLC9u3badKkCX379qVfv34v3KanxcfH07BhQ4oUKcKcOXNwdnYmJCSEvXv3Ehsbm23+0aNHU6NGDRYuXEhMTAyjRo2iZcuWXL16FSMjIwC++eYbvv/+ez7++GPatWvH3bt36devH6mpqRQrVuy525ycnExERAQjRoygYMGCpKSksGvXLtq1a8eSJUvo0aMHAEePHuWDDz6gXr16+uGkj4fuhoSEULlyZdRqNWPHjqVo0aIcPXqU7777jsDAQJYsWWJQ55w5c/Dx8dH3FhwzZgzNmjUjICAAOzs7xowZQ3x8PH/++adBkMvFxSVHx7R69Wq6du1Ko0aNWLNmDcnJyUybNo26deuye/duatasaZC+U6dOdOvWjU8++YSdO3cybdo0UlNT2bVrFwMHDmTEiBGsXr2aUaNG4enpSbt27bKs+/79+zg5OTF16lTy5s1LREQEy5Yto0qVKpw9exZvb29ANyy4Tp06BAUFMXr0aEqXLs3ly5cZO3YsFy9eZNeuXc+cR1AIIYQQQggh3kmKEG/AuHHjFEAJCwvLdH/JkiWVOnXq6B8HBAQogPLjjz8qsbGxirW1tTJ79mxFURRl5MiRSpEiRRStVqsMGjRIyexl/MEHHyjm5uZKZGSkoiiKsmTJEgVQFi1aZJDu8fZjx44pqampSmxsrLJlyxYlb968io2NjRISEvLM4wKUgQMHKqmpqUpKSopy9epVpWnTpgqgzJkzR5/Ozc1N6dmzp/7xV199pQDK8ePHDcr79NNPFZVKpfj5+SmKoihhYWEKoIwbN+6Z7Xj6eAICAgy27927VwGUvXv3KoqiKKdOnVIAZdOmTc8s7+l2Py6nWbNmBun++OMPBVCOHj2qKIqiREREKGZmZsqHH35okO7o0aMKYPC/zmndT0tLS1NSU1OVvn37KuXKlTPYZ2VllWneTz75RLG2tlZu375tsH369OkKoFy+fFlRlCevP19fXyUtLU2f7sSJEwqgrFmzRr8tq9dgdjQajVKgQAHF19dX0Wg0+u2xsbFKvnz5lOrVq+u3PT5/ZsyYYVBG2bJlFUDZsGGDfltqaqqSN29epV27dvptj49nyZIlWbYnLS1NSUlJUby8vJTPP/9cv/37779X1Gq1cvLkSYP0f/75pwIo27Zte+5jF0IIIYQQQoi3nQzJFG89a2trOnbsyOLFi0lLS2P58uX07t07y14tAQEB7N27l3bt2mFvbw9Ax44dsbGxyXJYZtWqVTExMcHGxoYWLVqQP39+/vnnH5ydnbNt39y5czExMcHU1JTixYtz5MgRJk6cyMCBA7PMs2fPHkqUKEHlypUNtvfq1QtFUdizZ0+29b4MT09PHBwcGDVqFL/99htXrlx5rvxPzx1XunRp4MkQ1mPHjpGcnEynTp0M0lWtWhV3d/cXbve6deuoUaMG1tbWGBsbY2JiwqJFi7h69WqO8m/ZsoV69epRoEAB0tLS9LemTZsCsH//foP0zZs31/eYg4zH+TL8/Py4f/8+3bt3R61+8lZsbW1N+/btOXbsGAkJCQZ5WrRoYfC4ePHiqFQqffsBjI2N8fT0zLaNaWlpTJkyhRIlSmBqaoqxsTGmpqZcv37d4PncsmULpUqVomzZsgbPWePGjTMM8xVCCCGEEEKI94UMyRRvhLGx7qWm0Wgy3Z+WloaJiUmW+fv27UvNmjWZPHkyYWFhz5zHa/HixSiKQocOHYiKitJvb9WqFatWreLatWv4+PgY5Fm+fDnFixfH2NgYZ2fnHA+pA90wuZEjR6JSqbCxsaFo0aIGQZbMhIeHZxo4KlCggH7/62RnZ8f+/fuZPHkyo0ePJjIyEhcXF/r378+33377zP8FgJOTk8FjMzMzABITE4En7c8s4JiTIGRmNmzYQKdOnejYsSMjR44kf/78GBsbM2/evBzPTxcaGsrmzZuzPL6HDx8aPM7uOF/G4+cos9dagQIF0Gq1REZGYmlpqd/u6OhokM7U1BRLS0vMzc0zbI+JiXlm/cOHD2fOnDmMGjWKOnXq4ODggFqtpl+/fgbHFxoayo0bN3L8nAkhhBBCCCHE+0ACZuKNeBwkuXfvXoaAiaIoBAcHU7FixSzz16hRA29vbyZOnEjDhg1xdXXNNJ1Wq9VPbJ7V/E2LFy/OMCl68eLFn1n/s+TNm/e58zo5OREcHJxh+/379wHIkyfPC7XlceAkOTnZYHtmQQ1fX1/Wrl2LoihcuHCBpUuXMnHiRCwsLPjqq69eqP7HHgeaQkNDM+wLCQl5oV5mK1eupEiRIvz+++8GvQufPtZnyZMnD6VLl2by5MmZ7n8csHwTHj9HWb0O1Go1Dg4Or63+lStX0qNHD6ZMmWKw/eHDh/qemaB7ziwsLLIMSr7oa1UIIYQQQggh3mYyJFO8ER988AEqlYrff/89w77t27cTExNDgwYNnlnGt99+S8uWLfniiy+yTLNjxw6CgoIYNGgQe/fuzXArWbIky5cvN1gRMTfUr1+fK1eucObMGYPty5cvR6VSUa9ePeD5ezQ9DkRduHDBYPvff/+dZR6VSkWZMmWYOXMm9vb2Gdr0IqpUqYKZmVmG//exY8deeDijSqXC1NTUIFgWEhKSYZVM0D1vmT1nLVq04NKlSxQtWpSKFStmuL1IwOxFe515e3tTsGBBVq9ejaIo+u3x8fGsX79ev3Lm66JSqfRtf2zr1q3cu3fPYFuLFi24efMmTk5OmT5nLzPEVgghhBBCCCHeVtLDTLwRRYsWZfDgwfz4449ERUXRrFkzLCwsOHnyJFOnTqVixYp89NFHzyyjW7dudOvW7ZlpFi1ahLGxMaNHj840+PHJJ5/w2WefsXXrVlq3bv1Sx/QyPv/8c5YvX07z5s2ZOHEibm5ubN26lblz5/Lpp5/qV5G0sbHBzc2Nv/76i/r16+Po6EiePHmyDFJUqlQJb29vRowYQVpaGg4ODmzcuJFDhw4ZpNuyZQtz586lTZs2eHh4oCgKGzZsICoqioYNG7708Tk6OjJ8+HC+//57HBwcaNu2LUFBQUyYMAEXFxeDObtyqkWLFmzYsIGBAwfSoUMH7t69y6RJk3BxceH69esGaX19fdm3bx+bN2/GxcUFGxsbfQ/FnTt3Ur16dT777DO8vb1JSkoiMDCQbdu28dtvv1GoUKHnapevry8AP/zwA02bNsXIyIjSpUtjamr6zHxqtZpp06bRtWtXWrRowSeffEJycrL+HJk6derzPUHPqUWLFixduhQfHx9Kly7N6dOn+fHHHzMc/7Bhw1i/fj21a9fm888/p3Tp0mi1Wu7cucO///7LF198QZUqVV5rW4UQQgghhBDiTZOAmXhjfv75Z0qUKMGiRYtYuXIlaWlpuLm5MWjQIL799ttsAwzZefjwIZs3b6ZFixZZ9hTq3r07o0aNYtGiRbkaMMubNy9Hjhzh66+/5uuvvyYmJgYPDw+mTZvG8OHDDdIuWrSIkSNH0qpVK5KTk+nZs6d+2OnTjIyM2Lx5M4MHD2bAgAGYmZnRuXNnZs+eTfPmzfXpvLy8sLe3Z9q0ady/fx9TU1O8vb1ZunQpPXv2fCXHOHnyZKysrPjtt99YsmQJPj4+zJs3j2+++cZgyF9O9e7dmwcPHvDbb7+xePFiPDw8+Oqrr/SBuPR+/vlnBg0aROfOnUlISKBOnTrs27cPFxcXTp06xaRJk/jxxx8JCgrCxsaGIkWK0KRJkxcaAvnRRx9x+PBh5s6dy8SJE1EUhYCAgBz1vProo4+wsrLi+++/58MPP8TIyIiqVauyd+9eqlev/txteR4///wzJiYmfP/998TFxVG+fHk2bNjAt99+a5DOysqKgwcPMnXqVP73v/8REBCAhYUFhQsXpkGDBtLDTAghhBBCCPFeUinpxwIJIcRrFBAQgI+PD+PGjWP06NG53RwhhBBCCCGEECJTEjATQrwW58+fZ82aNVSvXh1bW1v8/PyYNm0aMTExXLp06YVXyxRCCCGEEEIIIV43GZIphHgtrKysOHXqFIsWLSIqKgo7Ozvq1q3L5MmT3/tgmVarRavVPjONsbG8/QohhBBCCCHE20p6mAkhxCvWq1cvli1b9sw08tYrhBBCCCGEEG8vCZgJIcQrFhgYyMOHD5+ZpmLFim+oNUIIIYQQQgghnpcEzIQQQgghhBBCCCGESEed2w0QQgghhBBCCCGEEOJtkiuzTmu1Wu7fv4+NjQ0qlSo3miCEEEKI56QoCrGxsRQoUAC1Wn5zE0IIIYQQ769cCZjdv38fV1fX3KhaCCGEEC/p7t27FCpUKLebIYQQQgghxGuTKwEzGxsbQHfBbWtrmxtNEEIIIcRziomJwdXVVf85LoQQQgghxPsqVwJmj4dh2traSsBMCCGEeMfIdApCCCGEEOJ9JxOQCCGEEEIIIYQQQgiRjgTMhBBCCCGEEEIIIYRIRwJmQgghhBBCCCGEEEKkIwEzIYQQQgghhBBCCCHSkYCZEEIIIYQQQgghhBDpSMBMCCGEEEIIIYQQQoh0JGAmhBBCCCGEEEIIIUQ6EjATQgghhBBCCCGEECIdCZgJIYQQQgghhBBCCJGOBMyEEEIIIYQQQgghhEhHAmZCCCGEEEIIIYQQQqQjATMhhBBCCCGEEEIIIdKRgJkQ4p1yYs8hWnlVZ1jrXiQnJeV2c4QQQgghhBBCvIckYCaEeKcsmford28EsP/vHRzbeSC3myOEEEIIIYQQ4j0kATMhxDulasM6ADjkdcKnXKlcbk3W7icnEKdJze1mCCGEEEIIIYR4ASpFUZQ3XWlMTAx2dnZER0dja2v7pqsXQrzjbl+/hWNeJ2zs7XK7KZn6LdiPT28cI5+JOafKtcDVzCq3myTEKyGf30IIIYQQ4r9CepiJt8Nh4GNgSW43RLwL3Lw83tpgGcDm8LsAPEhN4kTsw1xujRBCCCGEEEKI52Wc2w0QAoBpwH3gLNAQKJS7zRHiZQwvWJKLCVF4mtvQyL5AbjdHCCGEEEIIIcRzkoCZeDt4oQuY5QEccrktQryk+g4u3KncIbebIYQQQgghhBDiBUnATLwdpqDrXeYJ/Jeme7oUBrejoFx+KGCT260RQgghhBBCCCEEEjATbwtToEpuN+INi02G3QG6+2EJ0KtM7rZHCCGEEEIIIYQQgEz6L0TuMTUCMyPdfRvT3G2LEEIIIYQQQggh9CRgJnLFmv17KPpxdz6e/ROKouR2c3KHmTF0LgmNPaCFV263RgghhBBCCCGEEI9IwEzkirGrl3ErJJgF/27j8p3A3G5O7rE3B588uuCZEEIIIYQQQggh3goSMBNvXJpGg6ONboL7ovldcM+XP5dbJIQQQgghhBBCCPGEBMzEG7d45z+c8L8GQLvqtbC2sMjlFgkhhBBCCCGEEEI8IQEz8cr5+8fw7bcXOHDgQab70wfIHK1t3lSzhBBCCCGEEEIIIXJEJk4Sr1zr1ge5di2GGTOucf9+GxwcDFeA/KhOfR7ER3IhNIC+TZvkUiuFeH5RMfc5enIhHm418Pasn9vNEUIIIYQQQgjxmkjATLxxcSmJfHdzJeGJMVzbeJsj3WaTqklj3OGlhCfGMLlWX/JY2uV2M4XIYOnaLtwIPIBabcz4L27g6OCW200SQgghhBBCCPEaSMBMZOn+zbOYW9rh6OLxXPn++qsWy5cH0qhR/gy9ywASUpOITIoD4G5sGAArr+zk+2OrATBRGzG74dCXbL0QT2xbtZ64mDja9vsIExOTFy5Hq017dE9Bq2heTeOEEEIIIYQQQrx1JGAmMnVi23z+mj0AI2NT+v94EFfvyjnOW6yYLd99VzrL/fmsHFja7EsW/3WOzgVrczrEH7XqyXR6LtZOL9V2IdLbvnYT33QbDEDUw3A+HjP8hcvq9eFqDh6fh4d7TfI4Pl8gWQghhBBCCCHEu0MCZiJTQf4nANCkpRB861yOAmYng69xKsSPD33qYW1qgalR1j15NCc92fdNOPsIgJ6/YVnmAQsaf4GNqSUdfeq8suMQIikhMdP7L8LRwY3WTaa+bJOEEEIIIYQQQrzlJGAmMlW7wyjC79/Ayi4vZep+lG36OzGh1Fo9lGRNKsP3zENBYV3rcbT0rA5AaHwEf1zbRx3XMpTOV5SrV2OeZA6zJyH1DlYm5nxYvN7rOiTxH9WyZyeiwyOJi4mlz1dDcrs5QgghhBBCCCHeASpFUZQ3XWlMTAx2dnZER0dja2v7pqv/b0vTQEoaWJiCSvXKir3yMJCSi/sYbKvs4sPx7nMBqLJiICeCr2FjasmdAWtJjTVm8ODTJBBPaIOtFHXOw5JmozA3zjjnmRBCiLeDfH4LIYQQQoj/Culh9l+i0cLdMN1fGwtwdnhlRZfI487ipiNZe3Uf/waeBCAkLkK/PyIhFoCE5CSSglPIX8Sa33+v8Whvo1fWDiGEEEIIIYQQQoiXpc4+iXhvpGl0wTKApFT95pTUFE5fOUZsvG6YZEBAHIMHn2L58oDnKr63b1M2tBlPqTxFAOheqqF+3++mY+h3qxm/Hx1L/g2O+u3+94JYd2g/icnJBmVFxD3kRqgfqZpUhBBCCCGEEEIIId4kGZL5XxMeAwnJ4GQDluYA9B7Tip3HNuPp6sO/88/TpPFB9u59AMCZNg3wKaXG4hsniAP+AcoBpR6VlwpEAvmeVJGqSSMiKQZnqyeBMU4AnwEaYBzQAkIiIyg2oBexiQm0r16LP78aB0BcUiybTv2BVtHglqcIdYo/CbwJMevLSZw9dIKBk76kSv1aud0cIf5T5PNbCCGEEEL8V8iQzPdYaloqEdEPcXZyebLRyRacDNOdvHwYgBt3rxEVG4GNjW51S2O1iqteswktGETRTS3x+rcNXATMgL8BS6APcB3oCgzTlWdiZGwYLAOoDKwGkoASuk1h0VHEJiYAEBAaok+anJaMVtEAkJCS8BLPgHjfXD1zgWU/6ubFmzF8PH+c3527DRJCCCGEEEII8V6SIZnvqaSUJFoOqUKFzgWY+NsXJCTG892CL5n3xYdcGT6EuKtX9GnHfzqLEh5lGN5jPPkc87NsWVVmzizHpi+9cfQIAiBMcx4SdenvGYfx6YGZzNy3ThcsA9iXg0Z5oA+WAfi6ezC99ye0rlKd+QOH6bc7WeehctHqFMnrSTXP2i/zNIgc0iZriPeLRdG+8Q6nzyV/4YI45NVFfEtUKJ3LrRFCCCGEEEII8b6SIZnvmWMXDrDs7zmULlaRyQu+BMA1vzudGvVmwcJxzDgFxgpYFS9B9dOXn1mWVpPG+Y3ziYq9iU+FLrjYVII/oZPDBNZF7Afg37hpNDxSEQYC7Z4q4Po5uO0HnqXBvXjW9Sha+v7zI7tvn+W7Wn3oUSrrRQBWXt5JUGwYQ8q3xcrUIidPiciGNlXL8eq7iT0bRf7OrpReWTW3m/RMD0MeEOh3g3I1q2BkZJTbzRHiP0U+v4UQQgghXr2lS5cybNgwoqKiskwzfvx4Nm3axLlz595Yu/7rpIfZe2bQlC5s3v8HUxaOonH11tjZOPBppy+xt3FEowKNSpdObZ59sEltZEy5qoOot/onXD6uBP7ASHB01X1JUqHC4VMb2EXGYFlqCpw7CJEP4PTeZ9ZzNfw2Sy/t4G7sAyYeWZ5lun9uHaf71u/5+sBCvjqwINv2i5xJCUsm9mwUAOH/huZuY3IgT/58VKxTXYJlQohXolevXqhUKv3NycmJJk2acOHCBYN0kydPpnr16lhaWmJvb5+jsuvWrasvV61W4+zsTMeOHbl9+3a2+YYNG2aw7caNG/Tp04fChQtjZmZGwYIFqV+/PqtWrSItLU2fTqVSsWnTJv3j1NRUOnfujIuLi/6YQkJCGDJkCB4eHpiZmeHq6krLli3ZvVuGuQvxKuXkXHN3d9e/T1hYWODu7k6nTp3Ys2dPhvKGDh1KhQoVMDMzo2zZspnWqSgK06dPp1ixYvo6p0yZ8sqOad++fahUKhwcHEhKSjLYd+LECf2xCJGbHn+2T5061WD7pk2b5PWZjru7O7NmzcrtZrzVJGD2rlEUeMawOZe8hQBwsHXi169WcXlDBD1afkqv1oOYOnYVqhmT8Zw0lbK/b8pZfWeAKHST9R/QbZpVfxDzGw1n94fTqejinXk+Y2OwfTSPmWO+zNM84m6bHx/HwgA0KVIpy3QarTbT++LlmBewoPBnXpgXtsRzYqnsMzwn/0Dd7WWFR0FM/MuVcenEWfZv/pfn6VibpNWQpsjrTYg3R4NunP+aR381r73GJk2aEBwcTHBwMLt378bY2JgWLVoYpElJSaFjx458+umnz1V2//79CQ4O5t69e/z111/cvXuXbt26PVcZJ06coHz58ly9epU5c+Zw6dIltmzZQp8+ffjtt9+4fDnzHuMJCQm0atWKkydPcujQIUqXLk1gYCAVKlRgz549TJs2jYsXL7J9+3bq1avHoEGDsmyDSqUiMDDwudotxNtEq9VyP+A2Ny5c4X7AbbSv+Vryec61iRMnEhwcjJ+fH8uXL8fe3p4GDRowefJkg3SKotCnTx8+/PDDLOsdOnQoCxcuZPr06Vy7do3NmzdTuXLlLNOPHz+eXr16Pffx2djYsHHjRoNtixcvpnDhws9dlvgPULTwIAju+Ov+voFra3Nzc3744QciIyNfWZkpKSmvrCzxjlByQXR0tAIo0dHRuVH9uytNoyiBIYpy/Z6iRMdnmiQ8Kkz5Y8dSJfD+zZer67afohz8W1H8bipKD0VRmimKciaLtHsURemiKMqsp7anJCvKgyBFSU3JtrqElCTFP/xutukWnt+qjD+0VIlJyvz4xdtl30lFqdlDUWp0V5R9J168nD83Biq1PopVGvZXFP/bihIWfktZtb6fsu/Irzku48zBY0o5lYtSlvzK/IkzcpRnR0SQYn5ohZLv6FrFLz4q2/QnYsKU8YFnlWs5SCvEu+j1f36vVxSlkKIopLsVerT99ejZs6fSunVrg20HDhxQAOXBgwcZ0i9ZskSxs7PLUdl16tRRhg4darBt+fLliqWlZY7zabVapXjx4kqFChUUjUaTaXqtVqu/DygbN25UIiMjlRo1aii+vr7K/fv39fubNm2qFCxYUImLi8tQTmRkZJZtApSAgIBntluIt9Wty9eUlT/OVuaP+V5/W/njbOXW5Wuvrc6cnmtubm7KzJkzM6QZO3asolarlWvXMrZx3LhxSpkyZTJsv3LlimJsbJxpnqyMGzdO6dmzZ47T7927VwGUb7/9VmnQoIF+e0JCgmJnZ6eMGTNGefor5p9//qmUKFFCMTU1Vdzc3JTp06cb7Hdzc1MmT56s9O7dW7G2tlZcXV2V+fPnG6S5cOGCUq9ePcXc3FxxdHRU+vfvr8TGxua43SIX3b2uKJsXK8ofvzy5bV6s2/6a9OzZU2nRooXi4+OjjBw5Ur9948aNBq/PnLw2J02apPTs2VOxtbVVevToob8O2Lx5s1KsWDHFwsJCad++vRIXF6csXbpUcXNzU+zt7ZXBgwcraWlp+rIiIiKU7t27K/b29oqFhYXSpEkTxd/fX7//cbkbN25UvLy8FDMzM6VBgwbKnTt39GmePvdPnDihNGjQQHFyclJsbW2V2rVrK6dPnzY4hnHjximurq6Kqamp4uLiogwZMkRRFN21BmBwExlJD7N3SVIKpD76pT0289UjHe3y0LFRT9xcPPTbLl26wIkTR1mw4R+6fD2VE5f8nl2PJg1O7ITgQLi0A5YBW4Fyj/YrCgRc1s1RptXAz+gm/18JBKYrx8QU8hYEY5NMq0mIjWD9T73Z9OsnqNNS8XIslM0TAH1LN2NcjZ7YmFlmm1bkvht3dC8XgBt3X6yMhZNn8V3bqsRtrEV8ZBjnr8Effw/kyKmFrNs8hFu3j+SonPuBd/U9y+4H5Kwxf4TdJkmr4UFqEv9G3X9m2gRNGvUv/sv4O+dpcmlXjsoXQqS3AegABD21/d6j7RveSCvi4uJYtWoVnp6eODk5ZZ/hOURERLBu3TqqVKmS4zznzp3j6tWrjBgxArU688u2p4eXhISEUKdOHbRaLfv378fFxUVf//bt2xk0aBBWVlYZysnpUFMh3iUBV/zYuXYj8TGxBtvjY2LZuXYjAVeyuS5+Aa/iXBs6dCiKovDXX3/luN7Nmzfj4eHBli1bKFKkCO7u7vTr14+IiIjnaX6OdO/enYMHD3Lnzh0A1q9fj7u7O+XLlzdId/r0aTp16kTnzp25ePEi48ePZ8yYMSxdutQg3YwZM6hYsSJnz55l4MCBfPrpp1y7dg3Q9ZZt0qQJDg4OnDx5knXr1rFr1y4GDx78yo9LvGJBN+DoP5AYZ7g9MU63PejGa6vayMiIKVOm8OuvvxIU9PS1Rc5fmz/++COlSpXi9OnTjBkzBtC9Jn/55RfWrl3L9u3b2bdvH+3atWPbtm1s27aNFStW8L///Y8///xTX06vXr04deoUf//9N0ePHkVRFJo1a0Zqaqo+TUJCApMnT2bZsmUcPnyYmJgYOnfunOUxxsbG0rNnTw4ePMixY8fw8vKiWbNmxMbq3u/+/PNPZs6cyfz587l+/TqbNm3C19cXgA0bNlCoUCF9D9fg4OAXfq7fZ8a53QDxHMxNwdQYUtPANuOHb2bOnTvDL7/MIDZFw/prMQCcvx7AlT/nZ51JrQYLa0iIQWNpTYaZou74walH8yqkpkLpSrrvMy5A3qfSxgHzIUEdT3LvJBzsn3z5OLR+Omd2LQXAqYAXtdqPyNExiXdHuwaPAmWK7v6LOLJdNweekhhCIYurfFAlL5t35AFArTbCwtw+R+U0+rA1V09f4GFIGJ9OHJmjPD2di7I+/DYOxqa0dHR9ZloFBc2jgJwM4RTieWmAoeh+4HyaAqiAYUBryPip9NK2bNmCtbU1APHx8bi4uLBly5YsA1TPY+7cuSxcuBBFUUhISKBYsWLs2LEjx/n9/f0B8PZ+MgXCgwcP8PB48sPYtGnTGDhwoP7x0KFD8fDw4OjRo1haPvmB6caNGyiKgo+Pz8sckhDvDK1Wy5Ftz/4R68i2Xbj5eL2S8/2xV3GuOTo6ki9fvucaCn3r1i1u377NunXrWL58ORqNhs8//5wOHTpkOifay8iXLx9NmzZl6dKljB07lsWLF9OnT58M6X766Sfq16+vDzQUK1aMK1eu8OOPPxoMBW3WrJn+fWzUqFHMnDmTffv24ePjw6pVq0hMTGT58uX6AOTs2bNp2bIlP/zwA87Ozq/02MQromh1c1o/y7mDUNADVK+nH0/btm0pW7Ys48aNY9GiRQb7cvra/OCDDxgx4sn31EOHDpGamsq8efMoWrQoAB06dGDFihWEhoZibW1NiRIlqFevHnv37uXDDz/k+vXr/P333xw+fJjq1asDsGrVKlxdXdm0aRMdO3YEdPOOzp49W//D2rJlyyhevDgnTpzIdGj1Bx98YPB4/vz5ODg4sH//flq0aMGdO3fInz8/DRo0wMTEhMKFC+vLcXR0xMjICBsbG/Lnz/8yT/N7TXqYvUuM1FA4H3i4gE3OVoiMjo4CwEStwsJU19OrUL5sfjFXqYmqVp+DDmb8aZHAzVB/w/1ajcH9ddWX086+Fh+5NiZB/dQkU0uBtWC52gr/365yP/JJdN8hf5En952LIN4/Drbw/VD4fpjufna2HoCe38DSTU+29Rn9GQXcXanXpgkrF1bF0Q66tJlP5zbzGdp/Py7OJXLUFhMTE0bMnMjUNfNwLlQA0K24OXXIN6ya9b9M89SycyayWhduVWqPm7n1M8u3MjJhe6kGfFmoFFtL1c9Rm4QQjx0kY8+y9BTg7qN0r169evU4d+4c586d4/jx4zRq1IimTZtmOzl/TnTt2pVz585x/vx5Dh06hKenJ40aNdL/+ptT6XuROTk56dtrb2+fYU6Vli1b4u/vz/z5hj+OPe5lm5MJj5s2bYq1tbX+BlCyZMkM24R4m4XcvpuhZ9nT4mNiCbn9gt3gs/A851p25TxPGVqtluTkZJYvX06tWrWoW7cuixYtYu/evfj56XrSHTx40OA8njJlCqtWrcqwLSf69OnD0qVLuXXrFkePHqVr164Z0ly9epUaNWoYbKtRowbXr19Ho3nynaJ06dL6+yqVivz58/PgwQN9GWXKlDHorVejRg20Wq3+uMRbKOx+xp5lT0uM06V7jX744QeWLVvGlStXDLbn9LVZsWLFDGVaWlrqg2UAzs7OuLu7G3w2Ojs7G7yGjY2NDXqYOzk54e3tzdWrV/XbjI2NDerz8fHB3t7eIE16Dx48YMCAARQrVgw7Ozvs7OyIi4vT9/zs2LEjiYmJeHh40L9/fzZu3GiwUJDInvQwexc9xwdnjRq1CQt7QEJCAiNG1eBiwF3a1K2Wbb4HybEEmAGoCI66R1HnYrrJ/3cCpUpA2VRd7zLvcqz43+ec4Rj4w1m/E9QoW+9JQWaxgA0ASVaJRMVHUMBBN/SyUpP+2Odzw9jEjCK+dXJ8TOL99csqiE+Em3ehTX2wt4GaTeuzNeCEQTpTU0tqVv74peub/vk4dqzdBECR4l5Ub1zv2RmyUcvOmVp28iunEM8vp8MAXs9wASsrKzw9PfWPK1SogJ2dHQsWLOC77757qbLt7Oz0ZXt6erJo0SJcXFz4/fff6devX7b5vby8ALh27Zp+VTwjIyN9mcbGGS/lunXrRqtWrejTpw8ajUb/y7iXlxcqlYqrV6/Spk2bZ9a7cOFCEhMTDdqxbds2ChYsmG2bhXhbJMTmbLWgnKbLqec517ISHh5OWFgYRYrk/EdlFxcXjI2NKVasmH5b8eLFAbhz5w7e3t5UrFiRc+fO6ff/8ssv3Lt3jx9++EG/zdHRMUf1NWvWjE8++YS+ffvSsmXLTIexZxb0UzJZfMnExHAKF5VKpV+Y4VmBQ1nx8C2WlPkUQi+c7gXVrl2bxo0bM3r0aIOeYzl9bWY2rDqz12t2r+HMZNaGzF7TWb3Oe/XqRVhYGLNmzcLNzQ0zMzOqVaum/yHN1dUVPz8/du7cya5duxg4cCA//vgj+/fvz9BekTkJmL2LYhIgMhYszSGv3TOTGhsb06HDk3HP5UtmsarlU9zzenD74S2SUhMpUfDRLz5fA6cAcxVsLAu6UXG0q9+Ns9eOU8ytBL5e6eYt0GohzxpoUZhUcy2q+iZ45jfsmu5VvlGO2vNflKrRxUaN33A/UEV5rpjsK+XrBccuQJGCYP0GpqmzttMFc1UqFdZ2OegC9wz7N/+L//nLdPy0J/ZOObvQFEI85vKK070clUqFWq02CBi9KkZGuiGlOS27XLly+Pj4MH36dDp16pTjYWM9evTAyMiInj17otVq+fLLL3F0dKRx48bMmTOHzz77LMOXgKioKP3cSpkFxtzc3HB3d89R/UK8DSxtcjaFSU7T5dTznGtZ+fnnn1Gr1c8VcKtRowZpaWncvHlT3/vl8bBuNzc3ACwsLAx+IHB0dCQmJsZgW04ZGRnRvXt3pk2bxj///JNpmhIlSnDo0CGDbUeOHKFYsWL698PslChRgmXLlhEfH69/Lg8fPoxarTYIDoq3jHkOL+Zzmu4lTJ06lbJlyxq8Xl7FazOnSpQoQVpaGsePH9cPyQwPD8ff318f1AZIS0vj1KlT+mGTfn5+REVFZTm8++DBg8ydO5dmzZoBcPfuXR4+fGiQxsLCglatWtGqVSsGDRqEj48PFy9epHz58piamhr0phMZScDsXRQeAxotRMeDvRWYvPp/o6mxGQ19mxtujHn0NxlIerK5V+tBdGrUC3Mzi4wX8iqgxHVMTM2pXbxf7kVi3jFxKfAgQff0uViD+Rs4U1M0EBynG/iU3+rN1Pm074eB/21dwMz41U9TlMGImRPwLlsS16LulK5a4YXL8b9whc9b90JRFK6evsBPG5fkOK9fQjRT7l6korUTQwoWzz6DEO+lWkAhdBNiZvYrrOrR/lqvpfbk5GRCQkIAiIyMZPbs2cTFxdGyZUt9mjt37hAREcGdO3fQaDT6Hhqenp7PHJ6YkJCgLzs0NJTvvvsOc3NzGjXK2Q9GKpWKJUuW0LBhQ2rUqMHXX39N8eLFSU1N5cCBA4SFhWV5Yd+1a1fUajXdu3dHq9Xy1VdfMXfuXKpXr07lypWZOHEipUuXJi0tjZ07dzJv3rwsh30I8S7K7+aKla3NM4dlWtnakN/t2fOUvojnOddiY2MJCQkhNTWVgIAAVq5cycKFC/n+++8NAlk3btwgLi6OkJAQEhMT9e9DJUqUwNTUlAYNGlC+fHn69OnDrFmz0Gq1DBo0iIYNG762wNKkSZMYOXJkloukfPHFF1SqVIlJkybx4YcfcvToUWbPns3cuXNzXEfXrl0ZN24cPXv2ZPz48YSFhTFkyBC6d+8u85e9zfIW0M2L/axhmRbWunSvma+vL127duXXX3/Vb3sVr82c8vLyonXr1vTv35/58+djY2PDV199RcGCBWndurU+nYmJCUOGDOGXX37BxMSEwYMHU7Vq1UznLwPdNciKFSuoWLEiMTExjBw5EguLJ1M3LV26FI1GQ5UqVbC0tGTFihVYWFjoA+ju7u4cOHCAzp07Y2ZmRp48eV75sb/rZA6zd5GFme6vqfGbiSqkpkFoJEyIhVYKTED3vSUdSwsrXbAs/TQqajXUaQM+FXV/JViWY4mPhpYrQPIbCvrHp4JGAa0CcanZp38dTIyhZFFd58k3wdzCgo4DelK14csNCdZqNPqu1pq05/uHDbhxjBUh/nx26wSnYh9mn0GI95IRuiWXQRccS+/x41m8jgn/AbZv346LiwsuLi5UqVJFvwpb3bp19WnGjh1LuXLlGDduHHFxcZQrV45y5cpx6tSpZ5a9YMECfdn16tUjLCyMbdu2GUzin52qVaty+vRpvL29GTRoECVKlKB69eqsWbOGmTNn8umnn2aZt0uXLqxevZoxY8YwZcoUihQpwpkzZ6hXrx5ffPEFpUqVomHDhuzevZt58+bluE1CvAvUajXVmz171aHqzRq80gn/H3uec23s2LG4uLjg6elJ9+7diY6OZvfu3YwaNcogXb9+/ShXrhzz58/H399f/z50/75uDii1Ws3mzZvJkycPtWvXpnnz5hQvXpy1a9e+8uN7zNTUlDx58mQ5ZKx8+fL88ccfrF27llKlSjF27FgmTpxoMDQuO5aWluzYsYOIiAgqVapEhw4dqF+/PrNnz35FRyFeC5UaymbzQ1fZWq9twv+nTZo0yWBo5Kt4bT6PJUuWUKFCBVq0aEG1atVQFIVt27YZDI20tLRk1KhRfPTRR1SrVg0LC4tnnr+LFy8mMjKScuXK0b17dz777DPy5cun329vb8+CBQuoUaMGpUuXZvfu3WzevFkf4J44cSKBgYEULVqUvHmfXr1PAKiUrAbUvkYxMTHY2dkRHR2Nre3LDYN6X8UHhaOkarAuki/jTkWBlDQwMdIFpV634AiIf9SlzMURrNJFMyJCIDYKHLxggBHcBEZCUuskrt67gJ2lAx75vF5/G98zKRoISwC1CvJZ6tZ7eBN13o/TvbzyW4OF9D99LjvXbcbv3CW6fNYPJ+ecf+D03PYtloenEmOVn9EDDlHS0f31NVKIl/T6P783oFstM/0CAK7ogmXtXkN9Qoj/goArfhzZtsugp5mVrQ3VmzWgSImcB6+FEC8g6IZuNcz0Pc0srHXBskLPPxRYiDdJvhK/hR4c9mPXB5NR0jTUWjeUwu2e6oKpUoHZG5ykL30vtvT3o8Nhz3rdksGpCXD90fxlW+B4yUPcfngLAGtzG/LZPt9StVpFy4rLOzFWGfFRifr/uQk9TY2goM2br9Pt0fff/9jT/Uo07NiShh1bZp/wKeWDj3Fd0eAQdw9N6AWQgJn4T2sHtEa3GmYwujnLavG6epYJIf4bipTwxs3Hi5Dbd0mIjcfSxor8bq6vpWeZEOIphTyhoIduNcykBN2cZXkLvLGeZUK8DAmYvYXCDvujTdGNyQvdfzVjwOxNCboBd/zBrTg4O+vGy6UP1CUngKIlPFXFXs1dapcsQb5r5tAW1OneANUv8Gb46+mNDNszR1eNJpU+pZu+9OGI7L1tgbJtB2HuWijjDRMGvZkRyG9a9Qq9uRV4gLyOnhR1q5lteq1Wy42A/eTN44WDXaFs0wvx7jEC6uZ2I4QQ7xm1Wk2BIm653Qwh/ptUasgn163i3SMBs1wUdtSfxPtRuLatiCrdL1wePWtz/5/zpMUn4T04l1aR1Gjg2A5d77GQ29B2QMZoSj5X8K1O7TU3uRKdQFHPnVz5X2OMTYypoqmBvZUDdhb25LHJZFhpNmJTEjK9L/5bVm2BqFjYfwpu3YVi7rndolevUtmulPf9ECOjnL0dr9s8mIPH52Fhbs83wy5jb/v6J0oVQgghhBBCiP8aCZjlkrAj/uyoOQEUhVLftqHspE76fRbOdjTc+y3RV+9xctBSrNzzUGl2b4xMX++/S6vVoiiKbrUttRosrCAhFiyts+x6pC1WnlsJNwG4HRHPyiPLKK4YUyVRja9zYShfFoDYxBhi4h5SIDAAlSYVytZ+5hLCX1TqRJImBWOVEZ+Wa/XKj1W8G2pXhBWbwb0guLrkdmten5wGywCCgs8BkJgURXhkgATMhBBCCCGEEOI1kIDZa3Y3JIw7IQ+oXqaEwTxc8XfDdbOrA/G3M18Z7/zYdQTvvAiASwNf3DpVfW3tvBpwh3qffEVicjLbfp5IjbIl4YMO8CAInAtnmU+tVrGqWzUWHb9FLbtQPrqpxjTcBrVbCMRfAk9fEswt2HJ2PUVjkigY+2j5R3NLXdAsCxYmZnxXq++rPkzxjvmkI7RvAHY2uhHBr1tMbCgr1/dCq2jp1n7JWxmMatt0On9tH0XhQpXwKFw9t5sjhBBCCCGEEO8lCZi9RoH3QynTZSCx8Yl82bMjU4f01u8r3KEKJUcFEh8UQdkpH2aa3963MHf+PIHa1Bhbn9f7xf3v/cd5EBEFwO87D+oCZhbW4OaTIe2BA3sJDLxF06YtyWuTj3YnXGln7kqyeiNmS7pCsjmUuQitT4KlLfGJUaRqUokxTtdLzdreoMwboX7ci7iDTwFfnO2eb4EA8X7L4/Dm6jp8Yj5X/LcDcODYHFo1mvzmKs8hD7fqfP7JwVxtg1arfaGJkhVFIUXRYqZ+DyejE0IIIYQQQrxXJGD2GvndDiI2PhGA01evG+xTG6kpN7XLM/OXHtsO5zrFsXCxx7bY6x2P1rpuVX5es4nE5BQ6N8q659ft2wEsXboQgNDQUEbaj4b/6faZNa6oC5YBhDhBxQZgYkpek3yUdi3Pw7gHRHkXwd7UGpxd9WUmJMdzxH8/AA9jw2hf+aPXc5BCZKNwoYqoVGpAwa1gxdxuzlsnITGSmf+rTdhDf7p1WErFMs9+D0svPDWJGuf/4UZiLIuL1aCHc9HX2FIhhBBCCCGEeDkSMHuNGlQuy8ftmnL55m0mD+z5QmU41yme47R3ggNYv2sFtSs0pEKJas9Vj4+7K/e2r0RRlEx7jmi0GtQqNWZm5hgZGaHRaLC0tATT9IWYQ8QZCHaG2kchyB5cdMM5y26tCP8CXYDOhmUbG5lgamxGSloyVmbWz9Vu8fZKi0hGFZWEkas1mLwbPYpKejfjm6GXUBQtLs4lnytvvCaVG4mxlLKyx+g1LJMdGnQfx3x5MDE1zT7xSzgV+5CDMaF8lNcDZ1MLg303Aw8RHHoJgKOnFj1XwOxITBh+iTEALH9wUwJmQgghhBBCiLeaSlEeTaT1BsXExGBnZ0d0dDS2trZvuvr3Vv3+vvgFXsLC3JKTq4Owt3k1Y9mCIu6w/+pOTI3NaFqmNcF373Pnzm2qV6+JhYklbALMgOYKnN4NgVd1GcvVAc/SEA000G3Smmk5tGAPHs7FKOT4ZG60mMRowmJCKeTohpmJ2Stp98u4dDuA/Zcu0KF6bZwd3uCYwPdE2LZgzrU7jJGJiopfF8ZqaFmMrExyu1mvTZJWQ/kzm7maGM1HeYuwyifrXpov4udR37F02hyKlvRmxfFtWFhlvWDGy3iQkoj7yfUkajXUsM3HoTJNDfbHJ0Tw02/VCYu4Sbf2i6lcrnuOy45KS6H2+e34JUaztFgNuuTz0O9b8sNsju86SL9vhlKxrszL9jaTz28hhBBCCPFf8eq7QYhck5qWAoBWo2HP8a3U7u1Nj2+aExMf/VLlBobdQKPVkJiSwP3IILy8vKlfvxEWFpa6PoodgJaAWgWVGkDTHlC/ky5YBmANlNDdved1l8CHt9h/dSdaRauvw9bCjqLOxd6KYFl0fBw1vxrG4Pm/0vK7b3O7Oe+ksL/voaQppCVqiTgVxdEyO0h+kJTbzXptQlISuZqoO8/2RIW88vL3btLNq3bzsh93bgS88vIfS1a0JGt152X0o/eT9KwsHfn286v8ND4+R8GyDQ9vk//Y7zS5tBNtcgzbXAqTUL0rXfJ5sHXXOH6cW4Ud2/7HL19N5viuA0z5dNQrPyYhhBDifTd+/HjKli37WsquW7cuw4YNe2Yad3d3Zs2a9VrqF+J12LdvHyqViqioqNxuyhunUqnYtGkTAIGBgahUKs6dO5erbXqbScDsPZCamsqxY4f5ttcMPF198CxcnKHTenIryJ89J7axef8f2ZYRsX8vZ9o04868XzPs88hXDGMjE6zNbSjo+GTuMRLjQKvJWJi1HTg6P3lsBIETb/Jn/xUc670P0A3x3H3pHzSZ5c9lyampxCXq5p57GPNywcb/qoJ9PDDLY4pFHmPiQ1JJCEwk9lxUbjcrx66kQqVQqPEAbqVln97d3JrhBUtQzMKWqUXKv/L29Bo1CHsnBxp0aIFnqYwLcbwqrmZW/FG8Dp+6eLM2i15yKpUKY+OcDQudHnSZ0NQk9oX6M+VnX6bOLsfGbcMJC7/BP3smcjvoBPtOTsHeSdeLs0hxr1d2LELkVK9evVCpVPqbk5MTTZo04cKFCwbpJk+eTPXq1bG0tMTe3j5HZdetW1dfrlqtxtnZmY4dO3L79u1s8z39BfXGjRv06dOHwoULY2ZmRsGCBalfvz6rVq0iLe3JG1X6C2HQXSN07twZFxcX/TGFhIQwZMgQPDw8MDMzw9XVlZYtW7J79+4cHZcQIntPv7c8vjVp0uSlyn36HH/f/JcDGeLVSX/+mZiY4OHhwYgRI4iPj8/tpr1z/uvXJDKH2Xtg5cqlHDyo+3C5H3yfhLQY/T612ogyxbKfvPzKp31JDAwg/N9/yNu8FRaF3fT7CjgUoks13ZuO3vlD4H8W7Jx0vcmMsn4pKYpC+1G1CQ2/z9HeUzlewJ4EIxXBUfeIjA8nj02+FznsV0qraPnn1gnc7ZwpmacIa0d+yz+nT/Bp05a53bR3kl1lR+qEtObB5vtcHXgap8b5caid94XKuhcK2w9DZV/wfUPxlMWnrhI//geifX3ZPO4Lhtpkn2eGRyVmeFR6Le1p06cLbfrkfL6wl9E+jxvt87hlnzAH2jgV5mhsGD5psSTF6Xre3QjYT4uGk7C3K0RUdBCeXpUYenYW/uevUKVBrVdSr3i3aRQ4kQKhWnBWQ2VTMFJln+9lNGnShCVLlgC6C7dvv/2WFi1acOfOHX2alJQUOnbsSLVq1Vi0aFGOy+7fvz8TJ05EURRu377NsGHD6NatGwcP5ny12xMnTtCgQQNKlizJnDlz8PHxIS4ujitXrvDbb79RqlQpypQpkyFfQkIC7du3x9/fn0OHDlG0aFECAwOpUaMG9vb2TJs2jdKlS5OamsqOHTsYNGgQ165dy3G7hHiXaDUarh08RFRwCPYu+fGpVRO10eudYzX9e8tjZmaZj6ZITU3FxOTNTV+RkpKC6WueF1UIPa0C92MhPhWsTKCAjW500mv0+PxLTU3l4MGD9OvXj/j4eObNm/da633fvQ3XJCqVioCAANzd3V/z0UoPs3dWQkICq1evYP36P3j4MAzQBabMjXSrVNYsV5/KpWrx61eruBZwiciY8GeWZ+mpi0SY5M2LiX3GObsMgmUA925xxdKI3apoHoTezJBeo9FwLeASiUkJaLVa4hJ0QTyTlFS8E3S9yhwsHbGzfPn5wb7//jINGuxh377QHKWPiUnl4sUo0k/fN2rf/2ixfjTllw3g8sMAOtSozaLPRlDRy/ul2/dflq9lAercbUmFrbUwMn+xi9JRM2HJJhj2A8S8oR+F7n71LWb/7sBqxnQKnj7+Zip9D33pWop7lTtypP4XVK/Yj/z5StCy0WTMzWz4avBZhvbbR68PV5PftSC1WzTEzNw8t5ssctk/iVDtAXSKgCFRur/VHui2v05mZmbkz5+f/PnzU7ZsWUaNGsXdu3cJCwvTp5kwYQKff/45vr6+z1W2paUl+fPnx8XFhapVqzJo0CDOnDmT4/yKotCrVy+KFSvG4cOHadmyJV5eXpQrV46uXbty8OBBSpcunSFfVFQUjRo14t69e/oLU4CBAweiUqk4ceIEHTp0oFixYpQsWZLhw4dz7Nix5zo2Id4VJzdsYqh7MSbXa8ycj3oyuV5jhroX4+SGTa+13vTvLY9vDo/mxlWpVPz222+0bt0aKysrvvvuOzw9PZk+fbpBGZcuXUKtVnPz5k39l8O2bduiUqkyfFlcsWIF7u7u2NnZ0blzZ2JjY/X76taty+DBgxk+fDh58uShYcOGAOzfv5/KlStjZmaGi4sLX331lUEPEYC0tDQGDx6Mvb09Tk5OfPvttzxrGuyffvoJX19frKyscHV1ZeDAgcTFxen33759m5YtW+Lg4ICVlRUlS5Zk27ZtBAYGUq9ePQAcHBxQqVT06tXruZ5z8Ra6EQFLzsP6a7D9pu7vkvO67a/R4/PP1dWVjz76iK5du2bZOzM8PJwuXbpQqFAhLC0t8fX1Zc2aNQZp/vzzT3x9fbGwsMDJyYkGDRroe6z16tWLNm3aMGXKFJydnbG3t2fChAmkpaUxcuRIHB0dKVSoEIsXLzYoc9SoURQrVgxLS0s8PDwYM2YMqampzzyuoKAgOnfujKOjI1ZWVlSsWJHjx598X9m8eTMVKlTA3NwcDw8PfTtehf/iNYn0MHtLaR/NI5R+xcpzfic5dfkwbT/oyp6du9m1SzevUatW7bCxscXV1ZXPi31BSmoyFUpUIy4hjho9ihAe/ZAy3pXYOvtElvWVWbOBhzt3oC3iif/t+xQvZZMxSJZOjGdxToWeBSDu/nlaF3gUWNJoQK3ms6nd+GvfWrzdS7FtzimWTNrMpj2rSSvogW9UON4JGozLeKE2erlf0vz8Yhg9WtedMygogWvXWjwzfUxMKmXK/ENgYDyffurJ3Lm6HkFbLulOyBRNKoHRoZTMU+Sl2iVeHc2jqe4UBXhDS5SU8HLH/8ARzCzMqVo4/5upNJ3w0DBsHe1f6pfmZK2GBSH+OJtY0DGvOzGxocxb3pyEhHD6dPkDt0Kvpzfc0wqY6RYo+KjdAoPt1lZ58PKo80baIN4N/yTCJ1EZT/MQrW77fKCpRcZ8r1pcXByrVq3C09MTJyenV1p2REQE69ato0qVKjnOc+7cOa5evcqaNWsyXcUaMv6oFRISQp06dbCysmL//v36L+gRERFs376dyZMnY2VllaGcnA41FeJdcnLDJmZ16PLoQuKJiHv3mdWhC8P+XEOldm1ypW3jxo3j+++/Z+bMmRgZGWFmZsaSJUsYMWKEPs3ixYupVasWRYsW5eTJk+TLl48lS5bQpEkTjNL1kLt58yabNm1iy5YtREZG0qlTJ6ZOncrkyZP1aZYtW8ann37K4cOHURSFe/fu0axZM3r16sXy5cu5du0a/fv3x9zcnPHjxxvk69u3L8ePH+fUqVN8/PHHuLm50b9//0yPS61W88svv+Du7k5AQAADBw7kyy+/ZO7cuQAMGjSIlJQUDhw4gJWVFVeuXMHa2hpXV1fWr19P+/bt8fPzw9bWFguLN/DGL16fGxGw9UbG7XEpuu3NPcHT8Y00xcLCIstgVFJSEhUqVGDUqFHY2tqydetWunfvjoeHB1WqVCE4OJguXbowbdo02rZtS2xsLAcPHjQIHO/Zs4dChQpx4MABDh8+TN++fTl69Ci1a9fm+PHj/P777wwYMICGDRvi6qqb5sjGxoalS5dSoEABLl68SP/+/bGxseHLL7/MtJ1xcXHUqVOHggUL8vfff5M/f37OnDmjjx3s2LGDbt268csvv1CrVi1u3rzJxx9/DOjeb17Wf/KaRMkF0dHRCqBER0fnRvVvvYCAW8rgwf2VwYP7K4GBtxRFUZTQ8GClaHMLpWADlPbD6yj//LNF6d37I6V374+UkyePZSgjKjZSqdnTSynYAKVgA5RynfJnW29Y6EOlY+PuSrMa7ZUFvyx9ZtrElERlzZGlyrID85Xdl/7RbbzlpyjrZivK1qVK3a7u+rrvhd55kvHaaUX54xfd7caFnD8pWYiISFby5FmvwGqlXbsD2aY/dy5CgdUKrFa8vTcriqIoD6OjFDp9oDCqnmLyeSNFo9W8dLvEqxN4T1HmrlWU05ffXJ0pKSnK7g1blZtX/N5cpY/88vVkpSz5lY6lP1AS4uNfuJxRt04pHFiqcGCpsvnhHWX/0TnKoK9RBn2NsuLP3q+wxU+cv/KXMmyspTJsrIWy7I8eikYj59L75nV9fqdpFaVSiKIUup/5zfW+olQO0aV71Xr27KkYGRkpVlZWipWVlQIoLi4uyunTpzNNv2TJEsXOzi5HZdepU0cxMTFRrKysFEtLSwVQihUrpgQEBGSbb+jQoYqiKMratWsVQDlz5ox+f2hoqL69VlZWypw5c/T7AMXU1FTx8fFR4p96Dzl+/LgCKBs2bMhR+4V412nS0pTBhTyUjzDL/KYyVwa7FlU0aWmvvO6n31se3yZOnKgoiu5cHTZsmEGe+/fvK0ZGRsrx48cVRdFdj+TNm1dZuvTJdTmgbNy40SDfuHHjFEtLSyUmJka/beTIkUqVKlX0j+vUqaOULVvWIN/o0aMVb29vRat98uY6Z84cxdraWv8ZXqdOHaV48eIGaUaNGqUUL15c/9jNzU2ZOXNmls/FH3/8oTg5Oekf+/r6KuPHj8807d69exVAiYyMzLI88Y7QaBVl4VlFmXU869vCs7p0r1jPnj2V1q1b6x8fP35ccXJyUjp16qQoSs5eZ82aNVO++OILRVEU5fTp0wqgBAYGZlmfm5ubwbWvt7e3UqtWLf3jtLQ0xcrKSlmzZk2WdU6bNk2pUKFClvvnz5+v2NjYKOHh4Znur1WrljJlyhSDbStWrFBcXFz0j9O/hwQEBCiAcvbs2SzrfBuvSYBsr6VeFRmS+RY6ffok8fHxxMfHc/r0SQCSU5JISU0GIDY+mkaNmvLxx4P47LMvqFgx4y/VF/xPEXDvOgAOtk78+tWqbOu9FxRMfFwCGpWaTX4POHM3626y5ibmNC/XljrFG1DbpwHb9l3j6o1DoGghPoZJnb7CrUBR+rf/nAL50i0U4FUWytSCcrXBo+RzPCuPaIB7wKNepQ4Oppw924QtW2qzenX1bLOXLm3Pxx8XxcvLhsmTdWOr7aysKZm3CFxR84FNOdQqOS1elehY3fxjwWHZp82KWwH49EMoX+LVtSs7JiYmfNC2GR7Fi725Sh/Z9edWAK5fuMKd6y++ImaC9knX63htGl5F6mJhbodabURJ7+Yv28xMHTr+G6mpCaSmJnLi7HJu3T6cZdobAQfZsO0L7t7L+dA08f46kQLB2qz3K8B9rS7d61CvXj3OnTvHuXPnOH78OI0aNaJp06bZTs6fE127duXcuXOcP3+eQ4cO4enpSaNGjQyGSuVE+l9snZyc9O21t7cnJcXwiWnZsiX+/v7Mnz/fYLvy6JfwZ/UgBxgwYADW1tb6mxDvqmsHDxERdC/rBIpCxN0grh089FrqT//e8vg2aNAg/f6KFQ3nGXZxcaF58+b6YVtbtmwhKSmJjh07ZluXu7s7NjZPJl11cXHhwYMHBmmeru/q1atUq1bN4D2hRo0axMXFERQUpN9WtWpVgzTVqlXj+vXraDSZL961d+9eGjZsSMGCBbGxsaFHjx6Eh4frh6999tlnfPfdd9SoUYNx48ZlWGRFvCfux+p6kj1LXIou3WuwZcsWrK2tMTc3p1q1atSuXZtff824wB3ophOaPHkypUuXxsnJCWtra/7991/9XKZlypShfv36+Pr60rFjRxYsWEBkZKRBGSVLljTodeXs7GwwjYORkRFOTk4G5+Wff/5JzZo1yZ8/P9bW1owZM8Zg/tSnnTt3jnLlyuHomHmvvNOnTzNx4kSDz/D+/fsTHBxMQkJC9k9aDr3JaxKApk2bZrguKVmy5Bu5VpEhmS9KUSA+CdRqsMx88s7nKitNA8ZGoFJRsWJl9u/XrQpRsWJlAFzzuzNn9BoOn91Dn7afoVarqVo16wBR+eJVKVOsEtcCLzJh4M/UKPdBts3wLVuCZm0aMS8wlcvGjvw7aycXv2yKt7NtpultzG2xMbclFQ0b6l6m3D1Tih6Lx8TCgZr123O41Sf6tFqtllth17E2syF/sbK6jeeBNEgqqeHatRhKlLDF1PRR1/JAYBxgC0x+9BdgBHAIqAg8mq+xUCFLChWyzNC++JREtgecpEL+Yrjb6YbVqVQq5s+vbJDO2MiIYz/+yuU7gZTz8Mz2eRI5N/xH8AsERztYNwPMZG5Z9v61HQtLC6o2zHw4Yo8RA5j15XdUqledoiVffA69SW7lMEJFrCaVD+zyY61NoXrF/lhYOFHUvf0LlwtwxX8HKSnxlC3VzmB7+dIfcsV/O6BgaeFEvjyZBxxTUhOZu6wpKSnxnDy3iu9Hh7xUe8S7L/QZwbIXSfe8rKys8PR88v5foUIF7OzsWLBgAd99991LlW1nZ6cv29PTk0WLFuHi4sLvv/9Ov379ss3v5aWbY/TatWuULVsW0F10Py7T2DjjpVy3bt1o1aoVffr0QaPR6Id3eXl5oVKpuHr1Km3atMmyzokTJxoMCRPiXRUVnLPPl5yme15Pv7dktv9p/fr1o3v37sycOZMlS5bw4YcfYmmZ8Tr3aU9P46BSqfTDtLKqT1GUDF9Wn+dLbGZu375Ns2bNGDBgAJMmTcLR0ZFDhw7Rt29f/XC4fv360bhxY7Zu3cq///7L999/z4wZMxgyZMgL1SneUvHPnovrudM9p3r16jFv3jxMTEwoUKDAM6c6mTFjBjNnzmTWrFn6+feGDRumD/4YGRmxc+dOjhw5wr///suvv/7KN998w/HjxylSRDeVT2bn4LPOy2PHjtG5c2cmTJhA48aNsbOzY+3atcyYMSPLdmY3RFmr1TJhwgTatWuXYZ/5K5grODeuSQAWLlxIYuKTCW29vLzYtm0bBQsWfOljyo4EzF5UVDyEP1qN0sURrF7iBfggGmITwMwECuXBzc2dWbPm6ZfCfaxlnU60rNMpR0V+++tgzvufpEmNtrSr3zVHedRqNYNGfMxf8/Zy2S+EVI2WB3FJWQbMHjPBCM+7TpwtFM6CFE8sbualTzPDk/l04HGu3rsIQJPSrch3Jj98qftQrhO7mxP+4TRo4MzOnY8Ce6uAK48ybwc6AVrgyKNtp4Ak4BlPe8e/J/DPrRM4Wdhyo/9K7M2zjjxbW1hQxbv4M49TPL8HjzopRsdCcsozAmZpWohOBkdzeMELtHfB2tmL+WHINwBMX7+Q+u0y9vRq/3F32n/c/aXrsjM25VDMA07FhbMvOpRJ93Zy6PgCboTt5rsl0KEhDHtGNb+HBXAo+gGfFSyOl8WT94BzlzawcHV7Im+aUqJwF0ZM+k0/WX/V8j0pU6ItwaGXyevkiY214cqoWq2GFX/24ur1nWg1uh5wxsYv+YODeC8457Bjb07TvSyVSoVarTa4OHtVHs85lNOyy5Urh4+PD9OnT6dTp05ZzhnytB49emBkZETPnj3RarV8+eWXODo60rhxY+bMmcNnn32W4ctzVFQU9vb25MuXj3z5cn8FayFelr1LzuYhzWm6N6FZs2ZYWVkxb948/vnnHw4cOGCw38TEJMueXc+rRIkSrF+/3iBwduTIEWxsbAy+iD49+faxY8fw8vIymEPtsVOnTpGWlsaMGTP071d//PFHhnSurq4MGDCAAQMG8PXXX7NgwQKGDBmiX7nzVR2jyEVWOZyLN6fpnrf6bALW6R08eJDWrVvTrVs3QBd4un79OsWLP/l+qFKpqFGjBjVq1GDs2LG4ubmxceNGhg8f/kLtO3z4MG5ubnzzzTf6bdn1bC9dujQLFy4kIiIi015m5cuXx8/PL8fH/bxy45oEyDQw5ubmJqtkvtXSNJnffxEJSbq/yan6stRq9Qv/sqMoCht2rwRg++GNJCQ+39KCs9tXoEt5N35oWYZaRXN2wdwutTwVy5di0E9Vafu7Kxj2ACc59ckXg6S0JHjU0zRBq+GEv24Fz/37w55MnFgOUAGmwOORm2qgH+AI9OSZwTKA6xG6LvjhiTFEJMXk6DheRmJqMmMOLmbSkRWkal7NSiTvuvEDoW4l+OZjMM3qszBNC2svw8qL8O+tN9q+53EhPoJa5/+hu99BkrUvds6HBgU/uX/3fo7z7d6wlU2L12S6wo1Gk8q23RP4a8fXJKcYnutXEqIBCEiKQ2VsRqqmAPEpup5tu56x8Mz1xBi6XDvA7OBrdPc7aLAvOvY+MXdNuPKHI39O30Hf2m1p412TD/KV4tyRk1iY23Iv5DxzlzVl/9E5BnnvhVzg5LmVxMWHkqZJpkjh6gzu/W+Onwfx/qpsCi5q3dt+ZlRAAbUu3euQnJxMSEgIISEhXL16lSFDhhAXF0fLli31ae7cucO5c+e4c+cOGo1GP/wg/cpvmUlISNCXff78eQYOHIi5uTmNGjXKUdtUKhVLlizBz8+PGjVq8Pfff3P9+nX98u1hYWGZfmkF3XDQFStWMHr0aKZOnQrA3Llz0Wg0VK5cmfXr13P9+nWuXr3KL7/8QrVq1XL4jAnxbvCpVRPHQgWz/jFOpcLRtRA+tWq+lvrTv7c8vj18+PCZeYyMjOjVqxdff/01np6eGc5Ld3d3du/eTUhISIYhYc9r4MCB3L17lyFDhnDt2jX++usvxo0bx/Dhww2+CN+9e5fhw4fj5+fHmjVr+PXXXxk6dGimZRYtWpS0tDR+/fVXbt26xYoVK/jtt98M0gwbNowdO3YQEBDAmTNn2LNnjz4w4ebmhkqlYsuWLYSFhWX7HiveYgVswDqbD25rU126XObp6anvQXb16lU++eQTQkKe9Dw9fvw4U6ZM4dSpU9y5c4cNGzYQFhZmEFB7kTrv3LnD2rVruXnzJr/88gsbN258Zp4uXbqQP39+2rRpw+HDh7l16xbr16/n6NGjAIwdO5bly5czfvx4Ll++zNWrV/n999/59ttvX7id6f0Xr0mkh9mLcrTWDaVUq8A2+27Szy7LBiJidb3UTF7uX5KUkkSPb5oBoFap6di4F5YWGbt7P0uxfLas7pH9fGDpuReyoqqRLrjmoDaFW0C6WFvl4zWp9r86xJWLwXamPbQHAsEq1ZhJzXxZ+Wcgn37q9SRI2AxdoMzCsBz6P7rlwKKmI5h2/HcaFamIh32B5zqeFzH95B98d1QXqLQzs+KzChm7wv7XVCihu03+H0z8DT6oDBMHP5UoIRXCHwVU77z+wGZUeAQP7oVQrPTzTYo24fZ5DsU84FDMA1o6utIpr3um6ZaF3uBE7EPGFy5DXlPDnpa9Rw0iJiISc0sL2n3cLUf17t6wlRHtdcO2HtwL5uMxhr9iHTrxP7btHg+AkdqEFg0nPmlLsRrMC/bjo3wetHPqSF47N/46eJvLt9zo1DjrOs3VRpio1KQoWmzSrWQb8uAa5Ut14ljRQ1xkPwCXT57T7/97yVpKVy3Pus2D0Wo13L13hgplOmNtqVtpMK+TJ7Y2LsTE6gKH9rYF2YcpwfeuMMDFG3N15h+wOaXVaoiKuYe9baEc/+Il3g5GKphgq1sNU4XhSpmPv+aOt9Wlex22b9+Oi4sLoFuxysfHh3Xr1lG3bl19mrFjx7Js2TL943LlygG6uXrSp3vaggULWLBAt0qsg4MDpUuXZtu2bXh753zIddWqVTl9+jRTpkxh0KBBhISEYGVlRZkyZZg5cyZ9+vTJMm+XLl0wMjKia9euaLVaRo8ezZkzZ5g8eTJffPEFwcHB5M2blwoVKjBv3rwct0mId4HayIgeP8/QrZKpUhmulPnomrPHrOmos/iC97LSv7c85u3tzbVr156Zr2/fvkyZMiXTc3vGjBkMHz6cBQsWULBgQQIDA1+4fQULFmTbtm2MHDmSMmXK4OjoSN++fTN8ue7RoweJiYlUrlwZIyMjhgwZol9572lly5blp59+4ocffuDrr7+mdu3afP/99/To0UOfRqPRMGjQIIKCgrC1taVJkybMnDlT36YJEybw1Vdf0bt3b3r06MHSpUtf+BhFLlKroE7hzFfJfKxOYV26XDZmzBgCAgJo3LgxlpaWfPzxx7Rp04boaN2Pz7a2thw4cIBZs2YRExODm5sbM2bMoGnTpi9cZ+vWrfn8888ZPHgwycnJNG/enDFjxhisUPs0U1NT/v33X7744guaNWtGWloaJUqUYM4c3Y/UjRs3ZsuWLUycOJFp06ZhYmKCj49PjqaAyKn/2jWJSlGeWmP5DYiJicHOzo7o6GhsbZ893O+dk5QCwRG6E7+A00sHwJ62/fAmZiwfR42yHzD+05kZ9p++cozWQ3XR2OIepdk5//wrrf9ZNF0VVH6gVqlgINA73c7mPOl1th4o/Maalambkff4+8YRmnlUwdvp1TRm5sl1DN+rO7EXNx1Jb98XfwN95wTHwcUHUNRBd0tHq4U6vZ9co+5emMnQzH23ISAKKhWAUnl5XcKCQ/mwTH0iw8LpO/ozBk/+Osd5p969yNeBZ7BQG3GqbAtKWNlnSLM/KoS6F3cA4GZmRWDlDlmWp9FouHsjgIJFCmNimvWvb38tWcv4Pp8D0P2LAQyf/mRJaI0mlS27xrJzv+5XmrZNp1O/1hfZHktWdd8OOskVv38oX6YzN03tORYTRg/nouQxMefvf7/h331TsLF2ZtSgM3Qr35Z7t+5QwM2V+NhYEuMTmb5hEbWa1Wfsj0WIiAwEoGHtUVSt2Idjpxbj7dmAIq7V+GvHVyQmRWJWdThdbuuGag8vWIIZHpWybXtWFEXh10X18b+1l3KlOtD3o3UvXJbI2uv+/P4nEcbFGC4AUECtC5Y1ffa0HUIIkaWTGzaxfOgXBgsAOLoWoses6VRq1yb3GpaFw4cPU7duXYKCgnB2ds7t5gjxcm5EwP47hgsAWJvqgmWemU9eL8TbQnqYvWoxCaDR6lZzjE8C+1e4YkNyKudP7ufu/VssvHWBLk374e3+ZKXJiOhY9p2+SwHnCtwPPU3bDzLOXbbv5A4iY8NpXbfzq+2BcRuM/FVPugI83amtIbp5yXwBF3LmJ2AH0AWoBnyGbljmbKBozor45fQG5p39mx6lGvF11Y/02+uuHU5QbBgT9s7nq0t+NOk9lbL1cjbXW1aGVmyPnZk1pkbGdC3R4KXKeudsva6bsNMvHPqXA/Mnby1qNZQsCpduQAmPLOYxq+umu71mAVevExmmGwJ85sAzxiRm4itXXz6wz4+ziQVuWcyHF6t5MmlpcErG+YkSNWmYqY1ISAhndJehHNy8hzLVK7Hk0F9ZDsFu0aMjD+4FExsVw8djDXuXzVrdkYCrf4GJDc7VhzLfqRwOceGUt3YiKi2FRG0aLqa6HrBR0fewsnTCxMScLzt9zJ4N2yhVuRxLj2zGyMiI5JR4fl1Un6TkWI6fXcb4ETepbvuke6ffjV26Y4wLZcLC+sw9fZgH56/hU84XUzNT0lLTsLTWnfjN609gxZ89AbCwsGfhqvYEh15i14HpVMgzlR7DfkatVrP+4ZN5Gl50mOtjScmx+N/aC8CFq3+9VFki9zS1gEbmutUwQ7W6Ocsqm76+nmVCiP+GSu3aUKF1S64dPERUcAj2LvnxqVXztfUse1HJycncvXuXMWPG0KlTJwmWifeDpyN4OOhWw4xP1c1ZVsDmrehZJkR2JGD2qlmZ6ybwV6lefvXM9NI0EPSQUS1G0rtWT+JTEnC2NYw8dRk9lZ3Hz2JmWpBzq//E+6lJ8Pac+Ec/XPNO8C2Gdv1W1+0nOVXXE84oBwG0IGApUAJIP+IwL5AfCEE3lLLjk/Qbz9zFvJERTXsVABsgs2uTGHT7VOker3l0fyEQC0Q8PhByFDBTFIUv9s4jTath9IGFDK3QDksTcxRFITZFt6xujEbD8YhkzNZMeumAmVqlpk/p/1CvsvQsjHUfgKZqkkKTuDnlGhaFLSkyujgpqSou39Ql8wvU9Th7FbHasAhdbDp/npznKV+7Ks27d8Dv7CU+GZ9xBbjrt3WnWnGPzPNXtnl277cWTq40ti/AoZgHfOVaymDfmge36OF/iBr3DlLq/CKSC6sxsXTk/JGTJMTFY2WTeRDOyMiI/t9+num+a0GnMANIjeUnrSVR4Xe5mRzPsmI1qXH+H+I0aazyroX95dVs2fkteRw9+HLQKY7u2AfALm97HI+tpXM+D34p7ItGq5sj7fHf9BrXHc3/VrYBICX8Gv1vn2BHnSb6/aZmT97vqpTvgZmpNUkpsVQu243TF9YCkJaqYc63P+Lo6EqrXh/SPo8bvxatTEhKIl8WMny+npeFuS31agzj5NmV1Kkmq2y9y4xUUE3WghBCvGJqIyNK1M18heq3xZo1a+jbty9ly5ZlxYoVud0cIV4dtQoKvWcjy8R/ggTM0lOUl1+hz8ociuQHVAZRc0Wr5cEhP6w98mFVyClHRUXFRrJwwyyKFPSife0P9WPa8tk96vWRqH0qvW7C75TUNFSqjP/ah5Gh+vthj++HRkFcIhgbQeG82UcyJqNbofIvdEEzn0fbLYGVQCC6gJkKuAlzRvgz2O007IG1ParzYflMehF996i8qsAvj/Jao5v4/yxQE6iLbiinGqj17CY+diU8EG9HVy4/DKRSfm8sHq3Gp1Kp2FS1H5/tWMqVG7FsVpWkd4UyOStUkJQMWw+CmwtUfNzBsY033IgEV1uuD7tA8Grdqg7Wvnbka1UQnyJw9RaU8nqOYNm9WIhP0f0q9dQvUOf9YNgPuuDbd0OgVoWcFWlsbMx3y3/NdN/hs/DVLN1pNnYANHq+afz0tvs2zHT7qrAA0hQF+6DDgIKZrQbX0rbU+6BvlsGy7KiqfUHwibmE5ClFiq0raDW4mllxKOYBMY96u22PvEfJRz2uHkbc4n7IRQZO+pJVsxZwpXdDUrRp/HV1G85/98A5b3GKutWgesWM8xyULtGaqnXH8O/xeVxxrYMlColJ0Vy8+jdurlVQpdhibWuj72VWttSTiHr/rhuZO3MAu1ecIi1RjYmZKeGhYQRcvc6AmpUzXYL6RbRvPpP2zTMOVRdCCCHeBb169aJXr1653QwhhBCPSMDssdBIiE3UTeCfz/7lysokInBq6HL8Zv+Lqb0lLS7/iGUBh0wy6iiKgpKWxtg5n+lXu1QlGxEX8JASbl6U9SmFsUoNFoY/wS+b+AWzVm+iVrlSFHMrBEBkTAQX/E9RqWQN2jXoxumrRzlz5Rg1ytTTZUp6NJY8TaNbrdDUsO23Ey7x842e2Bg7McJrLTa2j8aZG5Nx2KUdkD7uFADB6iT9w/sxGYeoAbphlwDHgGjAHl1gbC4Qim4IpxrYiS6YloNX7c3Ie1RYNoBkTSqtPKuztuWYJ0Pe7vhT984dLhT/gAkp11hpFkWrT2ZlX6gA4KflsO2gLra8cAJ4uwNWplBGN2zANN+j5UtVYJpXd3/2aLgVBB6FcljJvVj486rufqUEqO5qsPuCP6Q+6gR19hpUKqUb6vm88e70y6jfCnoyz9rNu89XTk70dfZkT1QwkcXaUuz8A1zylWDGvm2Ymb34sO25dYayzbc9xS3tSVO0nImLoI2TKwkaDctDbxKWmsTgAj6oa41k3eYhuBWqhJtrFTw/r023zz+hp98hlj+4ScN7+4gIv0EEUK/6UAq6lNbXEZcQTlJSNHkcPejWaCLm5fqQJzaMzwoUZ8qvpYmMDODeORsC/7HCMV8eVp78B5fChv/oPI5F+HrMZuzTfmTXui1sX72R6cPGEvHgIc27tee7FbNf+DkQQgghhBBCiNdBAmag+5Yc+yiYE5MAee1evqfZU8JPBwCQEpVA3K3QLANmySEhnKxfg6R7QRRo82Qp1dDgB5w8c4J9Z47Rqnlr2rRsC6YmBnl93F35bfSToUipaam0GFKZ2/dvUrlUTTbMPMihs7u5ff8mg7//iNNlg7HPY6tbodPSDEwzvhz+vv8Tt+LPAnAo/Heajv0UKgPFANcMyQ3VgZGHfIh8mIJZBTX9yxU2CFDodUE3v1lDdMGyx4yBgukeGx7uM4XER5L8qIfNveAbWJikCy6mmyupfbUaWDoasfD8VvqUbopaJSvrZSf+0amiKE/up+f1vS82ZewwL2yFfTVdb0oz06yHOT5NUWD/KbCKsaWSbQzEpWZI07QWHD0PySmgVaBBfyjlCb98neG0yNKvo6ew9Ic51GvblB/XLaD1Byr8b0NqKs9cQfJFtc3jRrxTYd3rv+XkV1KmsUpNq3SLVhS3tAfAysiEI2WbPUno25Hyvh152tJiNfjaIQ9+Cf7sCjqMibEFqzf0Y9fBH/n84wPExIYyfV4VkpJjaN3oF36/rGBcsgjTajYmJeYekZG697Xo67px1hEPHnLp+NkMATMAE1NTQu/e5+7NQO7eDNRvv3LKcGGS5JR4HobfxMW5JOosVs2cPnwcx3ce4JPxX9CgfYscPVdCCCGEEEII8TwkYAa64Ji1hW5ooo3FKw+WAZT/8SPOfrkGx4pFsCrnypUrl/Dw8MTc3NwgXcT+PSQG3AKgQZw1Fr0m4VGoGDVLNyDyQSSpqWlUr1UnR1GBhKR47gTryrpyS/el1NRYN+O6sbEJRmojsLLQHXsWStnVY0/YMkzU5njbVAUr+MtxLVEBEXTx6YepSdar+2ECduNNmbOrIhf7bmJTn+nkqehJw4PfYmSeLt/AR7fsJCXA/i26XnG1GoJj1hOh1ihUiubRidxIiaX8ieOElblG3pqPxo+6+UBqCqQm82/sLb7cPx8AraLwcdlX8+VbURSmnVjLrahgxlXvQQGb55ho6y33eXfIYw9uBaB88Yz71SZqCnR3f+HyV2+DeettAB+m1Q2mevWMQ5jz2MPcRyued3o0FdmlG7BhF3TO4TRyf8xdhlarZff6rTwMeUBeF2cmDX7hZudIZhP7+ydEsyc6hNZOrvoJ+t+U+6GXmD+3MqlpSTSu+w03Aw9yI/AAwaGXuBl4iITESJKSYwD4ccivhF2KJc3WkvH7F/N9iYpYWOUlMT4MqzpWpCU64e3lSbXGdbOsz75ccVgFWlNjHFvUxPV+LAPG61b1PLx9D4f++Zd4lz+JiLlJhdKd6d15TYYyAq5dZ9XM/wHw85ffScBMCCGEEEII8VpIwOyx/A6gtX9tq3Xkq+FN48Pj0Wq1jB37Fffv36NoUU+++WaCQTrHuvWxKOpJ8r0gCvfoR8VWbfT7Ro8e/yRhdLxuFU47K928aZmws7Zn4sBf2HLgD3q1HoyiKPRsNYhL18/QreUAbKyyn3ixXt7u+FhXw8zICkdTF7Yd3MCgKV0AeBARzMhek7I/+L/gVuhBAB6eukGMXzAOZXRzmd26FYdaDe7uORiWduIuTGkBKaYQdRF6PnvloE7GTvidPYapYoXZCDuYA1RAFxD10o0dTT52Q58+WfNkqePV+3ezZNcOetVvTNe69TOUnZqWRp9fpnP5TiCzPxlC9eIlDfb/c+s4X+1fAEBMcjxrWo3J/vjeEXkc4PMer6/8h5FP7ocVcdHNZ/cMrerAb+t09//3J3zYJGcx79a9P2TVrAXUaPoBTs7Pnsw/vR2R97idFE9P56KYZdEDKqcSNWlUP/8P4WnJzL3vx4UKrV6qvOd1P+Qit/YbEXPHAWeTUzRu059bd46Q18kTD7caqNXG+Hg1IirqLpdjTYBYjGMSsIiNZ+b8mqBJoV6DSRT37UR4v90Uda+Fta0NANERkWxduZ5SlctRuqpukrlq/Toy1jEWjY0lLUuUZnkJ3dDwqPAIPm/dG5V5IpUGhQFw6doW7tw7TeGChhPUORcqQAF3V+4H3qVszcpv7skSQgghhBBC/KdIwCy9N7C0bWpqCsHB9wG4fft2hv1mzs7UvHgdRaNBldVS1xoNhEXr7ienPlpk4IlTl48watbHuLkUZc43a+ndRtdtZvaa75m6eDQAzetkHJ4VEhLM6dMnKVOmLIUK6YZ5abVaXCw8AbgXcYdwbTjtW/Vkw+blJCYl5Oygm4L35gacvrMa59o+2BbXjbPcsuUerVsfRK2Gf/6pS4MGj47jDHAUaA64Q5omjav3LmIWpqJYwqMeOH6Pxvcpj9I7A+lGgSUkx1Pn058oGdOBQkcrYatx0S1I8NTk8MMrdkCraDFWG9GzVGOS0lIwURnR6+cfSU1LY9+l83SqWQeTdJOSnw29TquF3xJ0PByAsauXsmvSjwblOlnYoUKFgkLeR8Pk/lPStHA0CJI1UNMVzHP+VtOrtW5hAWtLaJaDBR4+ag6b98O9B1DYJecdREfMnMigyV9hYZnzXl2HokNpcmkXAJcTovi56MsFbFIULTGPArVhqUnZpM7enaQ4evsfxlxtxHLvmjiZPAmmR0bd5e9/v8bB3o0WDSahVquxVkpw54AuwHVmXQxjJnSjvG8njB/1RL1+az/RMffJa1+S7+YNYMHaz7EudA9n/5n4B58D4OyJ3wjw20rg3WMYqS34sOkKth0axvHFaTz0161K5lnKh0/GDeeDts2Y3bQDVxKiGJluVUwjY2NMTE1IiEkh4aYrtsUekJwSx6wFdZj05R2sLB31aS2trVh7bhd3rt+ieHndXGupqUk8jLiJc16fLIdxCiGEEEIIIcTzkIDZG2ZmZk7Xrj05duwwdepk7Ln0WKbBMkWBqDjQaMFIrftrkvFf+OuaKfgFXsYv8DJ7Tmyjea32AISE39ensdlmB4fgWtWr/LJiBnZ2diQnJxEVFcX27Vv58pvRfDiyHg+jHvDL8P9RyqcKZ4PPoagVKpStjpuTB5+0HZ6h7jhSuEsUHjhi9vjl1Qx8/JribdIEVbqg5KFDYWi1ClotHDnyUBcwiwU+A5KBPcB6OHf7FFfuXYB8YFrPGvdTRaGTna6Q34DFgBmwAiisIfnCQbbE3SAJLe49iuKsKgm26AJwT/8/jE35plo39tw+Q/45HTAzMmF/l5kUK1CIy3cC8SpQ0CBYBjD7zCaCNGFgpAKNiprFS2Uot0qB4uz+cDoB0SF0K9kgY8XvuysP4UyI7r6pGmpnsjpqFuxsYFTfnFelVsNvY+HSdSjjk3369J4nWAYQlfakF2JEWvLzVZaJMbfPkqooWKuNWVasRob9O/Z9z4OH/jRvMAFH+8IZ9qelpXDr9mFcnEthY52Xb2+fZU+07nmfd/cCRls/JuzhdTyL1OZe8AWCk+NINTLDrWBFypRsS35XV2wd7ImJjKKYry+APlgG8M+eCfif8WPD2geYmp6gwpC7oCj439ytT2Nubk9Y+PVH7Unk5yn9yVsmkqQ4R8AUrUaD//nLTOw/kmJlSlIzNoXN3fszLG8sX878nvKlO2FjZ8v/9v7Jid2HaNKlDQv/bEDoQz/S0pLRaDLOYWdjZ0vJimUB0GjS+Gl+De7eP0OZku3o33X9C/8/hBBCCCGEEOIxCZjlgg/qNeCDco8m9FeUZ3aJmbtuC9NXrKfdBzWY3ucjCI/V7bC1AEtz3WT9T6lR9gN2H9+KnbU9pTzL6bcXzFcYnyK+dHf6lIpbdPXHnIgiySKRpKREjB8FhtLSUtl3cjt3QnQTen/98wDC4mPp0rY/vr4VsTC1ZGDHLzE3MRwKmoaWKezhAfF4k5eR1H6y0wxUGB7np596cfBgGMbGKvr1e9RjLH2SR/fTz/ukGqkmJO4iZpa2OOAO1x/tSAbuAMpVEgIvkZRH96U/UhsBP2X59Optun6YxLRkEtOS+SfgBAe+/4lDVy5Rs0TGYFgj94osubADs3ImLG32JR9WrJdpmfXcypH5nv8A63Rz7Fk/Y567V8TBFmpVyHp/aNB9/C9cpUr9mpiaZTxncqqFkyvTi1QkMCmOMYVLZ58hG/9G6oLYcdo08pkaziV4xX87m//V9QhNTo6lX9c/M+RfsrYz569sxN6uELV67WXlA92chWogb3QgF4PP68sKsynMhjo/kmZkQlm1FWUAhzxOrDn7LzcuXqNqw9ocObmQwycXULV8L2pV/ZR4jyYErfFHm6IhKSUFC8WNRFUgnu61KF/6Q4KCz3P6/GqSU+LQpBgRsMsSlZEW+8K2OBRNxto5DRMLNXePmBEdHkGXcg0xszInPFg37HLuj8NYuKITACUrlqVkxbJcurYVD7eauLlWoVypDtjaPHvodUJiBHfvnwHA78auF/tHCCFe2Pjx49m0aRPnzp3L7aZkqm7dupQtW5ZZs2bldlOEEEK8Jfbt20e9evWIjIzE3t4+t5vzRqlUKjZu3EibNm0IDAykSJEinD17lrJly+Z2095KsiRgboiOh/AY3S0qPvM08UlwK5hvZy8l8H4oP63cQEhk1JP9xsa6yfrVun9hSmoKAyd3pm6f4pTwKMP+xdc4uPQ6bi66QNSeE/8wecGXXAu4SHhyqL6Yc9pT+vseHp40aNCEYcNGUq9yE6wtdXOchcXrgnRrNi7Ax6kErSt0zBAsA7gXdZ8H6I7nDlEZ9ms1qVzat5RTW2cSHxWKm5sVhw83ZP/+BhQo8KinjzUwG+gLzNBtKhOUQPl9l6i2/RyhXVfy66AyzOrvQ5D/Kd1iAZWA9pBSNRWtuRUOaQql49LIZ2JN5aLVDdugaFl9ZTebrh8y2N6jZCOcrRwoYudCh2K1cbSxpVWV6jjaZJznrXXRGpQIciPpVCqHTl/KsF8AHg7Q1huae0K5dEOGtYouSPwGxURG0blcQz5r3o2vP8rJ6hLP9kWhkvzqWSVDgOtFjC9cFncza3o5F6W0leHKuTZW+VA9WrXV1iZ/hryn9h9h2RdHuLbRnojwIC5E3OLxM9stX1E+8qqLk0MRQEX0XROuT0nDs/ccTB7GclH9pGddATdXrlYozNSQK6z961NuB53gj82DGbdxEH/eOcmxnoOxd81P/sIF6df5L4b1P0CLht9Rungb2jSZikar6wFma+uEZ+MkijaOJjLSl0JV4ynaJIbCdaIoUlY3XjouJpaUpCe99GwtPPC/cIXY6BgS4xN4GHGL/61szdHTi3gYcRPf4i2zfQ5trPPRsPYonByK0Krx98/z9AuhFxISwpAhQ/Dw8MDMzAxXV1datmzJ7t1PelO6u7ujUqlQqVRYWFjg7u5Op06d2LNnT5blhoeHU6hQIVQqFVFRUa+krePHj9e3I6tbYGDgK6nraSqVik2bNhlsGzFihMHz9CrUrVuXYcOGvdIyhcgNISEhDB06FE9P3UJfzs7O1KxZk99++42EhIxTmxQpUoTt27ezb98+VCoVDg4OJCUZTtlw4sQJ/bkuhMhcr1699OeJiYkJHh4ejBgxgvj4LL57iyxl9pl848YN+vTpQ+HChTEzM6NgwYLUr1+fVatWkZaWpk/39HVDamoqnTt3xsXFhQsXLgA5uwbLTdLDLLel+6zbd3IHfoGX6NKsH7bRaaBVaOhbgnXHTlHex5M8BZ0hMVkXdLA1HEp2eeNZSv9TgQCT68xcOZH1P+032G9u9uTL/THNXnY3LUncnSRm3R+Lr2lN8tjlp3XrdhRPN3l9vUpN2Lz/DwBMjIxpWK015b2rYmyU8WWTnJJMp0E1MK5ZGs8mjfi4SJsMaUJuniLomm7y/xun/6ZM/f6ZPydlH90eMb5wkVLH/ABYr1wDIC0tmfs3z1CoaUWYC39dP0yn2RPJb+XAyaZjKGtiAS5FdL337vqDRoOfjRWDdv3C7tu63ihrW47hw+K6PmAVXbwJGfTsoVwngq/y86kNlE724PKj+ef+PnGUXz8Z8sx8T4uJiCI+JgYX94xD7N4rhe0MH9+IIOHvi1yJ9qf4wLZYOb+ZlUMjHjwk6mEEALcu+72ROnOqc74idM5XJMP2u/fOsHX3OKpV7EtRt5pUKN05Q5pfvplA/AMV8Q/MMalTgk+86nJGdZT7yYm4mVkRYWzJR+0W8uui+oSes0SJ02Ie94ASp24zvHE3fTnrH95mwI1jAAxyLAYPr6BJMiH85FyqAWkeanyGdCGhkjf/s4gmYU5nLq1OQm0MPSe15ZPuf3P52laCgs9xI/AAAGfrFKee/zFMjTUA9BzTjd9W/Y8HiebE/huKSq3gUDSZ6Nh7fFimPmojI8zMzfhh4wwevyleS4zlZmIMRS2eBK2DQ68QcPcoZUu2w9LiSYCxdZOptG4yFYCEuHgGNu6C37lLjF0wnaYftXu5f5J48zTAOeAhkAfd58FrnJouMDCQGjVqYG9vz7Rp0yhdujSpqans2LGDQYMGce3aNX3aiRMn0r9/f1JSUggMDGTlypU0aNCASZMm8c0332Qou2/fvpQuXZp79+49sw1Lly5l6dKl7Nu3L9v2jhgxggEDBugfV6pUiY8//pj+/Z98pubNm/OFTF6WtbU11tY5WLhHiFym1Wq5E3yf2IQEbCwtKexSALX69fUduHXrlv69ZcqUKfj6+pKWloa/vz+LFy+mQIECtGr1ZLGfCxcuEB4eTr169Th69CgANjY2bNy4kS5duujTLV68mMKFC3Pnzp1X3ubU1FRMTEyyTyjEc1I0CpEHw0gOScIsvzkOtfKiMnq9Qd8mTZqwZMkSUlNTOXjwIP369SM+Pp558+a91nrfdydOnKBBgwaULFmSOXPm4OPjQ1xcHFeuXOG3336jVKlSlClTJkO+hIQE2rdvj7+/P4cOHaJo0aLPdQ2WW6SHWW6ws4K8dpDHTncfuHzjHN2/acqk/43g658/1a98ufrzAVxaM4dDi6azavteXDr056MfZqPRap+UlwZlZldiQPJIVsXvoEbZD3S92IIeQqzu16vqZeqycPxGxn86k0kfTqJ+jxq0/rY+Rd2KcCPlNDNnzjEIloXFJVGp9ggc7HUT9JuoLOje4tNMg2UACUlxmIaY0ntlfew/PUllXDOksXJwQfVoQm4bR125KMAYoC6wMovnq2Vr8CgK7qWpnfIDrpoaXI35hvl/lCD04nVIiGXVlV24K+ZUvleA3cGhUMBDFyy7fQ2O7YCTu2j1+0h23z6DGvA2tuZhYnS65zAVgm5AfHQWjYDuW75n9dXdfHVjIW1TapJXY8/XlbtkmT4zUQ/DWTdnIZsXr+bU7gPPlfedd/Uhg9cNYvCKT/i4S12UN9TTzN3bk8GTv6LyBzX5eu7UN1Lny/r970FcuraFIycXkD9fCYN5xR4rUdkbAGMLLUV9vbE1NmVJsZpcTIhk0t0LNLq0EycHd0xMLHDySUJtpMLEUqFCxM8cXtddX45Ruqh9WPGvuLjKgXtnnkQnHFbd4K/zZ1huFMVPobfYY1SFuGBTYu6asmPNVop7NcLTqRuXjl7W57ErXJDTZdqioEJtZMbRa1Mp6n2V/JHXQaNF0apwLJZMZPgDALQaDYnxCZzdc5mUQtU47tmWVSV7M/TmCX2ZcQnhzPitKgvmD2DO/9qQmpLC9rWb8Dtn2MvzwtFTnD9ykqSERP6Yu/Tl/hHizdsDtAIGAN8++tvq0fbXZODAgahUKk6cOEGHDh0oVqwYJUuWZPjw4Rw7dswgrY2NDfnz56dw4cLUrl2b//3vf4wZM4axY8fi52cYkJ83bx5RUVGMGDHilbbX2tqa/Pnz629GRkb6dqXf9jSNRkPfvn0pUqQIFhYWeHt78/PPP2dIt3jxYkqWLImZmRkuLi4MHqxbOMjd3R2Atm3bolKp9I/Hjx+vH8axY8cOzM3NM/Sm++yzz6hTpw6g63XXpUsXChUqhKWlJb6+vqxZs0aftlevXuzfv5+ff/45Q4+5K1eu0KxZM6ytrXF2dqZ79+48fPhQnzc+Pp4ePXpgbW2Ni4sLM2bMeJGnWLyHrt66yc8rl7Ps701s2PUvy/7exM8rl3P11s3XVufAgQMxNjbm1KlTdOrUieLFi+Pr60v79u3ZunUrLVsa9qL+66+/aNy4MWbppo7o2bMnixcv1j9OTExk7dq19OzZM9v6VSoV8+bNo2nTplhYWFCkSBHWrVun3x8YGIhKpeKPP/6gbt26mJubs3LlSrRaLRMnTqRQoUKYmZlRtmxZtm/fblD2kSNHKFu2LObm5lSsWJFNmzahUqne2qHZIneFbgziQNGtnGqwn4vdjnOqwX4OFN1K6Mag11qvmZkZ+fPnx9XVlY8++oiuXbtm6CX9WHafTQB//vknvr6+WFhY4OTkRIMGDfQ91nr16kWbNm2YMmUKzs7O2NvbM2HCBNLS0hg5ciSOjo4UKlTI4HwGGDVqFMWKFcPS0hIPDw/GjBlDamrG+XvTCwoKonPnzjg6OmJlZUXFihU5fvy4fv/mzZupUKEC5ubmeHh46NvxKiiKQq9evShWrBiHDx+mZcuWeHl5Ua5cObp27crBgwcpXTrjtDVRUVE0atSIe/fu6YNl8HzXYLlFepjlBpVKHyh7LCklSR9ASEyK1+23tgBFy5W9awgKs2PK4r8JDY9k7b/7+ap3J0p7PemZojZVQyLY2tkxvNsYuKWb+FtJSmFT75YcDTiFWfsuNL5cigcJJ3H/tgAmtuYM7voNJYtXxNTkyRfy5DQNlWb8y+3IeAq4fYmvei0FrIqw9c8tVCtTRz/XWXoOtk5stD5EnhhnlAgF7gGPYmIrNv/G5ZvnGNT5K2p0HE9yQgxOBR/Nzh4MPP4MXgF0y1A0FHaDX+cCkDcFrFYvZ2Pv43D4Lqo711k4JJWvC1SkbJIjKlcVmiXuUBqwBELT/fqm0b1RmKmMOFqwLtYu6SLfx3fA/QAwMYOm3cEs43A7F2sn/CODsFVZsjBmOI5q20wXEshMQnISlmbmRD2MQJOqa8fD4NBscr1ftN6O+If5AxBw5xopKcmYmWUc2vs69B09lL6jh76RugBi4iElBfI4ZJ82M3mdPAm8ewxTU6tMh2MCfPXTLxStnJdkQmndYiwAaYqWhEev8+i0FPI4evDV4LM8eOhPQO8zbN83HrUxXPbfRlxCONaWTrTJU5ilxWoQmpJE/fBYxuUzIm9x3fAPtdoI07CbGNk8WYLW3c2IByighkatdCfshD6fcy9ITcHKlhilOVE5dh8q6/1o0mxoUncoO/Z9B4BL+QRCTltiZKrg49UAZ7vy7Li7gZjQFCytrWjWtT0nti7igWdFLFLicFG0TBnTHiOtHd0Hj8J/l8LdQ3m4YnWdiOND2b5mEyampqy7uAe3YroP3hIVy+BWrCh3rt+iSZe2L/YPELljDzAqk+0PHm3/Afjg1VYZERHB9u3bmTx5MlZWVhn252Rek6FDhzJp0iT++usvvvzyS0AX2Jk4cSLHjx/n1q1br7bRL0ir1VKoUCH++OMP8uTJw5EjR/j4449xcXGhUyfdXILz5s1j+PDhTJ06laZNmxIdHc3hw4cBOHnyJPny5WPJkiU0adIk06BcgwYNsLe3Z/369fTtq1u9RaPR8McffzBx4kQAkpKSqFChAqNGjcLW1patW7fSvXt3PDw8qFKlCj///DP+/v6UKlVKnydv3rwEBwdTp04d+vfvz08//URiYiKjRo0yGBY7cuRI9u7dy8aNG8mfPz+jR4/m9OnTMi/Lf9zVWzf5Y8c/GbbHxMfxx45/6NS4KcU9ir7SOsPDw/n333+ZMmVKpu8tQIYhlX///TdDhxpeq3Tv3p0ff/yRO3fuULhwYdavX4+7uzvly5fPUTvGjBnD1KlT+fnnn1mxYgVdunShVKlSFC9eXJ9m1KhRzJgxgyVLlmBmZsbPP//MjBkzmD9/PuXKlWPx4sW0atWKy5cv4+XlRWxsLC1btqRZs2asXr2a27dvyxBqkaXQjUGc73QUnvqdPPleIuc7HaXMH9Vwblso88yvmIWFRZbBqOw+m4KDg+nSpQvTpk2jbdu2xMbGcvDgQYMOAHv27KFQoUIcOHCAw4cP07dvX44ePUrt2rU5fvw4v//+OwP+z955h0dRtX343ppseu+dQEJJ6L33XqQXKYIgiHQQFUFAEEUQBAUpAiIgHanSewuhBAIBQkJCSO892Wz7/hjYEJJAUHz1/d69rytXdmfOOXN2dufMmd95ytixtG/fHnd3wbjE3NycTZs24eLiQmhoKKNHj8bc3Fw/n3iZ3NxcWrZsiaurKwcOHMDJyYmbN2+ifWZMc+zYMd59911WrFhB8+bNiYyMZMyYMQB88cUXf/kchoSEcP/+fX777bdyLXRfHtsSExNp2bIlpqamnDt3Dmtr4QHpbczB/hMYBLNXkVcI2flgZgzmb5ZN702pW60R303fyP2oO3zQV1iNvnD5PFt/20REyj0eZF6nUa2ZPIqJp6q3O5XcnIsrS4FVwDmQtpGBSCdkz1SpKUxOwOzIadoD51dcIjopGwDLqq4Ezn6H9pXe4cLNk6jUKrxdfQHILlTxJENQyxMLjWhv5gE6SE5K5saNazRsWDIu2HPsHB0hHkRSkf6XdfN+EJ+uGAfA06Roti46ipm1S3ElByAACKVCD0JKnYYv5hdblDhaakGlpLbY+Jm9pA6JSTLE+IA/oCh2EznY4D1+fXqdjgU6rMUyyMmE56cx95llmUoJRYVoZHIk4pIPA/vemc++8Is0dqqGTRML8ABeM76r1Grafj6DC2GhfN5/CPMGDce/Xi2yUtOp367Fqyu/RMqTJ0TfuEVAx/YYlzP5+tsJioPIDKjrDH62b1RVXMWOmQtXs3/nz3TpPaxCYlnEvHsk7ojBY0JlPMb5/tle/0eJfArjvoRCJXzxIbRt+OZtDOn9M7Wq98bJsTrWlsKP7P6j40REnadp/dHYWHty885OXCo50ajOp0ieWX4qELFEIeVAeizDLYXJv6O9H472ftjZ+HD6yiLUGiWebvUxVdjojzfcUTi3C/fUwKt9KsW+4iI8W2cjDTpDtRBB4JX99hAwprCyG1a9hGvb2sWM6IcSos+YU7NpbXKz/sDCHKSyHKSmDhgbWVCozEEsluLbNYvw3605tDyYaj2D8HwnGbnMhGljr3Dj2G1il+mo4bke73Z5WAUHEq8JQaeDHWvMkedWB55QlKcj+kEEAKqiIlITk/WCmYW1FXvCzlGQl4+Zhfmbn3wD/wwa9HEry+U7oCVv1T0zIiICnU6Hv/8bpth9ARsbGxwcHPRWUEqlkkGDBvHtt9/i4eHxrxHMZDIZ8+bN07/39vbm8uXL7Ny5Uy+YLViwgGnTppV4aK9fvz5Q7OZpZWWFk1PZQr5EImHAgAFs27ZNL5idOnWKjIwM+vXrB4Crq2sJq7sJEyZw9OhRdu3aRcOGDbG0tEQul2NiYlLiOKtXr6ZOnTp89dVX+m0bNmzA3d2d8PBwXFxc+Pnnn9m8eTPt27cH4JdffsHN7T/zIGbg34lWq+XoxQuvLHP00gX8vLzfqnvm87HFz8+vxHY7Ozt9TLLx48fzzTffABAXF8ft27fp0qVLifIODg507tyZTZs2MWfOHDZs2MDIkSMr3I9+/frx/vvvA/Dll19y4sQJVq5cyapVq/RlJk+eTO/exeELlixZwsyZMxk4UAgH8c0333DmzBmWL1/Ojz/+yNatWxGJRKxbtw5jY2OqVatGXFxcCbdwAwZAcMN8MCWklFgm7ARE8GBKCA49XP9298xr166xbds22rZtW+b+192bEhISUKvV9O7dG09PTwACnmWYf46NjQ0rVqxALBbj5+fH4sWLyc/P57PPhCRen376KV9//TWXLl3SX1+ff/65vr6XlxfTpk1jx44d5Qpm27ZtIyUlheDgYGxshLm8r2/xM9LChQv55JNP9FaoPj4+fPnll3z88cdvRTALDxeMH14c25KTk/Hx8dG/X7x4MR9+WBw3etKkSfj4+HDlyhVMTIo1lbcxB/tPYBDMXkVSJmi1gnBmYgySv9eDtX/HESXe//77booKVXiYV+FJzgN6t/Zl6dQpONnaYCR/Kb5AlWd/AIjAzQ6URSTs2aQvInI2hmdGTZa1vEBhxJc/TWXdnmUYGyk4seYO3q6+2JsZM7u1G98cOoFl2lGSTaU4yQRrtrXrVlG7dj3k8jIyH34FHAZqAs8S25mbWCARS9BoNViZ25SuIwXWAZlABfSX+PgCoqIEMc/KUsr88dbgWA0qBUBsFjwGQmoIfdkMuiq10eRmIpFIqVK7JV8GtIIbp0EqA+9qxQ3XbQMProODG5ufBPP+0SVUs/Pk3KBlWBoJotvG0KPcTo6khXsgNH99XwEeJyZwISwUgM1nTvDlu+/RokenilV+gbzMTGbXa0pOaio1O3fk4yP7K1xXWQQPoqCyB5j8lTj1uUVw9VkcnnNP3lgwA+g+YBTdB4yqUFlVZhGPvwwDIPzjm3iMa4pw4rfzbx66bj+E/Gfxea+Fli2YaXU6QvMyqKQwx0xSOlaIVCqnZvVi66iMrFhW/9IVrVbNw8iTtG0+gw3bBwCQnZ1A57aChdnmXcN4cOc3qgBXENHRLYLwx2fIy0ulVvU+NKn/PrbWPrRpNqXMYMFpmdHPXunw9mhCl7Zf8OTpNSR95TyKOkdY+BFu3HcBtBg/jOW7T7/kj6eZqJzP4d9Hi7OHBwvmb6PXiMYoCkOJD7Vk1d5NdBo4jXthlwjefxupSbE7eXZKPtZAkSqfC6G7WP/JfrKSCslKMsW5Xh46B+FaF4ng7OGDxIQUYOtoj1/tGphbWaIwM6VJx1bUbSFk/VWr1ZzYeQAnD1dqN/sTSqWBf44QBEuyV5H0rNwrMuK+Kc9Xhv9q8GydTqdv49NPP6Vq1aq8+25ZJtMCMTExVKtWfA9Sq9WoVKoSscDeffddfvrpp7/Ur5f56aefWL9+PU+ePKGgoICioiK99VVycjLx8fHlPkxUlCFDhtC4cWPi4+NxcXFh69atdOnSRb+irNFo+Prrr9mxYwdxcXEolUqUSmW5VjjPuXHjBmfOnCkzXlpkZKT+8zRu3Fi/3cbGppRgYeB/i5iEeLLzcl9ZJjs3l5iEeLxc3764+vLYcu3aNbRaLUOGDEGpVOq3HzhwgKZNm+ofgF9k5MiRTJo0iXfffZcrV66wa9cuLlx4tQj4nBevh+fvX3abrFevnv51dnY28fHxNG3atESZpk2bcvu2kHn74cOHBAYGYmxcvPDZoEGDCvXHwP8WGRdSUMYWlF9AB8rYAjIupGDTyuGtH//QoUOYmZnp77E9e/Zk5cqVZZZ93b2pZs2atG3bloCAADp27EiHDh3o27ev/t4GUL169RLCu6OjIzVq1NC/l0gk2NrakpxcPOHZvXs3y5cvJyIigtzcXNRqNRYWpZPOPSckJITatWuXOVaAcK8MDg5m4cKFJT5bYWEh+fn5JQSrv8KLY5utra1+XGnVqhVFRUUlynbv3p19+/axZs0apkyZot9e0TnY2LFj2bKlOHZTbu6rx/S3zb/3qfPfgEwCSq0glIn/85loqlUL4NKl80iNJYweMJn+HUeUG0OsFBIxmBjjNe1j5E6OZOiKmDV4JNnXhWD19k0EdS08Wog7VKgsICbhsd7KbF6PZmTeXUeGyhOZWE6RphC5xJgidaF+INi16zcuX75Imzbt6d69lxCc+aWQCpU9q7JzyRkeRt+lT7uhlIkEsIWYhCgKiwqo4lkNZUEht85fwcTMhIAmDfQXkrfKjAdtunItKQ3VJC2Sti+Y0HfuDS0ALZCVAslF7HsUwpcfp6NTGbN3uwofHzNo3qN0H+ycoZkQS+LnbZNRadXcTo7kSlwYnXwacCn2LtPOCAEik/IzONrvmxLVNWoNV46eoiAvj8ad2mJmKQx0lZxd6FKvAcduXmdc59dn/CuPvIwMcp7FaUkMf/RGdacshjvhUMkdNn6pT6z65hhLwcoIMpXg9PcHeJZayDCvY0XOzUxsWkYgPE3vQXhirvfKuv8krRvA8cuQmQO925VdZnj4RbYkP6aywoLbtbujqMB1XXwzEZGTW+zOm5tfHL/nSWxxzC+xWEJY+DF2HhBWeHaFHUKTdBtFUQ7eno3x8WjMH+mxpKiUDHHwRiIS06zBWE5fFMx8nibcJjn1EZ3aCCtf7Vt+TFziHT4KakzMeXPMK2nI2nyMSG8lVesXIpaAkWkOyRn36PmOH0c3yIg9HQ/Es37eapwb5AKmyCXmtBvckfsRh3BqKAhiSrER09Oge4v6pO06grWLMY2bDKRbpwVM2fgO0qcRxFwXJlz2Lo48DgsnMSYOuZERS/esR1VUhEwuZ8UnC/l16U+IRCJ+uXKIgIYVc1kx8C8g9fVF3qhcBalcuTIikYj79+/Tq1evP9VGWloaKSkpeHsLC0unT58mNDSU3bt3A8UTQjs7O2bNmsW8efNwcXEp8dC6d+9e9uzZw9atW/XbXjVh/jPs3LmTKVOmsHTpUho3boy5uTnffvutPu6JQvHXM/+C8OBcqVIltm/fzrhx49i3bx8bN27U71+6dCnLli1j+fLlBAQEYGpqyuTJk0tNsF9Gq9XSvXt3vUXOizg7O/Po0ZvdGw38b5BTRibKv1Kuovj6+iISiUoFrH5uhfHy9XbgwAF69uxZZltdunThgw8+YNSoUXTv3h1b2zdfsHyRlx9OyxKrXy7z4qLAi69f3G/AwMsoEwtfX+gNyr0prVu3ZvXq1chkMlxcXF6Z0OJ19yaJRMKJEye4fPkyx48fZ+XKlcyaNYugoCD9/f/l9p9n6Hx523P3yatXrzJw4EDmzZtHx44dsbS0ZPv27a+Mv/m6e7VWq2XevHklrEaf86LI/WepXLkyAA8ePNAvuEkkEr2VW1mhm95991169OjByJEj0Wg0eku+is7B5s+f/9bjwb4JBsHsVbjYQr4SFHLBxOGvUFgEhSowV5Rrqfb8BpSVlcmyZd+Sm5vDBx98RO3adUtZdO05uYXMnHTe7foBRnKjMtsDEEuluA0fpfcctG9ShYKCAlJTU7Czs2fW6MWCybh3DZrXKX66F4lEDGk3jjWRPwjtGIl4mHqT+nUbIpVKKSws5I8/DgFw4MBeQTArh4YBzWkY8GqTrOC7l+g/ozUqtYrvZ/6KY6EDYdeEbJamlhZUqvEs1sIP4JdtgZ/CAp6HX8jPEQL2O7jDp3ZwNQbq7odzcP6UKSGXFYCapUsf8OOPZQgtGg0kRIGlLZhbMyKgI5fi7uJn404jF8ECwFZhgVQsQa3V4GRaWtGPCL2n76/cyIiWvQSTeqlEwtzRw+iS0IAh1cpRTyqAg7c3Q79fSuixE3SdMeX1FV7g/jNvoMexws/Q5M+OlVIxDKwOaQXg+Pe7hIrEIhqca0PewxzMqt96ttXv2d+/F2sL+GnOq8uczRRiDD4qyCa+KL9EJsgy27R0Y+yww0RGn6dJ/dFcvVH88GlkVOx22KfrMg6dmI3C2JIubefqxbRLfgMI8emMcZVsBl6YTUpKOOFmHnS5J6RrjizMYZ5nLZq2nsuJS8uR6DSoVXnsOvgRXu4N8HR75pJlW5manZ1wbfiYQoy58Y0l1j5Knnsv5+Ql8f26VqjUBeQ9sQKEH5vUREPiTVNAhKmlKYu2rmLK57+h0goT7Lu3fLBfuJ707q3ZcuMwO48P5ta9bSyS2hLZcAqW1ROpcWgZRbFy+o0bzpZlawGQSCV0q9SIgrwCWvXogJFCOJ5OpyM18XXmSgb+VVQ0ae5bTq5rY2NDx44d+fHHH5k4cWKpB8fMzMzXxtD4/vvvEYvF+snenj17KCgoXlEPDg5m5MiRXLhwQR/kViqVlnChcHBwQKFQlNj2trlw4QJNmjQp4SYRGVkc8Nzc3BwvLy9OnTpF69aty2xDJpOh0Whee6zBgwezdetW3NzcEIvFdO1aHPDzwoUL9OzZU2+Bp9VqefToUYmYSnK5vNRx6tSpo4/fVNaE3NfXF5lMxtWrV/HwELJQZ2RkEB4erk84YOB/D/MKWlNUtFxFsbW1pX379vzwww9MmDDhlRaUubm5nDlzhh9//LHM/RKJhKFDh7J48WL++KN0LLZXcfXqVYYNG1bife3atcstb2FhgYuLCxcvXqRFi+LQIZcvX9Zbkfn7+7N161aUSqU+QcH169ffqF8G/jcwcqrYQ0dFy70ppqamFb6vVuTeJBKJaNq0KU2bNmXOnDl4enqyb98+pk6d+qf6d+nSJTw9PUtk2X7y5Mkr6wQGBrJ+/XrS09PLtDKrU6cODx8+/NvmE7Vr18bf358lS5bQv3//CruyDxs2DIlEwvDhw9FqtXz88ccVnoM5ODjg4PD2LRArikEwexUSsSBw/VVUGohLFXy18wsFIe4FtGoNZ7svIeFEKDXn9yWlsRkxMdEA3L17h4YNS5pTH76wh0nfCNZaqRlJzBy5kIqSlZXJ3LmzyMrKpF+/QXTu3I1t3xwHIPxJGJO/GYaVuQ0/ztpOQEBNKlf2IzU1mZEjP8DRxRE7a+HHamRkhJ9fVR4+vE9gYK2Kn4sk4AHQkOfP0gDcDg9GpRaCMN4Mu0IP/376fbLnYmEyUAm4AjojHVeK1mD6xIqaDzSQnQ4yOXR7D6pnCEZIQOtqCn6Q6NBoRDRsWM6K3PVTEPMQJDLo9C7vBXRmSLV2yF9wlfO39eDSkBXcS41moH/pYGsW1tZC2CcdWNoWD14x2Uk03zYJpUbFkcdBHO67qOLn6iU6TRxPp4nj37jetOGw7xR0aPIXxLLnGEnB5a/FhdJo4WYYuDuB02sefiUKCRa1rBB8bMcB9pT44fyX8rV3Xb6MuU1na9fXimXPqVq5PVUrC3F5jCXFNw0bSw8KCrNRGFsQULU7AVW7ExcVw4ldB2ncsRUDe63hRL7w4FkotyDL1JHj57/Gw7EWjhmPyDJxIFUlrOyZyIwolFtgqswAQCSSoDC20h9LLlMwZPR5upz/iUgLb2ou/ZykOwqsKwtuJQprDWqN0JZPu1xy7L3JLUhGJrIl5k6acAwTc27d3YNKm6lv1+heIoUYEX7wDGu8LqE1E5J1JFgJK/FZZk40mOpFPZdAFJZRzNq3lnO7j1CUmMqOHwTx8MzvR2k7sD0te3Skap0AWvXoWPEvxMA/Ty2EmJav0jkdn5V7y6xatYomTZrQoEED5s+fT2BgoODee+IEq1ev5v79+/qyOTk5JCYmolKpiIqKYsuWLaxfv55FixbpJ6fPRbHnPM/iWLVq1X80gK2vry+bN2/m2LFjeHt78+uvvxIcHKxfGQch4+XYsWP1cZNycnK4dOkSEyZMANALak2bNsXIyKiEK8qLDBkyhHnz5rFw4UL69u1bYlXb19eXPXv2cPnyZaytrfnuu+9ITEws8VDi5eVFUFAQ0dHRmJmZYWNjw/jx41m3bh2DBg1ixowZ2NnZERERwfbt21m3bh1mZmaMGjWKGTNmYGtri6OjI7NmzXqrcakM/Pfh4eyChanZK90yLczM8HB2KXf/n2XVqlU0bdqUevXqMXfuXAIDAxGLxQQHB/PgwQPq1hX8y48ePUrlypVLxAB6mS+//FL/234Tdu3aRb169WjWrBlbt27l2rVr/Pzzz6+sM2PGDL744gsqVapErVq12LhxIyEhIXoL2MGDBzNr1izGjBnDJ598QkxMDEuWLAH+unu7gf9fWDe3x8hNgTKuoOw4ZiIwclVg3dz+P963l3ndvSkoKIhTp07RoUMHHBwcCAoKIiUlpcS9688cMyYmhu3bt1O/fn0OHz7Mvn37Xlln0KBBfPXVV/Tq1YtFixbh7OzMrVu3cHFxoXHjxsyZM4du3brh7u5Ov379EIvF3Llzh9DQUBYsWPCn+/ockUjExo0bad++PU2bNtWHoVCpVJw/f56UlJQykwKBMDcQi8UMHToUrVbLJ5988kZzsH8Kg2D2n0CnLR4kNNpSu3Mik4g/KsQFuPv1QXKMipB3k6KR6qhVq7RLUZFKWebrihAT84SsrEwAQkND6Ny5m37fuj3LuPPoBgC/n97Ge70+4tPJMyEjF0yMOBx6jEdPwhjeYzzWFjZMn/4p6elp2NpWcMk/FxgGpANNgBey2fdpN4wLN0+Sk5fF6L5TcXfwwtzKAoWZKR5VKsEKhCyalYAVsCdzMlsUKyEedhb+gByELJhaLXhXhYhkyFTSs08rHnbVkZ+vISDAqpx+PQv4r1FBYR6YmCGXyLiV9AhbhQUeFkJAtgbOVWngXPag6OzlzjsfjKAwLx/3ysKEJ/TESZ5os1FqBCEwvTCnYufpLdOtpfD3b2HZZvj9NJgq4NdF4FC2C34ZuJe759HsuyTtjcVrShXc3i9/wvl3kZwuBPn3cH59WYAhDj4Mcfhz/dy9ZjNfjfsSt5o+DJs9kN2HJvL70RlMev8s7q7CePF+mx4kRiexbsF3dP/SlqqqXNKrDsQhKxqnjEckoSN3Uzv6PrNA69VrLdAIc6kMf9faPH18GpFIwvuDd+FgV7nE8e8VqYmwEoQBbZMq5J99yM2f7JFbqPHvlUWNhnXp2PpTLMwcsTCuRP86TYiPFcQysRxs/Zz5cd9Fnjg3onLiNSQ6Ec3a9OXwxoMYWanRmj3L8KuDSr/t51GrjlgG3cfKu5DLwesAOFE7hYgW9fhJVg/jDdspzC8AdJzafgITMxMW/LrSMGn/b0MCTKPsLJnPmcpbDfj/HG9vb27evMnChQuZNm0aCQkJ2NvbU7duXVavXl2i7Jw5c5gzZw5yuRwnJycaNWr0SousfxNjx44lJCSEAQMGIBKJGDRoEB9++GEJi5Xhw4dTWFjIsmXLmD59OnZ2dvTt21e/f+nSpUydOpV169bh6uqqT3TwMpUrV6Z+/foEBwezfPnyEvtmz55NVFQUHTt2xMTEhDFjxtCrVy+ysrL0ZaZPn87w4cOpVq0aBQUFREVF4eXlxaVLl5g5cyYdO3ZEqVTi6elJp06d9KLYt99+S25uLj169MDc3Jxp06aVaNfA/x5isZhOzZqXmSXzOZ2aNv9bhNVKlSpx69YtvvrqKz799FNiY2MxMjKiWrVqTJ8+XW/tuX///nLdMZ8jl8uxs3tzE9t58+axfft2PvzwQ5ycnNi6dWuJ+IllMXHiRLKzs5k2bRrJyclUq1aNAwcO6F2xLCwsOHjwIOPGjaNWrVoEBAQwZ84cBg8e/FZcvgz8/0EkEeG/rJaQJfOZYUHxTuGf/7Jaf3vA/4rwunuThYUF58+fZ/ny5WRnZ+Pp6cnSpUvp3Lnznz5mz549mTJlCh999BFKpZKuXbsye/Zs5s6dW24duVzO8ePHmTZtGl26dEGtVlOtWjW9hWrHjh05dOgQ8+fPZ/HixchkMvz9/fXJP94GjRo14saNG3z11VeMHz+exMRETE1NqVmzJsuWLXtlYpJBgwYhkUgYMmQIWq2Wzz77rMJzsH8Kke4fcDrPzs7G0tKSrKystx6j419Ldr7gD2dlBvKSOqVWpeZk+0Ukn7uPSCZBp9KglkK3iCXYeZZe8dLpdPy8bwWZOemM6z8DU0XF40kdPreHn35aiZnMki6BAdQMCUfl7cN+Eah0SrZd+wGZTMaepeep6VcPniSDSg1A8znNiEqJokerAXw97VeScgqpbP9qayONVoNIJEIsEkM88Hw+4AKUF7d+K3ARaAa0fgKxD0k56MhNnxjsnzhSR9yAFS06cNroJADz7/9IoK8/VPYGZy9IAtU7ara6nMTN1Z5235eOEH334m7Q6ajh7AdZaYJbp50zv2ozOB51HQcTa767vgsjsYwF1UbRoWo9Ar0rLnCcWb+B9aOFiZDvxi+Id5IxrX5//G09KtzG/1fGfQmhz0LN/DgLav5FD0tlciHnXA4CILWU0SatV/lltRqMxG/3ifvBY/hwIRSpYNZo6FzBhBCvQqNRc+3WZkxMbKhZrVeJfR91GcKlP04D0PuTxiSJhJWoXp0W067FDJTKXFrYV6IoR4xYqqP+xGSkRjqkUmM0GhU6XWl3KjNTe9q3mEnb5tPIzUvl1LkfCD0VTbWq7en9/hAA0pNTGdRtEOcndEDj6YCLVMKAKwsI3Z5AxlMbCpMEy7L3FvZn4meCGr5sxnw2Lyl5s8ur7sGjH8eCWIzrgTNUP7kXWYEb2cla8nIzaDQpC5FMiVgk59oP1iizhUnUiMUdCE/fjEYp4kDLT0iw8WNEooi2sQUsnTpX375UJuV4fAjWdn8txouBsvnb79+nEbJlvmhp5oggllUgk7IBAwYMlMX9x5EcvXihhKWZhZkZnZo2p6pPpVfU/HvRaDQ4ODjwxx9/vPXA+SKRiH379v3p+IxvwtatW3nvvffIysp6a/EQDfz/IWlfLA+mhJRIAGDkpsB/WS0c3zFkMjbw78ZgYfafwsJE+CsDsUxKh7OzURcUcX3SL0SsO4NHu5rYvmCukns/jMxLF3Do2Ru5vT3v955UZlsAWbmZyKVyFMalj3c/+g63Us8B0P/WLZIinwKQ36Ej6Ta2/DhlF/XqNcDJ7plQJ5OASo1apyEjPxOAPLWUqosOE59VwMxWPvTxVVOnaqNS5pfxGbGcCTuGNjuT5r4t8apcD6YAV4CX4v+f/OMsj+5H0L9Wb2yXPzM5uqkB2WEQaQhuFUWqXESSbwLuy70YdnMN8gmTsA13J2DDB9BaDIuFatsPbuGE/ymC7FO5Z5vHuafLaOFeU3+s4KPr+H3FGAB6NR1I/SpNoEptnrp6MvynT9ChEwQ+QBmuZsb5tcySbuTOirX4uZVv5fQiSZGP9a8bpBrTdcSbxR37b+Bx4jMroApaVT3no8Hw007w94LAKq8tDpmFQtINi+JYfXkFgo5rZQ4yazlmgZbk3snCumX5Jt0jwy+xMSmCwfbebPVvUW65N+V+lCCWAdwOfzuC2dEzC/jj9DwAxrz7O4HVilee350yhkd37uPu68WAkTPY+nsIRkZm1AkUsmaKxVJqD1ETE6zCu64djq6VSU4Np1GdEfTu8h0HT8xCpSrgfvgx0jKjAMjNS2HfH9PJjTeh54BxnP/5Kaf3HmMPx/D296V2s4ZcOX6OMGdTCr0Ed9A6RsbkpT3Epz2kF8k4ldUVi2vhrP/6IM42deg3djjW9i+KVjrEUh0qG3N95ol8hRXJISaA4AKaMaAVQ2YsIO/WOSzllfHhBNtXbMTBx4Q+g2YxofN9ou8+xSM3BWdFFiEr9nL7BasAdz9npn37tUEs+2+mDdASwa0+FSFmWS3+FssyAwYM/O9Q1acSfl7exCTEk5Ofj7mJCR7OLv+4y25aWhpTpkyhfv36/2g/3pTNmzfj4+ODq6srt2/fZubMmfTv398glhkoE8d33HDo4SpkzUwsxMjJGOvm9v8KyzIDBl6HQTD7q+h0oNaAVPKXEwNIFXIarR1NnW+HILNQ6F2KVFlZBLdpgjori/hfN9Lg3NVy2zh59RCj5/XGRGHGvmUXqeJZ0ux6RI/xhEWGoNPpcI+UkhH5FORyCo2MUSgU1K/dCFMTU/pMbUHk04csm76J1tVbcSP8KgO7jMJIrqBKrXfZvElw3fzh+Gm2/PgZ/doPZ9nHm0oc60nqYwoi79ElX4ZT9iUSnjzEefAQGFyyz48fRbNsoZBcIP9+AdPEE4RMl1oxaBQgzcUKCalokSnlmGaaYlLowFjzA/DLs0bsAS3kZuVw/LJgdl871Yx7tnmkFpR0x8jPKk6zll8oZOlDJMJUZoyxVEaBugitTou9whKxREoSGRSpVcSnp1VYMOs2YyqZ8QlIjYxoO3Z0her8N3EvBk48i8PfrhbU8Kx43eqVYOWnwuvCp/lkXEjBtoMTcrsykldEpMORCOHaescP3CyIiIHxCwWDzYUToFkdMQ0vPksOEGBZ5jE1Oi2bkiIA2JYSxc9VmmL8lizN2jaCS7cgKxcGdPrr7RUUZpOc+vCF9yV/v43at+RY7E39+3kzBHH2SWwwx88uIrBaL76Ye577j47j7dmUpasbAnD3wUEG9lpNn67fARCbcJudB8aTmPCI/KJkNCo4sukQPQeMQ2adhZGlmqJsGcYmCh5GnmZ32Cco3mmJqEiNWCqhioUrv1b9DI+oy6T6V0YTKsXsTjQAm5esps+YoYTfCdP309pXiZmjioKYOBw3nkTlaIXT+uNIZXLUKhVamYTkdjXpHHISn85fIpZo8e2aSb0Jgtv5ieOrib4rCPzSHWfxr1GV24BOq8WnehVGfTqRjgN7lRs3wcB/ERKgtGGwAQMGDPwlxGIxXq7/LmsWBwcHPv/883+6G29MYmIic+bMITExEWdnZ/r168fChRWPqWzgfw+RRIRNq38ucLsBA38Wg2D2nCKV4FdtVH662VLodBCbCspn2S8dyw5++6bIi0zgMFAfcARNfh7q7GwAlMlJ5dZLTU1h+6bfaGTfhZDU8xy+sKeUYGYnNWPDhxvB0hSNSEdyr32Y+wdQY6sN8gg50ccieOIaSVDoBQB+3r+CvMJcxi7oD8DCCT/SuUYl+tRM5lp0Ivl3dgIQ8vBaqf74OFQhPiMTFxchG48iNbHMfhsZGyGRSNBoNBTYFcB6YCNgL4I2fSA3hkZO7nhlxGF8PowMj4d8GaMmMNKBCzkpfG9SF+lREaLTIkyyTPFq7k10ShQZdpkMrlmFdyqXNPlp3HMS+bnpwuvmg4Tv3TcQG4mUX7t+xsCDX6LWapjf7D1avVOL2Vs2EeDlTesKJDfQarU8iI3hesQjLtWszNPUZHyjImgV8Pq6/03kFZb9+k3QFmkJanoKZXwh5jUtaXyjQ+lCCbnC96PTCa/dLLgZJliYAVy5Dc3qgMREikXt8q8/iUjMaKcqrEsMZ5hDpbcmlgFYmMKSt5TpWKUq5NtV9UlODcfexpdG9d6jfq0hJcokpUFCiuDK+qJGv+bXnmTnJHD15ka+npVCm2ZTUBblYW7mSE5uEg52Jc353JxrMvWDiyTEPmHC4BYk3M9j/Ox3WLx/IrkOe6j/oYzCWy0Z1qgbXs3VODZMoH14JLGuAfh+dogV8wZS4FWFeHdfWh1ZTrp7F7RyKeIiNa17dmL+6Okc27EHMxcVeUlSXOrlY+VdhLv2AY+OJJASqsDRzZnvT+1laKcBhC4YQmFlFwqAjNYBtHA9g4WbSt9fjTweuZERRUoledm5VG7syO3Lwr6GbVvQZUgfVCoV4zoMJDEmjvfnj+Buyg/Y2/gyfMBW5DLDqrcBAwYMGPjf4e+MuvPxxx/z8ccf/23tGzBgwMC/BYNgBsITf4IgoOBkDWYVfLDSaAWxDNDlFfJWjErzlTBKCgkScAL2Q/C+3ezp9Q6mefn0MxVihmm12lJm5MHBV9EWgUJqiqupD1Gx4SXbVmvQJWZw9tZV8pQFdBjQH+f+gyAIMk+lMovfUPyg5Gb1dTjZuZKUFk+nJr1ISI3VN5GQEotcKmH3e80A+GLlJULCTJn03ixextHSifYD55LyxyZsTSyRVy07NoOruzNfrfiCyIdRtO3cCszhd+9YroelM/5GZZy71EAMuNy/DrIE6JJA9s+mTJ9uw1xZDWQmYhD0RMSI6W7Xki/brEBqnoubeaNSwb/lxiZ0HvVtqX5o1Bp6V2lO1AfbyCzMpYa9kDls1ydzyvu2SjFk6SK2XzhTYtuEtT8QunI9AEUqFXLZG4iy/1Jq+wg/VZ0Oav/J0B/aQg1FSYL1UEFMftmFAh0FoUwigmqCu2WbhnD0EuTkQ4+KxtnOLWKNdU1W+TZEInq9+4VKDev3CIH8R/cFs7+Ybf7Kbdh/Wuh7hyav6GZ+KsmpwnVbqMymY6vPSuxPTIV356iJs41nUHVb5gwsTr9sbGROdk4CcpkJYrEwtBvJTfl4/HViYoPx921f5jGjE0/h0jyOwJ6VeWh8g/thf/DEtwcaJPjFH8W5oYTIq5bk9qiLc8YjdDlqMgJckcUlU+DjgiwtB5t7SXht2ImulgN1PdU4eDlwZfs2AoenYeqgpiBNgsJWiJ0mEoN91QJyIm2YuuQL/AKrcyrsEm12fc7tBGMsbj3CWhWPuYuqRD9vG1th26UpCftOo7BVEydez/T187AyqkbHgb0Iyk7hi2ETSTp9EYDlM77Gvm4Cll73qFfrCLVr9AEgIuo8m3YOwcrCjXHDD2NqUuGsEwYMGDBgwIABAwYMGPgfwiCYgV700r+uqGAmlaA1V5CZGMeyQ99h4erGjBHz/3w/tFqIS4c0ISsj6YAGghPiKTIypsjImERbew4e3Mfvv++hevUAJk2arndBql49gN/376FQWUhyQRyD/YdTWFRIakYSbo6eIBYRdP82vx7dC0CBsZR+/QaCD4wXreSgLhi0YP8kg8hDkSiLCrG1sqdAWcDTxGiKVEo+HFicwiwpKZHksGxslZ7kJxeV+ZEsHD1gxBzQaTF5hVBRo2Y1atQUrOFu3Umld8QFdEZwbU8qx7s8i/Ts4Ib2cRgFSrgSLqNmTSs2no+it407Vm4yJIghA6o3aU6AdWMe592ku/Nk9u59yvbtT3jvPR86dxZis8VkJ7Hj/hnaedWltmNlHt2+y9l9RzA2N8WxeV06NGj0Rl9dQW4eSU/jOHv7Vql9Nb0qkZmbS7NPJvMgNoY1H05hVIc/n1Hl34BMCq0C/lobUgsZNX5pQNKeWNxGl5NQwdII+r9kJWkNG758YUNKPuQVgadl2W7RafmwPQzUWiQtPKC202v7dvAsbD0svDYygg8HlF1Oq9WSX5COmemrM1fNXSVYxV25Dc1qg0k5Q4y1pRudWn9O6P0DtGtReuU2LhluNj1Lhkcci1RGTFL3xlIqB+Cj944Tcm8v/r7tkUiN2JwUSeHj48ienKdp/THIZAp0Ol0pAfnqzU1odRqS0x5A2gOyHetxrXJvOt1cibVLAdYuEOsVwNE6H6AozEB2Oxm7Ncew2nqeorbeeKofkna/CG2aCNLyeZytJM/mExxbFmeFNbbWEHnMDO8WWrTiAhJvmVCYX8Ca+cuoWq8meboI6j1Yg+URE5zr5mPZrHhM1mqhQGHJZvuGGHVJpPKZIDTqLJTZErwCnWlavy8anZaOd09gk5zIc6fc3FQVGQctqdI9mxPnvsbGygNPt/qcu7KSzKxYMrNiufvgEHZGDZHKZXhW/s9nVzVgwIABAwYMGDBgwMC/F4NgBkIw/sJngo+l6avLvkS0KpUW0wXlwMnO9a8JZoiE2C2TMuCiKfQxBhk06dqdsHWrMZHKaDr9E75cNB+tVsvdu3dITU3B0VEQADw8vFjx/U/ce3SbQs1YalapR8extYh8+pCx/Wfw+ejFiO2KYzxptRqy4+LZc+pX7tpchTQJoOPD/pMxMzHHzESwZlMYKZg//vtSvY2NfYpSKfjjRUY+KrHvRthVJi8ehrO9G+vn7sPCtHRsqQdJ2UzedwMvGzNW9qmLVq2jf/9LXHuQjKiT4ImXK3rB8sjDj35jIrh4NZPUXBG/HqxFYaEWkTdIbJ6JcVqQi42ZxzEArj3Q0H/AbjRqLfsOPeF6VENqOvrSZfen3EuNxuKKKbHjdhB+6y46rZaCrBxmrFhOWI+uTK5fF4ztIDYfarqVym6qP48aLb+v20xORhZzA5qx4GEQViamtA6sRZc6DWhbqw6n79ziXkw0AJtOH/uvF8zeFs4DPXAe+BcyhybnwY4w0OqggQs0LiM2SUo+qLXC6/icCglm1i8k/7MpJxGgVqth5c/teBR1lqYNPmBQr5/Kbc/FHh7FgK0VyF9jYNit/Zd0a/9lmftq+4M4UTCnLJQpSVcr9YKZjbUnbZoJySUWxtxhfsQlRp6agESn4d7DI2h1GhTGlkwefR5722KzwHAjO8Tos3tjmS+kJ4yz9sMn6SaIRDwd2AlxvhKz/aFI04TjS3MLsL97E+9uWTy4a4VIokOnEfGkYVMkiSEknxPj1TYHsbEcdY4KiRxc8scTGnSDzMcPAQ1PwiPpW6cBNYfkI7dSYeZShKVHScsyTaEIkbEWiUaJzfEbiDPzKEKKg6YXjesKaatFiJCLJcR91A3jzDwUD+NQKdVYeRdhX72AmLjrHDj2KRNGnSSgag9C7u3FVGFDbGg+Y0e0QiKRsPrEDuq3bvrqL8eAAQMGDBgwYMCAAQP/MxgEMxAC9rv8uaxqHs7etKzXkfM3jvNu1w/+Wj/EIqEf7ZTQSwrCczCNGjUlMLAWMpmcpVv38cPFaGwVEiZ3roedXcmsgEZGxtSpIQT5Dn10k8inQvDwU1cP8fnoxTRo0pSw6Hts+v1HomPtsShozXtNhnI38i5PC8wZP2AcLetWzHQoMLAWlo7mxD6NIejueUJut6FWzToArN+7jKi4R0TFPeL45f30bT+sVP3Pj9zh2AMhrlm7Ko5Ypco5cCAOACvTQqyqptOmg0uJOl9935yNO69StUUM4QXH6BTYHYX8hWDxLxmxPYgVYW5pTGZaPqbmakKHJmBf6Ezfmi245x5NoaYItU7DA4scjHVakgvzicjLpK8qDa6chLXZkKmBWlVg06Ayz4NapSI3UxAR5GotTzf8xoPYGM7fvUMd38rIpFIa+1ejlncl7j19wvvtu1To/BooJjMHpn0LqRkwd7wgHAGQpRTEMoCMcoKpVbIGX2vIKRJEtQrQugEsngoFSmhTTpb37NwkHkWdBeDmnR2vFMyWz4Tge1CzCkj/wqgrFsOuOo1ZHHuPTtYueBubl9iv0+lITY8kTZkDOh0qqTESVR46nZaiojyKivK49/AwrZpM5GboLq6HbEMUfoAUC0/ss58gRoJpYRpyVT6h3h2w92nLMtcqyLRyDo6Zg8Xp2wBYNrMm/1YqOQky8pLk+PXMpDBLjFYs4/fatTCfeB1QEGfpR71Oj7GUp+LVOpej6zdTkAF+XYswN3Xn2m/JVGqdg9xK+O4cA4pIumGFQw0VtWt1J/GOmEO/HMelXh4jCyaSJZXxUGKFsakJ8d3eYXXiI8a7+CMWiTgd0IHfXWLIb5/KH/c3AWBrXQmp+B5qbQHuLsLY1KD2UKpW7ohcZsLKT4TUuhqNhnvBIQbBzIABAwYMGDBgwIABA3oMgtlfRCqRsnXRUTQajeAaqdUKbmF/NmOmsVz4yy8EjQYUghhkYiJYvv16+BQAaQUaOvce8sqMcB4FYr5/aEGmugCr98cB8DD6HufuHyIi4w5qTfHDoUImY0znLjStVZXbD6+z8/hGwiJv8+n7X9OgRrNSbScmJvDzzz8Rn/gUqViGscaMH39YzrJlqzAzM6NlvY4cOr8LudYXD/uy050FOlux5/ZT5BIxVRzMcXJR4OqqIC6ugEm9avPeWGc8HRxL1PHzs6BdLw0XT0WiKiyiso0/NXxqlnsOaniLmfh1W0JC7qG5EMHQE7HYS1O4K+5PWs9suvo0wtrYnDtGafxqchJdkohavr44K4whQymIZQAh8XACaA+Xtm0n6vpNOk3+CDsPD+TGRjTv0YnI0PtUa1Cb3IICmnw8iYzcHNYdP0Lwd6uwMDHl1vdrin8n/8/Iz8sl4sEdqlSvjbHx2w+ufjkEHkYLr/edfEEwq2QNtRwhWwlNysl8lVskiNGVrMG+4hakTWq9er+luTMNag8l5N5e2jSbqt8en3gXCwtnzExsXygL7d7My7dMlFoNVU2s+KNGuxLb5z+5zfXcVBpFHCA+aAVOToGM1olBlYeFuQvZOfEASMQyqvt1JTn1ERu3D0Cn03Gh2lDuerZFXpTPQXc/lh/9jCKZELTttFbCVZkVfrvWcf5sCLpndmjunlHcv2aBe9NcrLyFOHQyhYasp2L8v9jAs6uGpG5NSTNTYZmcSpHWGGOFGf79H2NsoUNTlIFLdW80KiELqE4HMZcUZEZKiTptSquVnTh5+heUmVLUhRKkkgJsvdS4NRFj3yCPTVaFbI4MooaJFVZxVwgLP8qIhuMoeH8Ytw+cQiqT8d2OLZjbSUnPfIKPZ/F4Z24mZGkaPHk0D0PuYWyioNeosgVxAwYMGDBgwIABAwYM/G9iEMzeEhKJBDJyIC1HcN1zsxPMQUAQvnQIlmwVITsPkoWHyJeTEIzr25Wp362lblVvqvt4vrKZ+A3rsEjNxgKokqQiOj6SLuProSwqRGFkwu+3DqBDh0ajpUPtTrSwr8O+fT8zYc1YfRsL1s7gwIorpdo+fvwIkZERmIqsMLcwJSc/D6lEqk9EMLDTSKLuVOezmY9p1yKMoCA3qlYt6ZY5p1MNmleyx8lMjp+jBWKxhAcPunI/Ukm6xowCZdmfKz++gJg7MQBcOx9EdqIL8+bdpWlNOXOGS8GnOijMAKhTCQK9zHgYZ0rvfYIlUopaSZRnLN+3+Ujf33nNRpCpzMWlri3ft/0ISWoCRIVBYyVcTQFxE3gCMXdCWTVkBCC8/uzkHwD4162Jf11BuEvNziI7Pw+ApMyMEn2XSCRkZMPNMKjlL7jo/beQkZ3F0YsXMDc1o3Oz5nrhT6fT8UH/5jy6f5ua9ZqxZuf5t37smn5gZQ45edCi3gs7xCJo+errgLNPICYbwtPBxRxczV9dHrj9EGatACsLWP6xEDftZUQiEcP6bWZYv836bX+cms/hU19gamLLJxNCsLZ8e+nrs9RFNAg5THhBNgs8azPLIxCAq9kpfBETAsAtiTU9gcTEO0gkcjRAdk48UokRao0Sd9e62NtWIj3jCSKRFJ1ORa6xIOwVyU34MTmOY4Hvv/Ah4bugXXhu2ohOK4iNClsV1p4qfLtmUZjx7DcAaCQS7L0VPMhTA2IQ6ejfwJcNsqq4Jd+mQcRxBnzRkNsRkQBI5NBghIyUdCHl6ZMzZiReN3t2YA1r5i7F3k3oW8ZjOS4NROi0UJQrxkihAp0g321LuI9qzyhk6Zkc23qMz+ce5XCUkLU3NzuHiND7VKtXv1TsNgAXT3fWndlTofMfEXWBP87Mp7JXSzq1+bxCdQwYMGDAgAEDBgwYMPDfy+vTxRl4Jcr0XL7/fgtV3nmf6Ss3CBuL1MIfCLHRopMhOglyhQdDcgsgJau4zMuoNGW/BjIyz2NvfpjEpDVExT0ss3peQS47jm4kv3plRBIJElNTrJu1JCktHmWR4PpUu2pDDq68xq7gPRwJOUwLv2agg5a+JV2SavjWLvMYlSv7IRKJkEqlDOvUh94tOzHjvfGYmAiWKWqNmp177wCQk6MmODiddfuO0HL0NHadvKBvp5Z5DrGHP+fML1PITn2KmYmEBykK7j+Fozchp6D4mCnZyey5to0i8wJkxkIgKDsbOz766AbHjyfyxbcxhBy5AVePChW0GtCokUqgukcNRkyxwMk1Azu/cKamdeHQTxP1bXtZOrG/9wJWd5iCXCIDRw9o1Am+7gld34eu1WAASI2MED8TioxMyk6daGdhybbpnzG0dTt2fDy71P4JX8EXq2Dsl4JB4n8LZ64FEf4kmhthdwmLjNBvLyzI59F9wVXv3u2gvyWNuasD7P4ODqx8M0utpz9Fkn7zmfgsFoFJxdYIDp4V3ECj4+Bi6TwO5OWns/LndixaWYu4hDv67eGPzzzbn0ZC0r2Kd7QChOZlEF4guP7uTXui3+4sV2DyLCtmFSt3LC1caFp/DHUDByGVGlOtShcmvn+aHh0X8f4QQRyysfZEpxbqdAz5EffkUNyT7+B49H28UoTvUqosQJacRZXrJyjMkCLIYmDpWYRWB3b+Stwa5/PYriYqsRyJToOtTSXkpmIs3JU07OfJDSsXmtzfRtt7G7HLe8TtiN+eN4NGBd6mw8iJk5EcakzSbROsfYsveL/aNfCpUQmxVEf1/hlIjXRIRMZYucqI/t2eD0NyMBVLuXDrV0wKM3iwx5rbe5QMb9yNjNQ0VEVFDG3Qmfea9WRKr/f+8vnfceBDHkac5NDJ2cQn3v3L7Rkw8P+FuXPnUqtWrX+6G+XSqlUrJk+eXO7+f3v/Ac6ePYtIJCIzM/Of7ooBAwYM/L/gv2Vcrcg9asSIEfTq1es/0p//RQyC2V9AmZ7L4cBPmLPhNyKexvPdgWPEpqULO59blxUWCb5GAPlKUKkhMQOy8iApo+yGrczAXCEkI7AsFmVy83O49SAIkQhUahVxyU/KrD5h0RCmLR3JgP2fUeXqNZo9eIJFnbo0DGjO1GFz6di0F1+OX4mTnQtnf37Ar98cR5uWInT7zn0qe1RleI/x7FpylgUf/VDmMRo3bsaCBYv5+qsl1K1dl24t2uPq74tWqyU4OIhPZk2myGYb4uaZuLfMp0FjER8sXMmFW/d5d9Y3elFFvbqQdmtXEnBwJBkPr8GBjQxJW0O92BjkUpA9M8orUhZyMfgo2vwc6qRlMrROU8aMHk+3br2oWlWIym5posXZSivEtMpOh4MbYP86SBKs0bzqm5FYZy+pVQTBLiHy5uu/ZEtgATAfMAcXvyrMPHaQQYu/4oNN68qt1r9ZKzZP+YTG/iUzPOp0kJAqvE5OF34O/y3YWdsAgmWVjaWVfrvCxJRJs5ZSpXptps9diUgkQqPREB8bjUajKae1N8fYSHBtrCjJdzL5fUsMl36MJyKoEAZUA+uKuYu2rCcYhFqZQ91qpfffDN3Jw8hTxCXc5vSlZfrtndt+gbNDdeoEDMCvUpuKd7YC1De3o4u1K7ZSI6a5Vtdv9zQ2Y7lPfSSIuIScjuNu0KvzYq7d2oxaXUhY+BEUxlZ0aPkJVhZCDLeMnCQ0YkE8l2pV9LixlB43vkOuLaLTrR/pu38mNbrOp3rfRRgd05H91IjnaQFCPdqytv0qDtadikosQysSI9cWIQISUm5hWzUXVaYNQcfTUHX7lChJNSQFghCmVWnQasQU5Yh5sNcKN6faNPFZhFlBE6QmWjIeGyM3V+Pka8mwT99l3vqfGPR5J6QK4dgqlZKHh+Qk3C3i0sxlqJPTMYlOAKAoXxhz83PzmNFvNDmZ2UQ/FKzZrl68wsOoc6XO6c0LV/n5qxU8efT4teff2UH4IZgobLAwf33iCAP/XSQmJjJhwgR8fHwwMjLC3d2d7t27c+rUKX0ZLy8vRCIRIpEIhUKBl5cX/fv35/Tp0+W2m5aWhpub21udlM+dO1ffj/L+oqOj38qxXkYkEvH777+X2DZ9+vQS5+lt8DqR623yZ/rv5eXF8uXL/54OlUGTJk1ISEjA0rJ0AqXyePl3YmlpSfPmzTl3rngsjI6OLvc3tGvXrr/jo/xPUd5D7MsP6mvWrKFmzZqYmppiZWVF7dq1+eabb0rUyc7OZtasWfj7+2NsbIyTkxPt2rVj7969f8tCpQED/+2MGDFCP57JZDJ8fHyYPn06eXl5/3TX/vWUda+vaLkzZ87QrVs37O3tMTY2plKlSgwYMIDz54s9kMoSK+Pj46lRowbNmjXTb7916xb9+vXD0dERY2NjqlSpwujRowkPD38Ln7LiGFwy/wK5Ucnkx6VTTS4lyEZFDQ83HCwthOdK8TP3HzOFYFGm1QkZOF90CyovzplEDI4lfcC0Wi29JjflQVQoMrERTaq1pXX9sjMtJqULD5CFygIKTI2Q2xbHUpo69Aue7LxK9JRjmL5fhFvX2lhb2KAd3xkUxhQ9jeZrU0c8OjTBuWbLV35+Z+dnAdRTE0h+dJ6bjzMosrLl0LrDqNUqUn36oJVaEavV8fvNixhJVSjVcsxkkJychKOjE7ZX/BHpxDg8rYVSmwuqeMRiaJr0iKpdPTB+lvjg2KaNPIy4SZ/mtfBRavGxLORepuACunFjQwY1UFPj+nYck0yhZRuIi4Rn1nTERoKjBwNbtGbzneOcenQdIytXOg1cVOLzrL99mKc5KUyt3xdLI8E1bOPGxzx+nMvUqf5YWwudqdG2DTVaNCPzwu8sir1O1YCW9Krd9ZXn6jkiEXwxDg6fhw6NwUheoWr/ClrUrYergwNmJiY42tqV2Ddo1BQGjZqifz/t/e5cPXeURi07sXzjkf90VwF439acW7ta43Y/k1WrwsCh4vHLmteFI6uEAP1lZbX0dm+EXGaCSl1AFZ/W+u1VfFoxa/LfY32UGBGN+ZSfcGvkzZJeJmRrVIx2qMTG7QPZILFC49ocjU7HuawkGjv7IZHI0GiE7L9qtZKQu3s5nliZX/MzsDJJwNncHYecmFLHEaHDJl2ORiKiyMsKtcoCkUSETqMj+4NGxA3sARIxMQ6BnAkYSd1H+4vrisC9aS5xQaZIbKU4Ns6m2tlfELlCfqoEnU5HRoQCM2cV/UZ+ROtenbkc9Au3Tt8DnXA7KsqRkpiTxceDRjEw+Ayr6zTD7pAIx4vBxD9Kx6dDFg4BBcRcNEU9+Fs0hSrUI9ow6HNnNk0/hU4LN85ewdhEgfrDHoj+OE/lGtGsXNcKG2V3Rn+4AvdKXsQ+fsKYNn3RqDX88PkihsztSO8RH+Dj0bjM8z+s3680rDMcZ8camJnalVnGwFtCo4F7dyE9HWxsoHoN+BtjP0ZHR9O0aVOsrKxYvHgxgYGBqFQqjh07xvjx43nw4IG+7Pz58xk9ejRFRUVER0ezZcsW2rVrx5dffsmsWbNKtT1q1CgCAwOJi4t7ZR82bdrEpk2bOHv27Gv7O336dMaOLQ6dUL9+fcaMGcPo0aP12+zt7cuq+rdgZmaGmZnZ6wv+S/m391+lUiGXy3FyenOhvnr16pw8eRKA9PR0lixZQrdu3YiNjcXS0hJ3d3cSEhJK1Fm7di2LFy+mc+ey55jR0dF4e3v/V4o0Wo2GiNthZKelY2Frg2/NanqvgX+Kn3/+malTp7JixQpatmyJUqnkzp07hIWF6ctkZmbSrFkzsrKyWLBgAfXr10cqlXLu3Dk+/vhj2rRpg5WV1T/3IQwYqAA6rYa88AuoMhOQWTljWqU5IvHfe/116tSJjRs3olKpuHDhAu+//z55eXmsXr36bz3u/yqrVq3io48+YujQoezYsQNvb28SEhIIDg5mypQp3Lhxo8x6kZGRtG/fHn9/f3bv3o2JiQmHDh2iT58+dOzYka1bt1KpUiWSk5PZtWsXs2fPZseOHaXaOXv2LCNGjHjri4YGC7Oy0OkE66/IBCEu2TO0ajUphw+S91CYPNvU8abKuHZ8YurH8Q8ncHXzMuSONuBqVxyvTCoBN3vwcAAjmfDe1RZszYX4ZBUkvzCPB1GhAGh0aoyyrMqdrCyZ9jPvtB3Coomr8fMqtkS5dvchG3Ye4eKQH3n6+3UuDlyp35cqdoSCfELvhZJ99Sz33h+GpiIKvE4HFw/gkJJM2wwVWXnp2NkLD5OiZ25iiLWctp1K9wZy2nqZ0qmSOVFRgkWHuMezMvXAKDAQ8iygUI7ogT+2FsWHKVIqyX2UwKUTuYDgymjvaQfLQN5eQreb5nilR8KVO3AnmNzrVzlxR06G0gg8hQjxOnQcL7yOyk3LGTMJjlWKg2EdibzK6GNLmX95Mx+fXQvAiRMJjBwZxIIF95g27SZanRaN9pnFVFwk4+8fIiovFaM7l3kYVuxm+jpa1IVvpkDbtxAE/j9NJXePUmLZy6hVKq6eE9xir547Sl7+f8iMTquD6wlw+Sk6pYa7z27Ccf6WVN5YTqrLV2CiKFssA3BzqcXc6Y9p3y6BM7eGER5dVqk7wEzg0hsfuyxWfP41D09eIrRZZW7lZ/BhxFVuhP9ByL09VIo4iEPOUxqY2zHMoRI/JUdh1/1n/Kt0YvA767kUvJblv83gm4QU7lpHcdGokMN1p/DQuRERTsK5eXE0saxqwtNdn/Fw81SujByP1TtrqDkyDVV7b0HQf4bOyAbbgpQS/cx6KkenEaFJ1iBKKuDRflPubbemIF3Kw9+teXLWnLAdNnTq8y5qlYr9yy+ArvTigVamZnxkEI+tZAT3a8rTsDR0aHCum49ErsPMUY2kUAWAcbo7E6ds4b2ZEzCzMGfA+PcwMTOlx4wPkM4JwKGGIJ7fvnGaz4dOAEBZUIhG/ex61sHJvfv4eHQX9m38tczzL5XKqe7XBRsrjz/1/RmoIJcuwshh8OnH8O3Xwv+Rw4TtfxMffvghIpGIa9eu0bdvX6pUqUL16tWZOnUqV69eLVHW3NwcJycnPDw8aNGiBWvXrmX27NnMmTOHhw9LhklYvXo1mZmZTJ8+/a3218zMDCcnJ/2fRCLR9+vFbS+j0WgYNWoU3t7eKBQK/Pz8+P7770uV27BhA9WrV8fIyAhnZ2c++ugjQLCqAnjnnXcQiUT69y+6ixw7dgxjY+NS1nQTJ06kZUthES4tLY1Bgwbh5uaGiYkJAQEB/Pbbb/qyI0aM4Ny5c3z//felLObCwsLo0qULZmZmODo6MnToUFJTU/V18/LyGDZsGGZmZjg7O7N06dLXns+X3V2eWwUtWbIEZ2dnbG1tGT9+PCqVMN60atWKJ0+eMGXKFH3/nnP58mVatGiBQqHA3d2diRMnlrBmSEhIoGvXrigUCry9vdm2bVspazWRSMRPP/1Ez549MTU1ZcGCBaVW4zdt2oSVlRXHjh2jatWqmJmZ0alTp1Lil1Qq1f8mqlWrxrx588jNzdWvzkskkhK/GycnJ/bt28eAAQP+1SLinyHk7GVm9xnF9xM+Y+PcJXw/4TNm9xlFyNnL/2i/Dh48SP/+/Rk1ahS+vr5Ur16dQYMG8eWXX+rLfPbZZ0RHRxMUFMTw4cOpVq2a3tIiJCTk/913ZeD/H1k39vJghhePF7fm6drBPF7cmgczvMi6sfdvPa6RkRFOTk64u7szePBghgwZUq7l1OvuTQC7d+8mICAAhUKBra0t7dq104/xz+8dX331FY6OjlhZWTFv3jzUajUzZszAxsYGNzc3NmzYUKLNmTNnUqVKFUxMTPDx8WH27Nn6+82LrFmzBnd3d0xMTOjXr98rrdaPHj1Ks2bNsLKywtbWlm7duhEZGanfX1RUxEcffYSzszPGxsZ4eXmxaJFgSFLevf51xMTEMHnyZCZPnswvv/xCmzZt8Pb2pkmTJkyaNInr16+XWe/OnTs0a9aMhg0bsn//fkxMTMjPz+e9996jS5cuHDhwgHbt2uHt7U3Dhg1ZsmQJa9asqVCf3hYGwaws1FoheJZOBxnFE52H0yYS0q8HVxvXJj8yApFIRINVI+kZuph2IztjYmYK1mbozaLKQ2EkWJ6lZEFqVrHL5iswMzFn9pgl2Js7oZCYElkUQmZOepllq3oHsPKTLQztXrwCHf4klubvz2DMNz+QJRMEDJnLM/82jRbrL+fwqPa7yF28ADBydUNsbPzafgEgEVQFjUiEu603n3wyh/HjJ7OuTzvMkhJp0Pw7TExT8e6ho4GfF/Vq1aZWrTpC3Y+AC8BqwNICOg6HwjHwiSvYCKuBAC37DyfFpB8JFr48sGlGWs1uOFTxgW1APhBWG3K/BN14sFDQaaElHRZY0OgLe9RWQqZNsUhMT98mAPQ1ceHIDx/yMFgI2i99YYXj+WuptPjyyFXn4/xjP6xX9ORibCjYOGIilvGTbS06mzjhHV68Evi/Tn6RDM+GX4DMAZH7Z1wK+fOGrPlReaSdSuK+UseOfMh9Vcy3B6lw6SkEJyAKjucrS6glg3mWIszM374xbfCdS3y70ZZD52DOj2WV6AwsBjoCBWUVeC1FqgKWrW3B5NlGyKzyATCOSgTASavESiFYj1rlJzMk6GuCanXlRGY8Ex9fY45SQ0abr2lSfxSpGY9RSWSIVc/Ogw4kpvacrDWWs9WHsbPxHB64NiPbWHC7lbnVI9NCuP6zfDUUKbqjsFeQYeZaon+5YjHohGtUJZaiKoT7e60QiXWIJDos3ItABznxMh7ssaYgVRgrdFpAJ6KwoBC1suT4J1FIsKuWj1/3dNz3X6TyuFU4bTyJwtQErUpMeoSQOfi5du3q48F7nwgP9BO++oxlBzZh42hHUmw8s+z86PG4KpkR1qSEGRN/zRRjEwWpicmc2HWQPh8Mw8rOBoWVIMJHHjdm/siPObP/KDqdrsSiRMTdB+xctYn05FQM/E1cughffQmpL53j1FRh+98gmqWnp3P06FHGjx+PqWlpK9SKWG1MmjQJnU7H/v3F1pZhYWHMnz+fzZs365PL/NNotVrc3NzYuXMnYWFhzJkzh88++4ydO3fqy6xevZrx48czZswYQkNDOXDgAL6+vgAEBwcDsHHjRv2K8cu0a9cOKysr9uwpTqah0WjYuXMnQ4YMAaCwsJC6dety6NAh7t69y5gxYxg6dChBQUEAfP/99zRu3JjRo0eTkJBAQkKC3hKqZcuW1KpVi+vXr3P06FGSkpLo37+//lgzZszgzJkz7Nu3j+PHj3P27NlyV7RfxZkzZ4iMjOTMmTP88ssvegtAgL179+Lm5sb8+fP1/QMIDQ2lY8eO9O7dmzt37rBjxw4uXryoFxwBhg0bRnx8PGfPnmXPnj2sXbuW5OTkUsf/4osv6NmzJ6GhoYwcObLMPubn57NkyRJ+/fVXzp8/T0xMzCvFWaVSqRfa/Pz8yixz48YNQkJCGDVqVEVP1X8FIWcvs27WIjJT0kpsz0xJY92sRf+oaObk5MTVq1d58qTsMCtarZbt27czZMgQXFxcSu03MzNDKjU4DBn495J1Yy9PfuyLKiO2xHZVRhxPfuz7t4tmL6JQKMoUo+D196aEhAQGDRrEyJEjuX//PmfPnqV3794l5oqnT58mPj6e8+fP89133zF37ly6deuGtbU1QUFBjB07lrFjx/L06VN9HXNzczZt2kRYWBjff/8969atY9myZSX6FhERwc6dOzl48CBHjx4lJCSE8ePHl/s58/LymDp1KsHBwZw6dQqxWMw777yD9lnw7BUrVnDgwAF27tzJw4cP2bJli14Yq8i9viz27NmDSqXi448/LnN/Wcm3Ll++TMuWLenduzdbt25FJhOeE44dO0Zqamq5bf2nLWoNI2xZSMWC6FVYBGbFolF+hLAipy0spDD2KSaVfEtVzc3N5cyZE7i6ulOnTr1S+/Wk5UDeM5dBY3mJTJjl8UG/aaRlpfDTziWICqQsXbmQ+Z8uKXGjjIxNoN/HC5FIxOz59nNcbWy48t5PXH8chUqtBhHsbmuCIvoU3l0b0AdABDILBZVHtMWzX30yIkOxatwMUUXM1EUirtk5oI55SPWm79DKxQeAunXrUxc4LO/N5rxdFEkd6Ft3PPXbdSuuGwNEA01eaM8ZGC0iPyeddeNakBb3iL7TfmHtLl/W/iYHimjUzgV/f0chTllNDdy2J98ym9tWcdTKboNCVUDIEyGmzKOoQvLjk7BQO0Me7JHMoyBFyS/3O3FDe45bpzfTZcwyqldqxP3sTagzNPgMFdweataUMmGCmqIia9wGJLErWIg5t/3+aZq1n8RX/eaTe3YvFjqQW5a2unruiWtRdm6A/5ecC4Y5q0Bm+gXShl8gl0El9z/XVv7jXK7UPk6aqYxZV7tQKJPwRyFssimr9HWQrQGeuSTJxAw0gYHlnvs84FNAC3wNvOHqbBKcOjgfkagdOp0FZiZqSg+nz99LeB7/601JTVuDl9sF4hPBuuZDPjn4M0fywoi9sx7v5Fuc8GqGVGKERGJEz16ruP3kKqGRF0EmuGNdy0klW11E8/ZfcWLvh1irb6DM8SLHPJscrRqvpFt0uvUDaomc4zXHcjpgJF/KVDRHze9R54ixbohHiB8OVl9ysfGH5JqU/J0nW3iRnG2Hg1kWmdhib5xI3fdT8bJ6h/jCY6Q+FunFsZe5fvYK/ccNZ+SnE9iwqNjaVVuoJTXMBLEUbO8eQqcF07AnBG7uS8iYw9zfZYVUoUNdILTZuldnajYWxtrkuAQ+7DAIVVERx7bvp0rNahz97XfACDCicYdW+NepwejWfYh+EIFYLGZP2DmMrIqYP/YjUkLvAxB1/xHzRk5FLBGz5tQunNxdeK9pD3Kzczi0eRebrx7+U9+ngVeg0cDa17hIrP0JGjV+q+6ZERER6HQ6/P39/3QbNjY2ODg46K2glEolgwYN4ttvv8XDw4PHj18fI+8/gUwmY968efr33t7eXL58mZ07d+pFpwULFjBt2jQmTZqkL1e/fn2g2M3TysqqXPdAiUTCgAED2LZtm150OXXqFBkZGfTr1w8AV1fXEsLOhAkTOHr0KLt27aJhw4ZYWloil8sxMTEpcZzVq1dTp04dvvrqK/22DRs24O7uTnh4OC4uLvz8889s3ryZ9u3bA/DLL7/g5vbm2Yqtra354YcfkEgk+Pv707VrV06dOsXo0aOxsbEpYdX3nG+//ZbBgwfrY69VrlxZ72a3evVqoqOjOXnyJMHBwdSrJ4xZ69evp3LlyqWOP3jw4BJCWVRUVKkyKpWKn376iUqVKgHw0UcfMX/+/BJlQkND9dZH+fn5mJubs2PHDiwsLEq1B4J7YNWqVWnSpEmZ+/8b0Wo07Fq+9pVldn+/jsDmDf8W98xDhw6VsgB7Mb7rF198Qe/evfHy8qJKlSo0btyYLl260LdvX8RiMampqWRkZPylMcqAgX8KnVZD/LZJlPRj0O8FRMT/NhmL2j3/dvfMa9eusW3bNtq2bVvm/tfdmxISElCr1fTu3RtPT08AAgICSrRhY2PDihUrEIvF+Pn5sXjxYvLz8/nss88A+PTTT/n666+5dOkSAwcOBODzz4szr3t5eTFt2jR27NhRQiwqLCwscT9buXIlXbt2ZenSpWXej/v06VPi/c8//4yDgwNhYWHUqFGDmJgYKleuTLNmzRCJRPrPAxW715dFeHg4FhYWJers2bOH4cOH699fuXKlxDl75513GDBgAD/+WNLy4NGjRwD/mnHPIJiVhUgkuE1qtMWulUCVb5YRMedTzANqYt2iVZlVN2/ewPXrghI9Z84CvLy8yz6G7IVBQVrxAaKmX328zKviY1mDxKgUzpw5Sfv2nfT71+07Ski4MDnfeOAEI538id52GTdbM76bPYDbT54yum0D+i/fQNvqzzLHicXgZgf5Rci9HLGs6kVkbDiV1XbIpGX7pEU+fUhiahwONs70ndsTrVZLh3vn2TB/f4lyLRp70oIyVu7igSFAIdALeCn0S/TdCyQ/EbIM3ji+gfz84klgfr4aIoBlaaTZhRPc9AmXo4+hVWt4XOcGQ6rOZe3PTfhx5QMGBSRgEbQbLjeAiw0RIcIEYzrLFrPOqiFatZpDqz5CIpYzOeU+Nlof2AR8Cr/88jO5uULGwMa2H+JkakO+Ssmgqm0hH+zzXKHre5CeBA4lVaG4NNh7WRDMutYHX2dh++bTxzkTepspPfoQ6O1DWmwsxmZmmP4/iT1x/qbw3KvRwNBu0LMNOL2osZyJhogMqOcMtV89CBdE5qHJ01DgZELhs+sludwcAguh8u/Q6Qkop0D1V4jVAKwAnos0jkDpbKblchr4FOaJr/BFrREkW1Vn0aRPyyh4DNgOdAUqaK1Zgvs4O07jnS7g4wlpGUNo06wLVcNUrN0iWNrEJd5BpVajUqsYERNG48PTueTXHxszLZmmjhxKj+W98EuMdfbjQO0PAXCTq8kRQpvhl3IHiU6DRF2AZX4yiMQci7mORW4UrSNPAhsBSO2zkvtiT16c8Njm5eJ88Bz2Fmkg0mGHYPlmY1mZXNOLiHS52FeFxJsqsmOMkJlqUOWJeS4e3r4cTP9xw5nw1Wf41qzML8uXYmqv4+ZBIa5aUa4EEwcVeYkyTOzVXJPrqHL4O4y+38ud/SfRyqVELRrGnBpueKc+obedJ1qtVm+V+jgsnNSEYssNI4UxZpUSuZu7E4mnETwQgmdrtVqcHaux9NeD/PLtKmwc7Eh4EktWuiCQn9x9iH7jhlOQJ1j4ZaaWbdlr4C9y725py7KXSU0RygXWfGuHfb4yXNbK55u287yNTz/9lKpVq/Luu++WWz4mJoZq1YoziqjValQqVYkH63fffZeffvrpL/XrZX766SfWr1/PkydPKCgooKioSO+OmJycTHx8fLkPExVlyJAhNG7cmPj4eFxcXNi6dStdunTB2loIQ6HRaPj666/ZsWMHcXFxKJVKlEplmRZ+L3Ljxg3OnDlTpvtZZGSk/vM0blwch9DGxqZca6pXUb169RJurc7OzoSGhr62fxEREWzdulW/TafTodVqiYqKIjw8HKlUSp06dfT7fX199eflRZ4Laq/CxMREL5Y97+PL1mp+fn4cOHAAgJycHHbs2EG/fv04c+ZMqWMUFBSwbds2Zs8ufT+sXr263gLq+TXz4vfg6enJvXtvNzP02yLidlgpy7KXyUhOJeJ2GFXqBLyy3J+hdevWpeIlBQUF6ccHZ2dnrly5wt27dzl37hyXL19m+PDhrF+/nqNHj761McqAgX+CvPALpSzLSqJDlf6UvPALmPm3euvHfy5YP7/H9uzZk5UrV5ZZ9nX3ppo1a9K2bVsCAgLo2LEjHTp0oG/fviXG8OrVq5ewKnd0dKRGjRr69xKJBFtb2xJj9e7du1m+fDkRERHk5uaiVqtLLWp4eHiUWPxp3LgxWq2Whw8flilqRUZGMnv2bK5evUpqaqresiwmJoYaNWowYsQI2rdvj5+fH506daJbt2506NDhTU5tmbw8TnXs2JGQkBDi4uJo1apVqWRwPXv2ZN++fVy4cIHmzZvrt79JjMwX70UajQalUlliW/Pmzfnjjz/e9KOUwCCYlYdIVErIMq8RQO29h0oVzbz7lAcrjuLUpjo6XbHP2PMfZ5nYmAuWZVKJENvsNajzChEbyejavA8ZcdmcPi4EcVUoFFy/d5mQh8H0aTeUNvVrsmzrPkQiSE67SYa1EVYm1yjKMsMq0pqBLf05cOc3tn9zkmZ1XpgUy2Ugl6HRaOgzpTm3w6/TtmFXfllQ+vOGPb5Dt4/qU6QqYkjXD9BqtShV1ly8U8T5m6G0qMiEIxlBLAN4boUeD8wCrUiL5cRq2LpWISP5CZ7tB9Oskgv29sZ4eprStasrDILCcB/q3b1PvjGMbi1cgAVF+bB7GYM/GM3gNlXhgqBQ4xov/JcBKrhs/duzZ3/hgtRoi8gXpwuCmRPExubz/VoT5JpAGjW+h7+tJ/Ef7kKr0yLJlZA3MIv01ARcB1ZBPLF4wvqc+DRBbwWITRUEs8iEeEZ8/y06nY6QxxEsr9WEdaPGYmJlxfygCzhVLm2x+N9Gz9Zw/R5YW0DfDmBr9cLO3CK48+wGERT3WsHMpq0DHhMrYxOaxRdZedx2NGWcqAjUUsEKtARNgd/B7wqCEPY6FyiXcl5XgCBACzKtgsnVF2A2yh4TRVnXsD8wt8wm7oTtJzk1nKYNPkBhXPZKPygRiYQfUUDVtojFQlKFwGo9GTVoF3kF6TyMMuKXI+8gFqsZ6/s+bRpoiE9WcDbLUd9KurqIepjwTqyKRz42LPZtwMbkCB4X5JDs0xHPtHsYawpRSk1wTwnF98EuVI7FsQ+zjO24IFKgeXat2GVE0fzhbxRJTLB0ikNU8Gwy/6y8vas9148mIZIbYeOrxNKjAJPW5njax/DogCXp4YI17bn9xygsKEAml7Phh5lEXC3AtXEuIokJOo2IzCg57k1zsaikJtarJqHODbhFNkO+HoNPRAy3FVpy6lcBYP69q7zTwoPsokfUHiTi+hahL4X5BTi4OpOTmcXna77l2L0RyNHiVKcAN/Mu9Bo6Gp+qQhsmZqaMmzcDgLvXbrFn7RYkEglt3umMnZMDi35bzaU/TtPvw+KVMgNvkfQKCpEVLVdBKleujEgk4v79+386JXtaWhopKSl4ewsLZKdPnyY0NJTdu3cDxRM/Ozs7Zs2axbx583BxcSEkJETfxt69e9mzZ08JsaU8K6A/y86dO5kyZQpLly6lcePGmJub8+233+rdTRSKimURfh0NGjSgUqVKbN++nXHjxrFv3z42btyo37906VKWLVvG8uXLCQgIwNTUlMmTJ1NUVPTKdrVaLd27dy+VPRAE0eH5ivTb4LlbyHNEItGr53TP+vfBBx8wceLEUvs8PDxKxbh7TlkPBq8TD8vr48ttyeVyvUstQO3atfn9999Zvnw5W7ZsKVF29+7d5OfnM2zYsFLHOnLkiN6N6fmDz4u/35f78m8iO61iY0ZFy70ppqamJb4DgNjY0gJCjRo1qFGjBuPHj+fixYv6jKYtW7bE2tqa+/fv/y39M2Dg70SVmfD6Qm9Q7k15LljLZDJcXFxeOVa97t4kkUg4ceIEly9f5vjx46xcuZJZs2YRFBSkv/+XNS6/6n5y9epVBg4cyLx58+jYsSOWlpZs3779tfE3nwtT5Qnp3bt3x93dnXXr1uHi4oJWq6VGjRr6z1KnTh2ioqL4448/OHnyJP3796ddu3b6ecufoXLlymRlZZGYmKgX8czMzPD19S3XbXzNmjXMnDmTzp07c/jwYX2s0ypVhLn5gwcPSiyClcWL96KgoCBmzpxZIoHS25jbGASzt8DFIT+SH5NK4rE79D4yFWdnF9zc3PHxKS2k6BGJwNSYOT9OYvvRnxnabSyzP1hSZtHoHVe49O4qFM5WdLoyj8H9h+Pp6oNMJsXVy5UW71XB3tyeG6EXWf3FLu7vWkWHcTXZf/og1dYqqKIrwEgGnk0+IkScw/Sx32Bn7VDmsXLys7kdLgTlC7l7g+3bt1CrVh38/YtXwqPiHlGkEi649KwUVnyylcGfbyMtVkv3KXNJP72zzIDDJagFjAQeAuOAJGARcBfEiEndlU31j5ZgqbAkPOkBsdFHmfH5O9gl2qPpUIS2QEMmKqKL8qDImuiCdvRvkk1TR2c4vBfq14WWLcGjCmSkgaoBNAaGCscy11aHtWLQalG4+eJj3AUb72roaumYeSSEX2c9JjHBFrAlt1oam10FVV8ikpAXlsUK3XjyHDKpf74TPSd+VOrjVfOAqCRQa6DmMyNDU2NjFHIj8pWF2FlYcvuP4+h0OvIyMnh0Nej/hWAWWAX2ryhnp4kMHE0hKQ+8rV7blkgswv+7WgDUA7gsxCfDyggG1gCjF39j04EOgD2CX+/rGA7YIbhkdq9A+RfoB4QAZuAwqDK84Tj8OOYKa7f0AiAhOYyhfTeWU7IW8CtwA7F4aok9tQP6EnJ3L9FJNdDqLPB2ucPH1fYBsNLsV5pcnIxzQQoat0b0sHRheIPORCUn4/JhX/y/aM9Gz0Aanv2Be+ae3Gq5mE/UqQReX8t1785cqDoY4wc7kAB33FpilxtH15MTOV91MNEOtehxYykKlZB847z/IOpHHkChyiNHbomJOp/ouIsY2Uu5s9EOha0Klwb5FIVkEnTbCbl5cQKIwoJCVEUqHty6S0ZqOqAgJdQYnUaMTiwCkYjYy2botCKUCdk4Kk6T3rEOYotsBn40kvBP5iNPSKfI2YaU1XsYNHkd4bfv4VAzH5+OKswUTtjZeXB6vfCQum/9VpqP6821kF8wk3uy4LdtSKVlx5us0aA2Z9OEuITPx7L2/brTvt8b/lYMVBybMn2t/3y5Ch/Who4dO/Ljjz8yceLEUkJFZmbma2NlfP/994jFYr3gtmfPHgoKiuMWBgcHM3LkSC5cuKC3CJJKpSUeoh0cHFAoFKUerN8mFy5coEmTJnz44Yf6bS8GATY3N8fLy4tTp07RunXrsppAJpOVWiEui8GDB7N161bc3NwQi8V07VqcSfrChQv07NlTb2Gj1Wp59OgRVatW1ZeRy+WljlOnTh327NmDl5dXmZNvX19fZDIZV69excNDSM6RkZFBeHi4fhL+tiivf/fu3Sv3O/T390etVnPr1i3q1q0LCC7Brwrc/HcgkUhK/D6f8/PPP9OjR48yM6y+6K7z/Nz/nb/Vt4mFbcXGjIqW+0/w3Po0Ly8PsVjMgAED+PXXX/niiy9KxTHLy8vDyMjIEMfMwL8SmVVF5uQVL/emlCVYl0dF7k0ikYimTZvStGlT5syZg6enJ/v27WPq1KnlNftKLl26hKenZ4ks22XFM4yJidFbbYPg2igWi/XC0oukpaVx//591qxZo7faunixdAxYCwsLBgwYwIABA+jbty+dOnUiPT0dGxubCt/rX6Rv37588sknfPPNN6VisJWHSCRizZo1SCQSunTpwuHDh2nVqhUdOnTAzs6OxYsXs2/fvlL1Xpybvfj9xsbGlppfvQ0Mo+tbwMrPmQ4bRyO3UKAyltO7d//XVwIKiwrZ8LugLqzd8x0zhn9JXl4ets+yEIY9jkEsFpG0/Qo6tYb8p2kknbuP9+CmNG8uTP4ePblPjzo9WDZ8OYXqQlCqcLKzRiQSzLeyjQVLG61YxNlHl5kya/0rAxBbmVszachs9p/5jRqmzTh+/A/Onj3F8uWrMX6WBKBD4x4M7TaWmMQoZr63EB+3KthYHCYxLQMzhaLM9qMiosnNySOgdrHlCuNeKNAHiBEyWWrFWpJ8EkjNTcZYXqxGRKdEYLpLhCLDDgkgbhDOt21q8fuVWHp/0IwedpGwZDFY20BAAIgl0LCjULkTJeie/z6NzJsRVHQOx+AA6u9vAlfgbG4i3y4RsqBammgZ1KwQSYuSg3iGdRJ5kkwAnlqVvWJ84ulFTuRdZWytHljL3OHkAZwKcrn9+WxOxiczoHkrUu7cJfrmLWzcXKnTvWuZ7fy/QiyCflUhVwUWr0mMURaPM4X/mUrIKACnl91yAt+wwT95zn2B0pmMK0RcEny13p+EtN14WL+HWq18TY13gXdJ1MC2fKgjh1ZGcOXGRpZvCiE11x+5VIVG7YpGY4dEkkp+ZCLDzn/MxvaryS/MYdqTGwQkJRDzw0juenvSKOQIO6T52Dy9ANU8MVdqCT93jgMtP0FtJFy7DllR+MVdJsKlCYHXhKw5rcO2IAldr++ZRiQl2dqXy5UHYlaUxgPnJgy7IMRbMHdS49kyhyfnzCnKkZJ0W7iOi3Kk+NbyRqQxZtCk9wm7fpuw1ETiVN4Ye2RhYaRD6luXk2Nbo5VLqfz5zyhuPMXkcQImjxNxPXYe06FJFDjN5UDQUc6fOM+3Yxcgy8jl+ZWYFGJC69l5FKmjyM2PxtzOi5zUAixtranuNIou0+dgaeGKTgvLZ84nJT+IXiNG4uvZik8GjCU3O4eFW37Ay++/42Hw/w3Va4Cd3avdMu3shXJvmVWrVtGkSRMaNGjA/PnzCQwMRK1Wc+LECVavXl3CsiMnJ4fExERUKhVRUVFs2bKF9evXs2jRIv0E7UU3OUCfxbFq1ar/8UC1L+Lr68vmzZs5duwY3t7e/PrrrwQHB+tXxkHIGDl27FgcHBzo3LkzOTk5XLp0iQkThOyyzwW1pk2bYmRkVKY7IQhumfPmzWPhwoX07dtXP3943o89e/Zw+fJlrK2t+e6770hMTCzxUOLl5UVQUBDR0dGYmZlhY2PD+PHjWbduHYMGDWLGjBnY2dkRERHB9u3bWbduHWZmZowaNYoZM2Zga2uLo6Mjs2bN+luSLnh5eXH+/HkGDhyIkZERdnZ2zJw5k0aNGjF+/HhGjx6Nqakp9+/f58SJE6xcuRJ/f3/atWvHmDFj9BYP06ZNQ6FQ/G3udmq1msREwV3+uUtmWFgYM2fOLFEuIiKC8+fPc+TIkb+lH/8kvjWrYWVv+0q3TGsHO3xrVit3/9/JuHHjcHFxoU2bNri5uZGQkMCCBQuwt7fXW1Z89dVXnD17loYNG7Jw4ULq1auHTCbjwoULLFq0iODg4H90bDFgoDxMqzRHZu2GKiOOsuOYiZDZuGFapXkZ+/6zvO7eFBQUxKlTp+jQoQMODg4EBQWRkpJS4t71Z44ZExPD9u3bqV+/PocPHy5TIDI2Nmb48OEsWbKE7OxsJk6cSP/+/ct0x7S2tsbW1pa1a9fi7OxMTEwMn3zySYkyy5Ytw9nZmVq1aiEWi9m1axdOTk76caSi9/oX8fDwYOnSpUyaNIn09HRGjBiBt7c36enpeovmsgxqRCIRq1atQiKR0LVrVw4ePEibNm1Yv349/fr1o0ePHkycOBFfX19SU1PZuXOn/pz9pzAIZm+BBsvfRZ4vPPjKJILVEjpA8upJmrHcmA6Ne3D8ygE6N+nD/PmzSUxMoFOnrsgdvOgzYyEikYjd/YYhO3UPU087nNuXdHes7FmVqf0+RSwWYyI3IezWLTwDqrPlq6OcvHqIni36s+OTkZxOuEP46T2Y+LVkXP9XuxTNGDGfGSPmM3PmFFIKk9FoNQT0tqVujcb8suAwRnIjFk0qGY/h7NpvOHjhGt2bNyg18bt7O4xPJ8xFq9UyZuJ79OxfhlCRJfwTSUWobdQ03t+CtNopmLtZ8CRViMkWkRROpXqOyA6aoRNpya78hOn5PZi6zo8rRqf4MG0KRXOymVZpC1Wtn62QBgFzEIyO5gK7EEJWHQH7SH86NfTlnt1ZTprMIVLpyEe7zyOWdkOrlnJiQRH13fLRiWTwx68Q2BRcfXCtUplGXbsTefsW1Zs3LRG7BiAlP5O+v89Fo9NyPOoGTzrPgQzBFdE3Px3n1t05EAQqTWM+uxmG3dv1uvl3IxGDpdGfq1vPGS48BRczcHi9u8q/ka1H4EG0NdAHx+oS+nZrWma5woICjF8wIZ6YCVeKhPQB5+zhYeR14rKeuZ6KVPzylQ2zD9zmScM73DCrQQObTlio8smXKtCJRDiMMSfCWYjZlaoqxNGrPg2PTMUr5Q45qTdJSn+PRnvvcHHQLdDpcFeqkWqU5Bpbk27qgk1ePBJNob4/D8y6k1vVDwsRPHRvjG1uHAUKKxKs/XDJEKQr+4ACrP0KcXR2JfU2FDwLnObQOo9PP9pC34DWKPOLEJtKMc4TLM9CJnXHWi1CbS2IoQU9qhPoEkrEYUt0WjAuyOGxYw32JUVi220AiqhkWnVsQVR0EIVFWShsi/BoXoBUZkGRGmQmOsav7caFdamc2nOYc/uPsTvsHHY2Ruxdt4XTlxfj0TyPX/Ycwd9yItdOCytw275fz2ervn6L37yB1yKRwJhxQjbM8hgz9q0G/H+Ot7c3N2/eZOHChUybNo2EhATs7e2pW7duqdhDc+bMYc6cOcjlcpycnGjUqNErLbL+TYwdO5aQkBAGDBiASCRi0KBBfPjhhyViewwfPpzCwkKWLVvG9OnTsbOzo2/fvvr9S5cuZerUqaxbtw5XV1d9ooOXqVy5MvXr1yc4OJjly5eX2Dd79myioqLo2LEjJiYmjBkzhl69epGVlaUvM336dIYPH061atUoKCggKioKLy8vLl26xMyZM+nYsSNKpRJPT086deqkF8W+/fZbcnNz6dGjB+bm5kybNq1Eu2+L+fPn88EHH1CpUiWUSiU6nY7AwEDOnTvHrFmzaN68OTqdjkqVKjFgwAB9vc2bNzNq1ChatGiBk5MTixYt4t69eyUExbfJvXv3cHYWFv2exzxbvXp1KbfLDRs24Orq+lZi2PzbEEsk9Js8hnWzFpVbpu+k0X9LwP+K0K5dOzZs2MDq1atJS0vDzs6Oxo0bc+rUKWxthUzY1tbWXL16la+//poFCxbw5MkTrK2tCQgI4Ntvv8XS0vIf6bsBA69DJJbgMvh7nvzYFyF4x4uimfDs5DJo+d8e8L8ivO7eZGFhwfnz51m+fDnZ2dl4enqydOlSOnfu/KeP2bNnT6ZMmcJHH32EUqmka9euzJ49m7lz55Yo5+vrS+/evenSpQvp6el06dKFVatWldmmWCxm+/btTJw4kRo1auDn58eKFSto1aqVvoyZmRnffPMNjx49QiKRUL9+fY4cOaK/l1b0Xv8yEyZMoGrVqnz33Xf07duX7OxsbG1tady4MUePHi2VJOE5IpFIn2inW7duHDhwgJ49e3L58mUWLVrE4MGDyc7Oxt3dnTZt2rBgwYIK9edtIdK9SVS1t0R2djaWlpZkZWW99RgdfytaHaRlg04HthbFgphWC4kZoNKAjRmkZAllTY3B0VqwrCkHnU5HelYqOZk5zJ8vBFp1dnZB51KdrzcKqd7nfvAuc0YPLr9fhUWo41OJjH7MD7s3UalyFSZPKc6sMXf1FH7YsZX03Lo09K3EyomjqNcg8LXJBpKSEgkODuLH3xcQ+kRw0zz0wzVq+dWvyNnSc/TACVYuXgNAx+7tmDhzrLDjOvAHgiedDDiAENfs1LOKo0AzRsOhm3vIKsjEzcaTNtU7EhtykYKUVLy+bM+YsFC2ZkbjUjuewO8+RizV0tx2ENOqPIsDMwM4K7xM8UnG/vFLrqgKWGzrSZYyBhUylie3RqW0ZMHI8XwWmIQoPUlfNB8dYRam1O0wkvjICNZ8PA2tVkur/gNpN7g4uHO2Mg+7le+g0qqRiiUkjdiIzeWjoCyEBu25ofLjwj14kvKA6u5y3u/o80bn08BfZ+1uuBMO7/eGWuUkYIkIusaK/kMwt7Pj4yO/Y+noWHbBl8jSwi954CuFLi+5ax48C99sEJ75f/gMAkonR2P1F9+ydv531G3ZmNUndiCTyeibBkHPBLOvYzZyePtvxGWuokjjS45DImvnSBj1hz1ZLYQ2at5awlQPHz4ogIjCHDrdWIGROp+7Hm3xcfBnb/MPOJMSBQ9O8M2GcQgx31Q4VfMn3KEhLSK2AzqyjWy4Efge0/3aE3f3N2LvbOOeeyvueLVn6LmPKZQoUEmNMVdmkG7qQkaWGZYJSZhb5SAz0ZJq7UWoZztsDt0mf9tTzJxU1BiSTnXfT/l53AYARFItOrUYnUTMw1XjaHvkFlen9SQzJx+fGRvwkT9AlS8hN1GKdSsZx6YuBLEY40fx+I9agYWtOQ6NYnEMLECnE7zdASyNK6NN9cAovwYXDp4iPVmw8tkechK/mtX5Y/cW9l8ehtRYuAXW8x/H6jFHUBUVsei31XQc0LNC3/f/Gn/7/fvSRSFb5ouWZnb2gljWtNnbP54BA/8gsbGxuLu7c/Lkyb+cbMHAqwk5e5ldy9eWsDSzdrCj76TR1Gr1/ycrqAED/0aybuwlftukEgkAZDbuuAxajmXd3v9gzwwYeD0GC7M3ITsPsvKE12Ix2FkIGZCK1EhchFUgMnMFsQwgr1Aob106o9NzRCIRtlb2WFvY0qBBIx4+fEDXrj3wqlyNG2GPkEjEfND7Ncq1sZwkIy3fbBFWwvMzsiAnH8xNAJg9ZglxqTYcOR/GmTkzMJbLICkDXAXXz4iIcMzMzHFyKul66OjoRLduPYnPvEXrR9YUiGT4eVbndcQ9vISqqACPaq0QS6S07tiCB3fDycrKYeDwPhQU5LNs2bckP0hk5NMPCDxeC84AdYAbwHM364YgEUtoV60LQUHXqO0sZJZyq9UMsiFSHMemNCHV+pPrzniHBmJV6zb1rAULNpVGjayVFN15HYWmBWTZphcLZh7AU4TkhflakIBMLEIiFuHrb8X49+si0hXBg+sQHw0qJfceXuH3y9uRyo3JzTBCq9ViZGpBYkxcic9vYWRKJStnHqQ/Ra3VEKHKoUHXEaBWgZECtwy48Gg3e+NWIbop4v7Tvkzs0RtPB0ficlIYengRKo2a+s7+NHSuyoCqpS0XYlKSuBh2l0516mNj/t8gOp8CtgCDEBTSf47waNh0BHKaQvh1OF6OYHZy9VrSYp6SFvOULyYfoNuk0bRr9Pr2P8+C358ZY+2XCG6Uz+neCvy8wEQBbuXobwc2CibGN85dIe7xE0TmvozNgPruUE8Op39TEJV2HACtLAdFriWaRBE9zWFLAcjE+VRKPM/+9GCqya1oVq0PPm2/5MzWWOqn7MZEvo0Pry1jf+BYmiYH42IZQZLyA4ytt2OXE4NT9mN9Xy5UH0q0XQAfxocjSXBHU2UBSi97ep0TVnaMNQUYa4RYODZ58WSf8ORhiAJQ4Ncrgwe9m/DUrjoPP2iCS897uMadRJKSRr5ZOC4N8slNlJAdI5wgkUaL/7hV+H5kgucfezGReHApqQDPd3ORGuvQJHkRfMQYsUqD1kiMJO+Z23laDjnHzHEMLOBF49aMvEdkp0Rzb/tdQISRwpjPVn2NX01hDDN2TtWLZQCPE/9g7/3zrPxsEYc276Jq3UA8fMvJcmzg76NpM2jUWMiGmZ4uxCyrXuNvsSwzYOA/zenTp8nNzSUgIICEhAQ+/vhjvLy8aNGixT/dtf/31GrVhMDmDYm4HUZ2WjoWtjb41qz2j1mWGTDwv4Rl3d5Y1O4pZM3MTEBm5Yxpleb/CssyAwZeh0EwexNetMiSiinKzONY07lkP4in/qqRVPmgLZgqICO3OEVieW6ZOQWQmiVkyHS2QSwWM3bshBJFjv24EIBt2zZz504I3br1pFmz0oFrM+/FIo7P4P13RxFx7x4dG7aA7GLB7P79ezRydcShrQVy2bOv/Jmod/ToYXbu3IZEIuHzz+fh6Vn6AbGWhQnpzu4AFKQ/ReFSfor2+EdBhJ4RLEfUyjx86/XkeFAI+6Nj6NGyEQ5O9ty4EUxERDhI4ZTdcQLzagmmMwB1gcMIVroWoFQWMnboBNKTcrAwFzF2VCNCn9YnM88GbeNDGAc5UlhojESspvFDUzRndTT59R02hR5l9LGl+Nt4cHb/dwRFnyYhI42VMYl4uzgx8aYfYpEIsmC46A9CjLeS0teEtTVd+G2VFHubgwwe7MUvv3SAokKubv+aQ5eFwFVajZrzP21Do1XjGBhIfr6O0EtXCbDQCtaH1RqwvO1HfHJuHU1dq1PfyR90WkiIBlMLHO1duSc5DM5CzLbvLu5m+8Wz9BnSlBNPbvAg/SkAF+PuAuBl6URDl2L/+MKiIhpOn0BiRjr1K/txbemP5X4fryM3PZ3wy1fxa9oY0wr4p/85tEAvIBch+FcWgklhxShSKjl+8DfcvSpTs17ZLoxvgr0NFHSDzMaQCfxRCJ3L8Iap070rl7b8hkZqTkh+c279BPWqg5X5q9t/MUSmlAhgFlAV+AIQUcWrdJ0pkdfYnBiF54NqVAoYjjjuGxq1b0GGxpaJn6rQ6WT0bRdD22EeXDevg5ViJzmF7UFljVgFVy5nMqnbU2aa2PHpQjs0Oi06wB1Iz3xMyzq/czXjD2xtT4AGFJkZ1Is8yIlqQ5C4i1BKgwBvOt8MxCfppr5fWpEwfhUaWWAXeQeXnzai8Jfh0i1aX0aN5JlQJSK9RlUICUErl2JeRUeL+9uo8/gIW5t/RZxzAHHOAXS8toK8yBM0+3oWjw9/TvAKe0SqZ+OlVkfsw0SMreXcv5ZLp6FdSFZsIeupjHvbCtFpC6k7fi3abo1R/nxY3wdjazXKXBFSiZQGDftx4842xBKw9FJh5qwiN0EQ5fas3ULt5g1xr+SFv28HTBTW5BdkAJCeGc2eA59ybPtpAMwsLVi0rWxzdwN/MxIJBNb8p3thwMBbR6VS8dlnn/H48WPMzc1p0qQJW7du/Vdnmfz/hFgioUpFMrkbMGDgrSMSSzDzb/VPd8OAgTfGIJi9CWYKcBEJYpOZgrQToWSFCdZFUVsuCoKZTILS2ZK9v24hLS0VGw9XBg8unaKbzGeiWr4SCotAUXZcp5SUZHYdPsaF2EJ23V7H+Q1VcXUuditMuxnF0YZz0Kk1BH7Rh2EjB0CRGiwEsawgO4cVK5aiVquxMrcQRCK5VHAVBVKOHqb2zRtE+PoSFxdbpmBmauVEevxDxFI5xmavziKk0xZnwdNqhNdjFq4gKS2DczdDGWjSEp/avlhZWZOVlUmdRvVgAM/d2AVeCMUQHx9HVnoOAI7aU6xZ/IDfgl2AOOo2sKRv3zNERdhTy/IgokeP8PCtg1RuzMbQo6i1Gu6mRhGc/5CODXowedoVfjj8FEjAxsuIYXbe0Basfaqy/rcOXF+WTr2BYfyReh3qWrN5S1u+/74uVlbG1B0wkwKZFCMTC2q1GcqVjadJf/BCdrHUaIhPEd5I5XSsVp+O3i+4roZcgojbwuu2/WhRpQZx5x7g8jCTOGxIFmey8vrvICk+Fc9tX55bzeSkprLq3ffILCwg2VLYGJ2YCOO3QqEK5vcE14qLXjqdjnnN2hB//wHuATX4+s71Ctd9M8SADYJgZk2xOloxls2fxL7f1iIWi9l04DpVqtX6S72xtoCOzWDrM2WrPKf0Bn3eYVXiEyYvMUIdb46lCRhVIFfBQkvwlgoumYHyKcChZ3uaUJZ1XYZKyfJ4Iah4ps9tTGwn8vWFj2jfRMzqbefR6QTLgxv3nqJSO5KZ0gYv2zgksgY8TApCq4knIaY2879Lplv7BaSbe/DQuT7eSbdwzozAWqfm9IXxFKqmo9GaIhHnkWHiiMjMCbXUGPULfck0EczeJCLQ6KDbjWX/x955h0dRrn34nm3JbnrvlRQCCT303nsv0gQpilJEwK4o9kJVARFFUUB67x1C7z0hkN573Wzf/f4YCOQAiufoOX7n7H1de2Uz+84775Sd2fnN8/wejtUehSARyGgRhu64L0KMIwYykd+fUypDahI9HO1barja4kWMLna0vPE6WMBwu4raOZu4MWwEyKTkFXlQEBFK3i0JuQs9sAhgkUmQSKV4tmpIx2H1WD5+OVgEtiw8SONxLiRslGG5p6kZEjNgfkaNi5eNix0ZcQbKku2RKtdUTxcEUDiZIAd0Gi3XTl9g5qDxrD63Bx+vOnz8RjbHTn3N1n1iCnuF8Q6CIGCxWDDeK719n52/bOD7jxbRtk8XZsx97/cPBCtWrFj5B7p160a3bt3+08OwYsWKFStWrDwlVsHsj6ISQ1FMJhO6Wi64NA6h7HoG4RMfpM0VFBZy4PRRADxLC2oKZiaz6GlmZws6A8iloHjyk0VnZ2c0cjeK1XcpVmvYsucoU8Y9qMJZcScXi1G88y+7nQ2Bnjxs5CMp16CQyTEajdjI74lyEgkoZOhyc/FesRxvo5HQ8nJiY5tV96svr8KkMaD0ciKiYX8McVdR2jhgq/ptQcY3ogUGXRVGfRUh9cXSlPXCgjlQVEKARI7z11+hdHmVz36dj1arfaIHzuef32L79ixmzIigTuMwbl9Nxl4lIb/kQRvvAG9iOobRbICKwe0OoM/PxjukHitXpqC6WweZ402iZEG0cKqDRJCQW5HOfTnK5n7VrFfh5vHzFOamk5qsIP1YIriqQanGL/IcZn03wBO5jZIOw9+pXvb475ZwYvWv6KU2qFxcuJUpI9jznmCmeIz4qat68L60iK+6TsHw3Fz0BSU0diqi4ZqvefPmckwWM1MaDWBMdFd2JZ2ljnsQTX2iMJiMfDhnJln7DgAwcfxI8kL9mSwPg9V3xX5XnYHXn9540mQwkJt4B4DshNuYTaa/MDXhGLAbsVzpH6tYVpycDojlnUuLf6OC3h9gtjv4qMFd+qjP2MM4uLsz7204eRnqRz5R166BiwRerY5CC7r3Vwb4Prb9qo0KHKWelPvk45Luj50SompJ0FjAvX0t3M6tR1/lyNAuVSw6/BnllVkIgK08iW1fwc3bV1nxq1hUYt3l7exs8T6VErgR2JFxh6YxreNb/LJhNMqQcg66LaJN7gwcNUWEFF7jSGgvzIDCpCM45zwGiYI9DV5CYdRiry2mcfIu2ieswgwYpLZcmdaNJkm70MrtUEsVOGsKkJkeVPr0kdkSaJ+BwqAmue4o5CdOk/VrOTJuUi97OYY2gTj4dqQoJoKIpUfIBjRhvtglZILRzJVQZ9LTtNhaHijot/cKGLX3jkvBApaH1XWRilQdkZMrOXtViUoSSJU5HUcHX+pFDubSVzsATXXbO1dvsW7J00VtggABAABJREFUStr27kxgWAjtWk0jLescOXk3iQ1/iY2WNwG4eyOhxjIWvfYRhbn5/DIviWemjsM3KOD3DwYrVqxYsWLFihUrVqz8v8UqmP0Bym5nk3vwBn59G9Hnwy85duk6o3p0YOX5j2pUSfT19aNFi9bEx9+kT5/+DzooVYtpmDIpBHiIUWASySNFATYcjMNoNPFMt3YkLTlEb0UgR2Wp2Nva0KlJzTSVwIGxRLzUBXV6IQ0+HCJOFASqNGoqNRV4Ojny+qhJ3Ey5Q5MGjcUUUDdRpBKkUiRyOWajEXdfP+RyRfV67mvxHoayKlqumowxficFc+cDYOfii//455+4jQRBQnC9LjWmrX7vRU4uXEKLyxdRSk6DzS4UmW3E9FA78yNpq5mZVbzxhhiNlZqqJitLrFaXcGYbB356DUffo5TJwnjt1abY+g/EUemEt2sAV6V32Hx6IbNnuBGuC0Zddw83KsvpvfAMIR1t6DqyEhs7Od5ZMtSGCWz2D6Sv/VLqGy9xPskZAHNOALjmYGuy0NAhlekD+jHt869o0vpBtJjZbMZGpaLTxPEIgsDduxWED9rJkBYODO9lIszrBrWUtqj8IuAksBZo3xo8tZCfARcPI1fYIqhFoUFptjCz+xA6N25EdmURPUObIQgCjb0fpL4uvLCRlfobdJQISCwwtmsPmg8dDBfTYF2qKMTW83/ifnkcMoWC51csI27lKtqNG/MX+3gEAy/98dmSS5he5wUcK+QE1dHTtPU/X7r5YVQSePl3Uivv4+wAvf5pe5kFQDsgDIh+bItDZwSiS7uhs6vi6xfsiOgnepyNL4Y4wQ+vNwazwzaXFeWFvJNWQZ26Y2iVsJahnT/ARgExUR1RurejwJjNtVYfo3IOoTL/BILFgoCFS1fX0KPPElbkZ1FpKqeq1BFVZTllxUnMyT/FKq8W2JvUJHnWI1FRU8CWmQ00Tt4FgoQVnb+h4/UfkFqM2OnLiPdrjV1OKVKzCTNmjDIlTSRmJId/5GCrydxShuFkY0MA2wHwTruFMSGBF17tSGRkWzYNk2K6dR2dkxK7hEwsggAWC9K1+xDjKwVs7RRUZgNYECTgEaYgP1EPCMhtbJH6tcOQtRe/ZmokEhkxTRvz8sTFyFR6PNzCkEikNIl4kRvnLpN47Ra/Lvpe3Cuz5jB/xnt0H96fcW9O4+RSPYU5TmQE7cI70I/c9Cza9K55HmvSoRV7f91CSO0w3Lw8/tkDwooVK1asWLFixYoVK/9PsApmT4lJq2d/q/fRFVVyYckejilvA7Dl6Gl+FmoKXhKJhIkTX3y0k8p7UQ5GE6WF+Th7eT/S5Mft+xn/wUIAcpKy8Jy+i6Bwbw737E/D2YNQ2thAYRkWRxWCQo5ELqPp4udq9JGVn06vybEUlRXw+fTvGNF5DAGxDUAuQ6vVUlxcgK/SD4WHB413H6Lk+FF8ho8GoLCwgK0fLsG2RCxukLXrMn71HygLUodHVYaCgnzUajXBwY+mcxZm3ODi7kXYBlggxxby9TDEV0xr1RmgSlvttQZAbhreGYkM7SBh/REzL9UOF62fBoJXcF3CG7QmHCNapwKwFBPl1w60kHD1NO9XdcNia6H75+GUzZ2FwiLjnaxrnCgv4MRKsOTvotOMjpTu3UBqylWcvKSs/rAPnXzqoVQ0QK0TIDmGwb43cZGZ8HATU+l2fDWCJq3vRWKVZHLk1j70Wglvj7OhQV1fPvvGiznLNdy+KKBuY+SyUElm4lGay2xwfj8AoVQCZ+1hoS9ipQGQlhUyY/tGTq/dQKuRzyCRSGjoFU5Dr8eUTbxHfi0ndsxqyJxmo2g+cLA4sXEQbJ0ipuGG/vGb+DbPjqLNs6N+v+E/y5qzkFEME9qA25OLXzwRqQQfRx/e7vI2NFiHGKn2hIqxZgvcKhAF6Ch3EB6NRPr3IweG/GaLoV3h+80S2te2J9i7hGmflJKRF0Lxh+LseRYJgoMvF7LFiKdbgR1oJhVo2WSCuASZDRFh77K2QVuQywm98RNBGdsIzr+M1GzkzKWf+Ka0gPzIIXS4/gPulWKFIovFyEZ1ObctAihcsdFXPDI2R5ktdip3cswWzIKEBL82BOdfQaNw4IZ/O+w1hQQUJyABZEYNt5MOYOcBbkIe2mNVSMs05IzrjOPdVEpu3cGitnDw6nQOpb/MsbrPovZwoGBAC9R1AnEszsZ341EoM2CRSlEFmzDkaAApgsxCnWGlGG62wbu5LbHdG+IX6U5Y7ba8//wVbL3jcVM2YO6R1SjkDrw+9HnOHznF9C/fZeCEkYRFi5Udzuw/Rkr8HcwmMSp3z5otxF+6TmqCGKWZkZSKf0ggWxPjCAoPq94Oty5eRWmnZNaCOQyYMBIb28eY3lmxYsWKFStWrFixYuW/Cqtg9pSY9EYM5aLgZVOo4YXpPdlwMI5XRgx46j50dnJ0JYXcyrzFJ7s+Z/s3Zx9pU1xeWf2+3GSgUdcY2n41GolUAoIUS04xApCecJvbVUV07fpoCt7FW6cpLBVTtA6e2cGInuKNtUajYc6ct8nPz6NTp66MHDkG52YtcG7WonrezZvXc9GcTD0PcJc5EjmlK+6xocg9vFB6eOHWo+by0tJS+fjj9zEaDQwfPpouXbrX+Lw0LwmLxQwClCr74ElX6OwOeaViZJntQzluZhOc3IXMbOLXKXJemt6ftp94iZl8F8BlVxjeDXuQnHQOmdKNug3u+UG9CJXmEiyT7plR2eqp31ON5YSFiCApe66DjVSPvfoclbddySoyUKvvOOxC62Ixmfh5xccEuwegQ0n7Zon0VfZlWO5IfpUMItFmNyqlhI3zxtCk2wSyFWZMZhNShYm6TSTEHcriatZdgiPNBEeC5V66mMFiZu5zwbygPUUgLcADiKoD+kwQBHRBkUTXdSa6U8enOHJgepPByCRSZBIpLzXsB4DRbOJibiKR7gE42/5Vhv3/Aqfuwhd7xfclVfDZoKeabdu671n8+Rs0bt6BDxatoZR4XJsdxhx6FjmvP3nGK7kQJwqSFpMFIcbzyW3/RozoJb4Ki5P55KtYXGTFVKoW43XsJehhprDgHL3vXqd+0i4i/dvTwCeGz5stQSZT8MvGsVy6to4OrWYwM05Nplng/YFDQejLd7/0I7k8DQCv0iSwWNDLVDWWrTBqkBl11Mk8hqM6H63CHq3cjkpbVwIKb6CyM9DhWU+CtKOQrZ2JQZAhsZgpdK3NuNCWqM9/xj1rMXRyew7FjCMq4zitb69Do1Jx9QcH9BJb6nTLxbGhHotMQKEwgwli0g6ybfTL1FqwnQYe3kx5sz/Tfz2H2tuFO0texOSsIui9X3GOu4lLLR2GSgmJV24wYUEfbuV9RMI12LRdQXGhHXU76ykxnWfTrhk0CX2Fw1v2APDZ5LcIjQqnQaumADRu14KU+DsIEgkWszjy8pLSGttE6Qpzf4og0C+WlyceRSFX8urgiWSnZiCTyeg5ahAqe7u/7oCwYsWKFStWrFixYsXK3wKrYPaUKBxVtN00nYytFwkb357BLSNY+uaURxuWV4nRPi52YqWvh9DIzDR4NQajyYinqxhddujQfs6cOYWzswu5uTnUrRvD62OHYDKZee35Z5D0LEFyz/792q2zRHtGIggSDEYTR44ceqxg1j62O81i2pKWk8S4/tOqpxcU5JOfn4dXbi4Os17m8pZN1Fu1Hum9aAmz2UxGYTIGW4FLfQTefvtVPEJr8cq3L/F8mwn423hjOVOIUM8D7AU02irS0lMxGg0ApKQk1xiH0WSkAFsc3EORJUoJuDUQYl3BAdELTiLUjAISBNH/S1uFxEZJu47e8BViUUVnsUmDZoOp16Q/57Z/yeGfphFSrweRNwdTmyZ02DKII4Hx2J9tyQBNT0r8iukdomaQoQNBcgduSK+z77CKCic9Qbb3xBSJBIPZSK/uq2huaY5aV8QRsomurE9Ht0+wbxHKlcPfcvlQInfPH+C5zy6RJk2mqlLgymkZr35uwXJPMrCzsSO23Ei+Uc2dU2J02o92XWnRbxWf2R4n8LQnc5uNpt+Wdzh99hvmdpjEjNjfjj66j1wqY3hUJ769sp19KefpWas5o3Z+wrqEI4Q4+XBj3A+o5E+OerlekMytwjQGRLRGIf03VeOye0gMdXgK8697rFr2JeWlxRzZu4k7R6+SOVMF9ELhPZj2mY+KYBVqWL0L3MqUNC1OZ8qWyWi/1zPvp13Ua9zyDw35hA5eKAFPCax1A69/MUt1zwlYuQ2a14fpvxPIl555Ab2+GICmUR8ztttFzhneZHhyFjpHBemK4XSNe5Otnd9l67ls1tVqwsLKSjJjXyP59h66O10hRumCXNYBGxtXpjy3jxPnlrHhwgouB3YFQeBOnRH0cPYm68pKJEDD5F2EZ5/FpSoXgHzHYCQWEyptKSejhnPGqyEnruXzQtEKVNoHBoJhmccp0UwitPVbFJ5fjFpTzP6YCaR7NaDF7fUAKKmi8SQNVRJHHKU6BMCMgAkJUswU2/niqC/C0yuTC2ka3sQV92gTxSHBGN3F1NDSDjE4x91ErjLjFqklqL2cjV/upzTXCxsHE7oKKb4NzdXj2rFyPV8fOFD9v0Gv5/uPF/DN7l8BmPjuK+xbu42K0jKadWlLSO1wrpw8R3Ge6I3nH+mFW/tLWCwW0jJFXzNDqT16nVgAwFalRK54isoPVqxYsWLFihUrVqxY+X/P/7xgVplawK0vd+LWJIRaz7X/zbb+fRrj36fx4z/UGyG/VKx4CeJfbxfRr+wezg4uLH57LXtPbmFUrxfQaDSsWfMzlofK9GVlZTBo0DB69eorTgjxgoJSzlw5xpTvXyLCN5LXer+Lm50zzw8cCRYLc1dt5sufNzKwYyv6NgjmypVLzB69gPpR0aJn2f3x+wfQunU7VJ99hLKsjMLdOygeewhHx3bcFLZzOSqNH4/Mx8PWj14dBhEaWoui0gJuBVkItxGFCsHTCHEWdqg2MPXTkXi7+TOs6YvoNFp69+5XY5PM+PI5Nh9ahYezJ0fm3UTZ3RXuV/N+yLcs/spNdu6tpEfvSKLbDyI+/g47EyXUPZpFz+/94BKiDdQ9NBWFlOaJKVTlR3PBAvZ40vHkUHIuvchL+QsYm36SFOddzDLYM9lejHor1TblpdwAXDPd2Z27DGPvepxIK6D16NcxYU/prytBEoTEIsHN5Izf9FqUJUwloSCRaKfTTMg4hvszHjzz/Bgq+5fSYlsaWTbZ5JSJhv6tglvifWwngYC7dx2yfRJx9anF+177uZV3lyVFrXA5uJ5p126Sq9Ty4/W9TxTMPj/7Kycyr/Nuy9E09RF9u8bs/oz9qReQCBJujVvBqaybAKSU5ZBTWUQtF7/H9pVcmk3szy+iMxkYG92NH3v+RpTWn0n9AFgyCjKLoW+Dhz4wAx8BecAcwL3GbO27DeCXZV9QKzKG4Ka1KW9cSvnFEjz7PN40f9kG2HoYwJmubnoKKsXiC/u3r/nDgtnaKii3QLkJjujgGdXvz/NbLNtgprBEwsb9MKQr+P1G0FvdyJ5EhXejqOQsz/TNxsVxHavfnUuTvEFkRd/EoNRSoB+DGglYzKwrK+BSrT4AnIgaQcCRVwAoLs3A16sudSJ60KHVdPwaPseyS9sAyLdY+Mo2iC5KT/Y0nkbLhLUEFd6oHsPpiEFkesTQ7sZKdDIlw06+h1NVPnnOHtgARokMmdnI8aiRXNfqQBXKsw6B2GuKsTGIady5TqEIFguHY8bhVp5Om/gHVSslmFnT+mPkRjW1s8/yzI0PoTZcmfAZ+fvjCL0oRZlyB5u+eZi9HWikOUylg4m8y3boy6WEdTGQdlT0MNOViZevggQI7gKlqQqS9tljNpi474EmSC0Ya69j1vR4mkfNILh2OBWlZQBcPHqaT9csIenGbV7qNhyz2Uzt7gLlJhPaPBkhdUPxco+ie/0mlBWXonKw54e4rdg7PkhLz8/KYdHrH+Hu48XUT99CJvufv6RasWLFihUrVqxYsfJfw//8r/szE74j95AoPLg0CMa1YfA/11Fh2QOxDMT36QUQ6MHZI0fYuHsrEbWjGD/xRXq1EVPTzGYzXl7e5ObmIAhCtXBWVfVQRUWpBLxdeWP9W+SW5VKqLsE1R8CtlgqVixM3bp3n7cXfYzAKLNu0m5JbTjirbPAz20BmIdgrReEO+GX3YdZeSGVyp16w8lsUDl44JDTARm5PebYLH6/MpCKgDwTvwMnVSdwmjm54Yc9aj1Tal3phc9gRjw4Stv70K0aTkcz8VGqZy6jv7IunkzN52lTm3xmBRJBxLSMLgILSfA4d/oxBY+c+stmuHF5Fr0EpZJeGcXh+JfMbNKF+7SQMEgtcSmT5s02ZMKFWjXkOXLrAnXwdUe42pJT40dhiQSIIGKV2SO0a8WbhYY6UVUKZN6s9EmjudAhToQfzUu1ZFyymn/YoHkfyj0kU9G3Gm2MSKCrU07OuhPDQY9Tzq03gnFt8s/kmU+dVAWNRRgXg3lwP3ZZirnTku5kHKCkpoV6HDgS1qEOAXy28LSGYgqLR3kwguMtoZr4krm/iseU4lRZT+17aZGxYM8Kvb6FX/V6PbI/Dxw/z9blN7DAlYBIsZFcWcXHMMvF4eUhYtQDzO77IR6dX0SOk6RPFMoBcdTE6kxgFmFqW98R2fwktawG1/mHiOkRjOgAT8G2NTye//hlDx07DxdUDmVxO0xMd0eVoUQY+Xr16OKu3XtfWnD7hgVZTRadeQx/b/rforYQ9WnCWQKt/KZDIDPSicZ3h7Dv5LO7OxdjZCsCTU2dtbOyZ/NxeYAkwmbvptcjNE9t7x0citxgYN9FEuk02arORST4RxJXlkamvoqFSFHEsCJzAEa9z3xF3dimtm71IvegleKYGkReUhlQQyHcJJcGvFV2vLCXDNQpvyR1szDrMwGe1O/JreQnJLhE0T9yIU5WY2k2lmj0NptAgdQ/22hJuBbSrjg4VytMAgZCCK8hMeoocg8hwjybHNZImd7dTeN2G7PN22EcL5D7bhRKlNwGfbyTNIEXZPobgkhu45aSguyBGucmLK6n97AJcwrQ4heoorhDPRWXpChS2Av5hwWTcTRWXDRjUUorvKPAK8CJRpkMQLBj1AgJgMYFRB1V2V/l40us8/11bZEozRo0Eo8HAthVrGfvaZE5W3EGjqWTRsm4c+8Adg1pKQbMc4rvso/yewFZVUYl/rftVT0UWv/M5u1dvBqB2w2h6jBj4LxwzVqz8/yA4OJjp06czffr0//RQrFixYsWKlX+Ko0eP0qFDB0pKSnB2dv5PD+eJvP/++2zdupUrV648sc3YsWMpLS1l69at/7Zx/S8h+f0m/93IncSbcEEmRar6nTtknQE0uid09JD2eL/qpdkMFVVs37+LorISTp89xYYNvz5oJpHwzjtzmDXrTebM+ZRmzVrSpUv3RyK1AL5/fwsvDn2NBd7vU3EzB5W3eBO5Yc+PyCTZANQN9cXX0x1ne0fcne7dmN8T8TRaHRM+XMjBc1cYfi2Hljfu0mpFIrZyUWhZp5GTogug/O5wJvVdwssj36ke48ruX1BL5olR4Y5Hfy8IhhE9JmCntKeNQwhlX63g45PHmDH1ebYkfM3tyjPEV5yg64imBLu40z0iBkejGoOuitzki2jVD1K7Um+eQKMXzeAH2QWRZlGLYhmAC6SlqWtsh5NXjjDl074sPL6GwQvU2Fypy119BZs0J9jp/COCoMDsdwoAQTDj5pTMGZfXaXb1JntLqkgXigC4Kz1Fx6vZLPn+Lu6yRKZ13YC/WxQdug5m+JjXWXL2IvPPxlcvt9BcjE5ZBMlBSB3LcLMVvzqJp09z4JPFHJyyHHNvM8njLWwZF8fFX+LZtWoVby16H41eywfdX6XMJGCyWLhdmMX3r29lauOB5JfCyVticOLda7e4e/AcPcoD6G4QCyiEOPlUj2Flz9d5u8VItvSfQ223QAZHtuPK2OV82m7i44/Je7T0i+bjNuMZHNmWb7pM/c22/x7cn/D+AR5evsjkYnSkRC55olgGMHEQvDwKPpwC/XsEsvNMNgcuF9Ow6dOWtlwK5a+BLp3utnDdC854QsBvPE54SLt8AvnAXt6eOJZls2PwUQWwduuYpxzPS8BhQv2/p2tLURSSmmSYzUp6NGhKfJP+XIloiiLjFDq9FoWhCofrCWQHTeXI8Kuc67ODu41eBSAl7SRxly1oFToQwIQFe00Rze9uwalMg8uVMeQWfovJ7ECWZyMWnFmOuuAmHa4tw70yCwtQbutKQVBHjDIFPqVJOGiLicw6AYBnyV1U2lIuhfZkf8PJxAd1IMG3BT4ld/AquUtg0U2SDziizpOTd0jGbYfGBK/Zj9u+y7gcvsaNq+GcXReJ8/Nb8T1x7sHWe6YN12e9QsoBJxwD9Pg01hDZwZ7nnltKr1GDERC3y30mTfiVLz5PYM2NDUz+8E0k98/HEgGZDeReUSFXKMgqOktEn1KktmIa56LXP+LyibPIFQquxK/lzvWrGNRiVHBZupyU9NNYzA929oz+41j63pdcP3uJT156A02V6GspCAIyxwoOxc2jpCzzKfezlb8Tubm5TJ06ldDQUGxsbAgICKBPnz4cOnSouk1wcDCCICAIAkqlkuDgYIYOHcrhw4ef2G9RURH+/v4IgkBpaemfMtb333+/ehxPeqWmpv4py3oc58+f5/nnn1wt24oVKyJjx46lf//+j7x/EpcvX2bIkCF4eXlha2tLREQEEydOJDEx8a8frBUr/2WMHTu2+pool8sJDQ1l1qxZqNXq35/5fxxBEJ5KfHtcuyNHjtC7d288PDywtbWlVq1aDBs2jOPHj1e3OXr06CO/i7Kzs4mOjqZ169bV0/8u58T/+QizFitewKtdFC4NgnCKfHzKFwAaPWSJPje4O4LzP1T8c3cU7+C0elDaiO2VClDZUickgpwiMVJj/77dDBo0rDp1R6Wyo06daH7acYBpP+6jQUQIMoUNVWVldGvRGe+oEEx6I1U/3aK3OZbiwhRsIh6IBxEBtXFWfYunUybb5p/D3dGD1NRkUkry8LR3xs5b9EqzUcgJ9fPmTno2kUH+2IXWglAgBKqyikmeVQIl4OqqYNLwcSjkD8RDQRBoYRdBdlUmExaNx8nemY+mfMPt7RUUHz/K3A/ewyiXUwnIUnyQeEuRCBJ6R0/kmTdHk3P3HEExnbi4eyGleUnY2LnQdvinSGVyQloMZ+jgJeQVuRPUrDltdrvyfIY/q20S6OQWzsyZtWts5pTMRMBCRUp/GuSNo59zBNiAUqrkklCE1NaJDq8q6eyYh82ea9S6c4EAtRNfut1AG6nntY/G4VESyJZPB6ExRJCeXsVL7e+gUuhRKbIICp7N7LgFfC7kQR9A0xbnpFCGSiZgc64tnAPtyIP4NVOhv3SerEwxii7dEo9OqMILcby3E25QiT3B2LL27EUaVbhx+VYlAlC3+ST8wxpjscDmU6A1wPVU6OBtrF5PrcWIQpCzJ/ksR9Iu0yGoIb4O7nzUZvzTHNaP8FaLkf/UfH8NXYC9iCmZT6h4+QewUYjpjveRSqWP+Ac+mRNw9TAcfRWUSfCMFyrHJ/mtnUdvGcOzxT9zVt+YdxwFxj/R+90LGIogbCIz4wZSCWh15U+9TtABiQRmT4K8Irh6Gzz99HxdeJvQMgmXf2hLlaaYRt5NsNWr8SuOJ7nuJCrcxZxnvdIdqX1rFteeTp7NL0Rel1HhIcVJIUMvU6KR21NaNoOSKtFYzdUhgeWjPkcuv8S8dUcpvTcKk0QOCPgm7yYn5IFE1eHmz7RI3ISNoQoBC2r5gzRFG72auhlHCCq4DoCDr4HSFBuUbkaeOzOL3BRHUhDPYUZHJUa1noBGVeTfUHL/GU7+8HYoCsqw8zQQPaIYQQItmwyhcb1h3I37sXpZMpmMIdOGYxCKEAQJUp03X73+mTh2ezvS3hpC63oNqJ1/nHcPPYvR/i47pe9Arhu3jovfXe090cvDLQxHfyOeMVWUpSlx9XGmVewLuPscoDBHjMw8e/A4Zw8eZ+03KygvLkUqlTJ7+Vz8I/xYe7gPOn0l56+s4o2pl//Avrbyj5jMJuIyr5NTWYSPvRtt/GOQSv5FQ8HfIDU1lVatWuHs7MwXX3xBvXr1MBgM7Nu3j8mTJ5OQkFDd9oMPPmDixIno9XpSU1NZtWoVnTt35sMPP+Ttt99+pO/x48dTr149srKyfnMMP/30Ez/99BNHjx793fHOmjWLSZMmVf8fGxvL888/z8SJDx6eeHj88arJT8tf2bcVK38lJpOJszfiyC/KwdPNh2bRbcTfDH8Ddu7cyaBBg+jWrRurV6+mVq1a5Ofns2HDBt59913WrVv3nx6iFSv/EhYLaI1gsoBUAFvZX1/Qvnv37vz4448YDAbi4uKYMGECarWapUuX/rUL/h9lyZIlTJkyhdGjR7Nu3TpCQkLIycnh/PnzvPLKK1y8ePGx8yUlJdGlSxdq167Nxo0bUalUf6tz4v98hJnCSUXtad3xahv12w0ND8QMdMZHPi4sLMBQWAZaA5aSCvBzAzdHsJEzcsIE/D1FMc4h38KtT7Y/Mv/yLXsxGI0UZqeyZ9c2jp04yuLxb5OwaA+3v9nH1fc2cn3OZhwjfNAbTNXzPdN9HD9/vJNDy88Q6l8LR0dH0tJS+HDpXKZ++Q6nr18CxEixkyvmsW3+exxZ9tmDBdcBVRdXtp8byLZtbbh0qTvu7o8XDL759RP2ntzCun0/svHAzwC4tm2PxiMMs9mCyWDBlB3KGN1plja8Qz2njoQ27EmrIe/jX7sN6nvpgDp1KXptJVl3LnLg6En0UhkunqW8tnkf7tdWsj1rJM4Fz/Ple544O9eM+hvU5VlG9JyIv3sMKTo1hQYx4i9FuAqGY6j887H18UZupyIjPJZYIRj/0Aas/taTCcOuoLWtJMFUSNaF2oAEiWCkkSQagJJKB15bvJsziaerlyd1LaGO2y70VRHV02xjOqPR6sjKysbX1RG51ILJksnc8GdJct6PWWnE1utBeu7kDAMNMnPEynyAp/9D6ZMPXSjC68cQ26U9O/OTOZKTgd5ioMqoY/3to4/dH/+/6QY8y79DszeY4aGvzD/gAKmiz5mlSkXa5/Hcees6xnLDY9p+TaLRhpP6JhgR+LkSJr4P3SfBiUv/2FYA1iEIBpydVtKm2YuMGrSCOwaYWgLLK2u2vnprK9/82I2t+3/klx2Q9VDm7NxZMP9VsIw8z+zMm4xIukCKwolLoT05HD2eeL/WAATfXI4s6wzGvHhGeI0hyXEtWcpKguNa4nxuBPX3dGaoewBquYp1rT8k3+vBtq8bnoinO7g4QZeYUkA06E9yr49ZIlbGbJCylwobZyz3DlpbgxoBC2YkqHSl1X2VO/hwtM6Y6mnBz3sRMLgN3g30GCol+MXqCBllQD4+mKCiKyjUGpyC9IT1KMPRX49nLwlyZyVB9eswes5LCPeuUsf3b0en1TJs8nO8/Pk7RDaMxmg08uv8n3m1+2wG9u7Pyl152NqJYpxM4k2j8uc5PmAme1ZvZt/abcQ2GMmcV1N49dMlNGzTjInvzqBF1/YARIV35dXJZ2nVqTe6coH0S1Wc3H6WzoN7P3Ik2NzLA5bbKGjfvztRjaMxmsRzkVZX8Zhjx8rTsjnxOMHLRtBh7QxG7PyYDmtnELxsBJsTj//+zP8kL730EoIgcO7cOQYPHkxERAR169ZlxowZnDlzpkZbBwcHvL29CQwMpG3btnz33Xe8++67zJ49m9u3b9dou3TpUkpLS5k1a9afOl57e3u8vb2rX1KptHpcD0/7R+4/0T106BBNmjRBpVLRsmXLGuNOSkqiX79+eHl5YW9vT2xsLAcPHqzRT3BwMAsXLgRg+PDhPPPMMzU+NxgMuLu78+OPorhtsVj44osvCA0NRalUUr9+fTZu3PinbhMrVn6P3XGbaT4qmKGzOjDl0xEMndWB5qOC2R23+T89NKqqqnjuuefo2bMn27dvp3PnzoSEhNCsWTPmzp3LsmXL/tNDtGLlX0Kth/RyyFFDfpX4N71cnP5XYmNjg7e3NwEBAYwYMYKRI0c+MXKqqKiI4cOH4+/vj0qlIiYmhl9//bVGm40bNxITE4NSqcTNzY3OnTtXR6zdjyL95JNP8PLywtnZmTlz5mA0Gnn11VdxdXXF39+fFStW1Ojz9ddfJyIiApVKRWhoKO+++y4Gw6P3IcuWLSMgIACVSsWQIUN+M2p97969tG7dGmdnZ9zc3OjduzdJSUnVn+v1eqZMmYKPjw+2trYEBwfz6aefAuI1HmDAgAEIglD9/++Rnp5ebdewcuVKOnbsSEhICC1btuTll1/mwoULj53v2rVrtG7dmmbNmrFt2zZUKtXf7pz4Py+YPTX2SnBQgsoGXO0f+fj8hXMUlokV7iq1mpofKuQ813wwTXZYaLgXCk4lUomObzjFQk5QgobRPTsikUjw8XzgCi7XwpnDx1l4cx1HR0GZO9iHeFBnSrfqNlKjhU7NehHqH1497eEvmcFgYPbil6k70JWfts2nT9tmODuI479x4xpvvjmLb7/9GqnUQt++/gQF2ZFXlIPe8OgZLCzwvqgocGT/ESoqxBvD1n36UnBXT0m6hRmziujf4Q7rv9c+Mn+9DuNxD4imbrtnWf/FSJa83ITCxGP3PpWRnCxFXeWIoaQ9/ToMJyyg9iN9KG2UfPHKd5ze/w4jpwbxc88ULk4qZkpOGmaLgCbzNuXFFkxG2LndjinaKhKe7YfKxYU5qXsYufND+iUMwc1e9EvycMpmb8l6FuwZxLeHexF/1Y7YrEzqZeQRcAdGGrbSvJOKNznIQsdDLG3+LWUxWZzbuxuTyUxGYRl6zR4khqvoSrcSMSmfnJ4HuJj0Ja4k0KYwiUGZhdTbt59hvTsR9kwHvi06xqmsGwgCDGwJTSOgUVg2+eUlNGzTnByVDHMhKEwynG3sGVWnyyPbwcrToTFARjlkVNy7KCcUwsZ4uH7Pm4v60LgROOrIyzRx+/M7pHyRwN3ZNx7TW3fCZLdpIBdP+I1LID4ZKqtgyxMzsgSaNXqWYf2W4O4aylvlsFULH1TAlYe+Yr9seJaEO/s5cGQCyzeWM+PLB58pbcC2NlxybYZPyBACnez4YKwzNyL7YJArSfRvRaF9AK3a/MDt+s1pvyaKnxe5U3pTgU2FHW4pgQCo8rzRr3qW7pe+ptvlb7ANuIBCGo+n28tcl2WwNKMN5To5126Jy42LGs7BRpNZ3fYzEr2bcrDhJH7usICdjadzP0nRIMgRMGOQ1wy1Mwg23PjRkQrZCFY2f40d03pxzqUz137yJOeqBN+AIiK1F3FOzcBiEkg/bo9LoIBvUzWV53T0fGc2J8Ma8cILH1B8043cS0our7GwffWPVFQW0GxABH4hAdXbGECTcYYbx4chkSsBsJQnoTt1Eck9tTTp5m0qSstY89X3TOv9LJfjzrL5u19qFF0J8o/F36u52KvEQrlwEa86FnyC/fEO8KXfc88w5KUxrDy1k5nz3+f7Y5txcXfD3s6diSO30KbZS0wYYRUC/lk2Jx5n8Nb3yawoqDE9q6KAwVvf/0tEs+LiYvbu3cvkyZOxs3s0ZPRpfE1efvllLBYL27Ztq55269YtPvjgA37++Wckkr/XT623336befPmceHCBWQyGePGjav+rLKykp49e3Lw4EEuX75Mt27d6NOnD+np6Y/ta+TIkWzfvp3KygdPAfbt24darWbQINGv9Z133uHHH39k6dKl3Lx5k1deeYVRo0Zx7Nixx/Zpxcqfze64zbzwwWByCmumzOcWZvHCB4P/46LZvn37KCws5LXXXnvs539nfyUrVn4PtR7yqsTIsocxWcTpf7Vo9jBKpfKxYhSAVqulcePG7Ny5kxs3bvD8888zevRozp49C0BOTg7Dhw9n3LhxxMfHc/ToUQYOHFjjd+Thw4fJzs7m+PHjzJ8/n/fff5/evXvj4uLC2bNnmTRpEpMmTSIjI6N6HgcHB3766Sdu3brFokWLWL58OQsWLKgxtrt377J+/Xp27NjB3r17uXLlCpMnT37ieqrVambMmMH58+c5dOgQEomEAQMGYDaLliRfffUV27dvZ/369dy+fZtVq1ZVC2Pnz58H4Mcff6yODnsaNm3ahMFgeOJ5THhMOOGpU6do164dAwcOZPXq1cjv2fH83c6J//MpmU+NRACvJxt2R0fXY9FX8wn1CaBtt27UfuigyM7O4oo5Hd/u9VHEl1Pv/UFsSzvNZcdMBBclB7nDpMG9aFk7ALXOwP5jp9HsuEClu4ET7pmYLWaQC5zvbc9LL3URHd91BrQ6HftPHMDRyYX27TtWL69z5+4IggSlUkmDRg0Z8WEHFBJb1mxewcsj3kZ+L91y+/Yt5OXlkJeXQ9u2HahTJ5pPf3iTxWs/IzI4mp1fn0Vpq8JisSAIAuP6T+XGhRukp6aDWsbVq5do1qwlg0b0w97Bjlkz9lClFcW427cfjbLwCKqHR1A9AFJv9kJikdH5dhvqxo7nRpsK0nck4+Apo+yVczwT9CIZCWcIqtMSk8nIjiWTKcxKpNfzC7G19+HC/r28ODqa8IaiqPalPITjm9phqCxnzasnuZrTHanGzCnLeNYOOsrIqCV8Zu7GkDIxZaaiaQy3lSoc2rdFsj8LhbQMjcGD+m67UVe40T0xEZn0Fo36TabP5HkcHvkLv15YSWebX1g08XUiGk0l8fIVIpvEcurCCVz1ZYT7RmGnUFKlE580XL6wki6t36bk9h2+uHgTdf8hrJpZlxKDmmVXdlI0bSueTnIOXTnMyPmfYitXEPfZAo59Op8ryUk0CK3FtcJkcquKMVvMSIQ/76arVFvJ+dwEmvvUwcHmXywF+W9GU6VGYWP7VGkUWlPN93YHU8QrdHYF1HYDuRT828FzINmRDQvFtCmJ8nF9j8BWaM92NxVaoEoJz7tBQTF0iH26sXvd24UKwOWh3enpHkl61gUM5kDMFhVaPVRpSpHLlchlNpzQgVmQIQChnrUJ8rjNkLLzrMhri5M6l3WtP+CIwpaEGwlk5IrfCYPJAZ2DmsLIS3gn1MHNZi0qczK18uB6YCcKFA6E1BuFQlvA6rA5rEqVsPRkLVon/YxFIiHDvV51rPzF4B50vLWSrpeXcjR6DMV2Pripc5BbDFiAAqfg6nUJzzpF7Pm13MpRUekYg+VeRVxNuC/6Kkja64hToIH4DS6Y9BKQyKgqMFOeJSX1sBJtqYzkAhM7tywkwr8fkipfkg4WILUxExodyheLG1NSloF3ww7UzWhA2t3bGKnEp2EVN9cqsZhFn0IECQ2Dczl1HGRyGSOnT2R8uwHcufbAm1Cn0WI2m8lMSmXejPfxCw1ixrz3CKgVTGLhKi4kiT9Yqswu1Kvfi20/rgUgOrYho155oca+ja7di+jajxbyeJhN3/3C/JlzaNS2OfO3/lj9w8CKmIb58qHFPM4eUKx5CtMPLaZfWKs/NT3z7t27WCwWatd+9AHN0+Lq6oqnp2e1b5hOp2P48OF8+eWXBAYGkpyc/CeN9s/h448/pl07sfT0G2+8Qa9evdBqtdja2lK/fn3q169f3fajjz5iy5YtbN++nSlTpjzSV7du3bCzs2PLli2MHj0agDVr1tCnTx8cHR1Rq9XMnz+fw4cP06KFWHQnNDSUEydOsGzZsupxWLHyV2EymXhvyctYHnN2sWBBQOD9pdPp1rLffyw9886dOwD/0nnIipW/IxYLFGp+u02hBlTyvz4989y5c6xZs4ZOnTo99nM/P78aEeFTp05l7969bNiwgWbNmpGTk4PRaGTgwIEEBYlFoGJiYmr04erqyldffYVEIiEyMpIvvviCqqoq3nrrLQDefPNNPvvsM06ePFkdnf3OO+9Uzx8cHMzMmTNZt25dDbFIq9WycuVK/P39Afj666/p1asX8+bNw/ue/dLD3H9gdZ8ffvgBT09Pbt26RXR0NOnp6YSHh9O6dWsEQaheH3hgu+Ds7PzYvp9EYmIijo6ONebZtGkTY8Y88HA+ffp0jW02YMAAhg0bxuLFi2v09Xc7J1oFsz+JgIBA5nz0OWazGaVSWeOz+fM/p7i4CKWjioWnF7N3724OfbdBTN5+ryNBXi4cPXqYn3/+gS23yyjTmYlwUdDS3w4sohJssVi4XFiGcP9JtY8rm9f8wsGDewFRnW7cOJZdu7axadN6goNDeeONd1EoFLRp0AVJvj02UiVLl37NtGkz0em05OWJUVa2trb4+YnRGntOiE/ZbqfeIDH9Fl+seJuTVw7z1oTPeX7wDJ7pO5bly5eiUtnx44/L2bp1E++8M4ew2rUI8MymtDwFdy9/3nyzzm9urx4T5lH+QyYdCt+BY9DSpORAcDgCAl+ctGPv9ukIEilTvr5ESX4a5/d8BwgcOLces5MPuVevErdlE5MXfYfeYo/JaEAQlMTn2NMh7BfqeR9k/+V3qah7ljLPTPJoyVrDfNraDCJJtpZKmxtcVjTk2vHLjO8+kcNveBEY3YUuTePYfvV5vBxSGdPiI2Q24SjkNlzbYsfMJuLTAJ2hnAaJMQz98i1OHFpN6U4t+k5RzGg1BrODC8HRbbl79RDeofVRTJ7F+DsXOBrkT9jZPExVOpCDXCqrFsCOXL+CxWJBo9dxKuEmjcMiaBlVl1NZN2izZjpmi5nZLZ9lTuuxf/i4vP/Q4+GLkMViodXqqdwqSqOxVwQXxnz7+Jkfw96vFnM77iT93nqN4IYNnmoerREKqkAmAS+7BzUx/hl2bvyJT96YgI9/MK1WnmKr0pMRKphkZ4HLuaAzQRMfytRlxF87T50GLdEfqKB8RxYO44PBXQV5anC2FQf0EJ59fKn3a3P0+Tr8J4Q8YQS+CAIoAaUzrPtStC20f0rN8UtnaK+B8otw7jr4dACFHKaMO8CdlKNUaFug1qzBy/kob3z8Ew72PsyadIauigAWVoLGHu5aovmy8kOWhb1G9K0RbPOScsxoIt+gZcNeCf4uG6lyakxGHyVKWQjJzW5ijtpF7OVvwGiLxmQg2yWcblfF/V5k54Pl3rGY6RjOxVq9iE3aQWDhda7be4PFQvv4VXiVpwIQe3cbZkFKtks4cq/6GOx9yHCrW72O9VIPUqxejGJKbfy7WOhiLODCqbN4/XQYlaMNkY3qkOIUipltgBGpjQmPKDUu4WocEmRoS2XI7cwc/ukWC46LofAx/ZSMfGk6oZF1KNkmfg9LTRfp+mp/MrIzadlkOreTc7i9cQ0GvR6pXMb3RzbRoFVTrr/UEmc3Fya0H0R+Vk71ODsP6c3IlycilUr56s1PiNslpp2lxCfi7O5GRO8Hl0eJ3ELGndTq/1Nv3326Hf4PrF64nKpKNSd2H+Lu9XiiGtX7p/r5byQu8/ojkWUPYwEyKgqIy7xO+8AGf9py7z8ZftyTzz/az/0+3nzzTaKiohg1atQT26enp1OnzoPrpNFoxGAwYG//IIJ91KhRfPvt05+fn5Z69R4cdz4+YmGZ/Px8AgMDUavVzJkzh507d5KdnY3RaESj0TwxwkwulzNkyBBWr17N6NGjUavVbNu2jTVr1gBipJ1Wq6VLl5qR0nq9noYNG/7p62bFyj9y9kbcI5FlD2PBQnZBBmdvxNGyfvt/38AeHsPvVxKyYuX/Jfc9y34L0z1vM+Vf8Axx586d2NvbV19j+/Xrx9dff/34cZhMfPbZZ6xbt46srCx0Oh06na46+rx+/fp06tSJmJgYunXrRteuXRk8eDAuLg8CaurWrVsjqtzLy4vo6Ojq/6VSKW5ubuTn51dP27hxIwsXLuTu3btUVlZiNBpxdHSsMbbAwMBqsQygRYsWmM1mbt++/VhRKykpiXfffZczZ85QWFhYHVmWnp5OdHQ0Y8eOpUuXLkRGRtK9e3d69+5N165dH+nnj/KPv6W6devGlStXyMrKon379phMNT1y+vXrx5YtW4iLi6NNmzbV05/2nFi3bl3S0tIAaNOmDXv27PkX1+DxWAWzPxEbm8d7f90/OMxmExYLJCWJqilaI63iIKiNnEPZYmSL7t5ZpaDKiMFsQS4RqKjS42gjJcJJQkLCLWrXFn9kSx5SHu6/P3VKrF6XmppMTk4WQUEhLJi5krfeEhXzzIx0SM3DZNSj14ppk7F1G+KksAXgxaGv8fHy12hRrx1Xr1zh2MX9AKzcvoRBHZ6lSZNmNGoUy1dfzeXGjesUFxeRlHSXxo1jmfvte2Rn5hJVS0ne9Z+QGVrjEVhTeb9P0x7Pi6qDWMyPNO1BjC011D01GkmuAuRgMZtQlxXi7heB3EaJxNkd/IKQAHZNYyi5HUfLtqdJTtHw7tsNaT9USfJ68Ay1JcZBwEMI5CPbXQCECzLSbG7ys81N9PIbSF2iuZXjBALs2nWCvA2VOMk/JDF/OgB5FcGUmnqh1YWjfcZEf1d/UA3AWZKLjyaS2ol9SB6ZRHKnQzg4OdPE6I6bnRJzZSmeLg1w7NWR2v0HcSbuKGsjdVgkLuSGuGL5qj+BPfPZ/MlIZBIp6+KPYPQ2UjcoCC8nV0a0fRApmF6eL0YXAqllub9x5D2e/FLYfBoELBy4+im7LpzgrcEjeHXwUBKKRdHhemFKjRu93yLjxk1+eXkmAAUpqXx04dRTjaNMd89HzAxqAzj8TjHa3+LAjrWYzWay0pP59uxpNG368UkFTEwvRBonrpPJYGTinO6kpyRSt14zntk/C4vezI392XRI6w25FeBl/9hHWd5DAh6Z9lvIZGD/B86iSgE842HhcvH/olKoH7qC/cc+pV6d/gzoUQo8B0CHlnDoRDZJaScwMBz7vaB5VpzvRKY3Xxy1A/NaZrf/gFHxJ6jMtCekKI5aDhM4PPQ6UrcQXC1emLNPkeIcxr4ePzD69EcctchwqnpwoTZJZATmXUbjXJfBBQNwlpRSzg7axK/BWZ1DjnM4Zltn1BpHVPpyHDWFGCQKDK7hrB69jsGH5iO1GDEh7lh94UAqdKO43mcr58rLUAgSomevxlyqpkqAT9csoc7xbci/GkzLjd/hUkuH0tUEgoTwXmXo6/tQtrqUq8evVo/x5m41pxquYtnLG3Bq6oidXzlaXTnnLoteiheurubVl87y0/OiwGYyGPEKduPStfWE120PJlsKsh98hwRB4PWvPsbdW0yBD60TweHNu5FIJJw9GAeAi88o2nWYyt1LGVwvjie15C6eft40atuC0TMfGK7fJzM5DWd3V+wdxQII5w6fwMHZsYYo1m1YP759fy4R9esSXDvs6Q+c/wFyKov+1HZPS3h4OIIgEB8f/7sV7J5EUVERBQUFhISIQvvhw4e5fv16tU/X/R9+7u7uvP3228yZMwdfX98aJeI3b97Mpk2bWL16dfW0f/zB/GfxcGTj/XP//R/Tr776Kvv27WPu3LmEhYWhVCoZPHgwev2Tc2ZGjhxJu3btyM/P58CBA9ja2tKjR48a/e7atQs/P78a8z3pN5MVK38m+UU5v9/oD7T7K4iIEH1yExISqiMxrVj5b+D3xLI/2u6P0qFDB5YuXYpcLsfX1/c3I/vnzZvHggULWLhwITExMdjZ2TF9+vTq659UKuXAgQOcOnWK/fv38/XXX/P2229z9uzZ6uv/P/Z/v0LnP067f208c+YMzzzzDHPmzKFbt244OTmxdu1a5s2b95vrdf/a/aT7tz59+hAQEMDy5cvx9fXFbDYTHR1dvS6NGjUiJSWFPXv2cPDgQYYOHUrnzp3/JX/R8PBwysrKyM3NrRbx7O3tCQsLqy52+I8sW7aM119/nR49erBr167qqPOnPSfu3r27OsX2HwOW/kysgtkfpGDvbnLXrsJn+Gjcu/V4ckOLBfRGkEt55ZVXOXPmFA0bNkahUNCv30DKy8upqCjnxO79XDh8nNdff4fi4kK8QjXkGmxwNMEPhw7TszKH55MuU2lnx76u3YmLO0bt2nXYuHEtBQV5dOnSnYCAQBo2bAJAx45dWLt2FRERtfHz9AWdAW9vHwYNGsbNm9fo2aQ9GE2okNKtbScMVVqGdOgJWUXg68rwHuMZ3mM8O7es4uCq92gsV3HRUIWPKphXX32Zxo1jmTx5Oh07diU1NQVvbx/q1BGjS+rE1CYyKpSDK6ZgMZsoyLhBl/E1QyxTKOYAd6iDFyHtXTn03lnqH0shJ/QcDhZ/qmyruHrSHztLELaO/tRqIApI0+bcpKgglX3FKTi6Gjl7woFGzSeTvEP8gbNzdyEffDSKwNpHSD4nPqFv9lwy7Xf2p8B0ARtHB7TFtyl2kGC0bYVMkGF3qR46yqksdWNnlQe28nDahG3kYPyzWJDw3aEBrDhSRqzyEJ3DHJAOlhCSvIBBR7shICDIMkm7uo66Q+oSGxIKgMRiwZhzhkt3cvkg+QgdoprjqJdQZmtBKHbFku9C+k8ueH3ox7X8JJ7Z8SEA3drGsnfI5zW21eDIdiy/uovk0myei+n+h4/VxCwx+qlUXcSmU6LJ1oLtm2jsF8Bsh/5kyEpp27zpU0dW2Lu5YmNnh06txi3w6YUlpUwUygTA5l/Mduj3zESuXjhBYGgk5bHtuAjEKkD6ULSY1qQlI1UUpZPuXEfmJMdQoENhJxVdG4Oc/7VBPET55RLip15GFWpH3eVNkPzGCl5JAFcn0D9knaDTw7Z9b1CpLuBQ3Fy6tfsI1b1oNXs7JYF+dYkK74beCLXywLzBQlDTKgIOziS7qhyDaRt2O+axstYQjmZXkCYbiwVQaEVRQWZQYzGI3kLx2gqSTEZ8ylPIy1pJukJFlWc27uo79Lm0CK20CdfSJiKTzGFCXxlnLnzKjcBOlDj4kewTS2juZRTGSmrlXSTerxWjbOSsv74VryNv4t7sdfJcwpEZtezpGYFHwllMcrE4it5iRjs+Cte1J1GoLKxa+iV2bSKpcPTEu6kWicWMvcqDrMaT2CZ1wvX4ZVw4VGPbmQ0Szq0pIjexCncZRN6777ZROFBeqGb/Z6XsnRND7Y7O3D2fTUyHWsz7vjFaXRlKcyhdGtX0gnhj8SfVYhnASx+8RqM2zchMTuOTF98AIDQimiF9xlDcrJD174vCv7ZKS58xQxgY1Rbf4ACW7PsVJ1cXfvz8G75642PcvDxYc2k/Bzfs4MvpsxEEge8Ob6RJe7GwxAvvzeSZqeOwd3L821Rm+7vgY+/2p7Z7WlxdXenWrRuLFy9m2rRpj/iYlZaW/q5XxqJFi5BIJNWC26ZNm9BoHuSgnD9/nnHjxhEXF0etWrUAscJrWNgD0dTT0xOlUllj2n+CuLg4xo4dy4ABAwDR0+x+qumTaNmyJQEBAaxbt449e/YwZMgQFApRQK9Tpw42Njakp6db0y+t/EfwdPP5U9v9FXTt2hV3d3e++OILtmzZ8sjnT3MesmLl74j0KYO3n7bdH8XOzu6pr6txcXH069evOjrcbDZz584doqIeFAYUBIFWrVrRqlUrZs+eTVBQEFu2bGHGjBn/1PhOnjxJUFBQjSrb9yOmHiY9PZ3s7Gx8fcUigqdPn0YikVQLSw9TVFREfHw8y5Ytq47aOnHixCPtHB0dGTZsGMOGDWPw4MF0796d4uJiXF1dkcvlj0SD/R6DBw/mjTfe4PPPP3/Eg+1JCILAsmXLkEql9OzZk127dtG+ffunPic+nEr6V2IVzP4AyelZHBg7htDyQvJ3bqNjXjnCk256CsqgvApkUgIDAwkcGlz9UUhILWbP/pAPP3yXoqJCtFotFgtMmfKK2MBkQpeYiVIhp9HP4gFnr1bjUlJCbGwzNrzzOupfV1Hu50dO67YMHz66uu9OnbrSsWMXBJ0BsgrFPBZ3J3r16kuvVn1hqRoCy0Anof/Q4VBaAWVV4swPlRJMPLwUO00y0UD/vm8Sd1n88p6/dIax7/ahpLyIebNWEBZYM7dYkEhRKB3RqUuwtX/U820FF8ihgvNkMoQYjvcqI9e3FJUpgoE+3VH5qxi8fixXLjRi8Mj+4kyXwfWlEFxNIbymgnOpWRTlypmyz47n+pwl8WpzZr0khrt6+gWRIpFiMZtYsUrD0UPuRPr3ZmQzBSWlYax0PoERM0aDEV8nLX5+5aRlOHDnNpgEFeEh1ziUYMZiEQUYoxlOq4s4c7WI16oEGidEI9wzGb9o+z0A+ek3OVZWhJeLD5XqUq6lXAKLE0qDml3aizjrytFlujDCaRybndX06+ePn5+SimIxLdNsMWMjffSJx5W8uxxOvwzAeyd+4tiIhY8/1p5AmC9cSwVPRxdaRTXgZPwVnmnTnvM3rgMQYHBmZNTj8/gfh4uPDx+eP0nq5Ss06d/3qedztBFFM4kA0n/Rhq1jj0F07CHm5esscNcIYTLAzU18PKU3YRftwasfLGb/9lUMHBlJU2eBom9c8YxWwqlMaPfnnVyTPrxF2Zkiys4U4dHPD+9B/o9t9/N2+G4jyGWw7D14eRScLYavm4NL07M0WtOAQOcAFIpXACmgoUu7N+jSTgkkYkc5a74Ipkoj4ORgx+qsnpy+uIIU9S/cPOAIB2BCn7mU5Ykp1cNuzGdnRhyVKV2QpU5H1mAdGcFS9ob0pG7SZTyzMzjVYgKlwYm8sF/04lKYLgMW9BIp6jqT0Nxehfxe5UeJxUSF0oU8l1huBXYAwOwTxsG1g1BZjHS6tpz99V+k0Fl8wpYTk4BN2QPhIa1bJxx/OENllozVn29HFjMao5M7cVEjaHl7I7NnJrKiOIfNt/bTTr6Hsg5a8i6r0JbKcHBxxN3fhZTr4jmoLFkJlAOgtHUizGsGFzLEajmyrCoaTCgHCtDqQF8p4cwyNQf1D/zGpDIpQyaNoaDoLiDg4VYLQRCqq2VG1K/L9TsbcK9VglpdjqunO5M/eoNDm3YSFFmLt0dNQa0pILcsm0VvfEhQeBgnd4sCX1FeAYlXb5KSIKZsWiwW0hKTqgUzrUaDRl2Fk+uT/TD/V2njH4O/gwdZFQWP9TETAH8HD9r4Pz5q+V9hyZIltGzZkqZNm/LBBx9Qr149jEYjBw4cYOnSpcTHP/C9q6ioIDc3F4PBQEpKCqtWreL777/n008/rf5Rfl8Uu09hYSEAUVFRf/ub3rCwMDZv3kyfPn0QBIF33323+kn4kxAEgREjRvDtt9+SmJjIkSNHqj9zcHBg1qxZvPLKK5jNZlq3bk15eTmnTp3C3t6+hreJFSt/Bc2i2+Dj7k9uYdZjfcwEBHw8/GkW3eYxc/+5lJWV1YgsBVG0DwwM5Pvvv2fIkCH07duXadOmERYWRmFhIevXryc9PZ21a9f+5eOzYuXPxlYmimG/FUEmFcR2/2nCwsLYtGkTp06dwsXFhfnz55Obm1stmJ09e5ZDhw7RtWtXPD09OXv2LAUFBTUEtX9mmfe/37GxsezateuxApGtrS1jxoxh7ty5lJeXM23aNIYOHfrYdEwXFxfc3Nz47rvv8PHxIT09nTfeeKNGmwULFuDj40ODBg2QSCRs2LABb2/v6t8owcHBHDp0iFatWmFjY1Mj7fRJBAYGMm/ePF5++WWKi4sZO3YsISEhFBcXs2rVKoDHPiwWBIElS5YglUrp1asXO3bsoGPHjn+rc+Lf4PD8D1JYBpVacLYD50crXz7MpYS7tBo3E51/LJNzbjLUUfJksQxAI95oYjSJQpTNo0rB8KGj2PDTL0RERREc/MAzyWiBzp8u4OStRN5r2IrGhTmUuDhTFRRMgwaNyO7eEefyMnxzsjnbOBZyikGjB3dHcFAi5JaA+qEqlVo9BmzZpL+BLspIt1dDKFFVELVaCi4O4llMKgHHB0ZMoRExFCWdAgQ6du6D0iOJ06dPIvc0sfboOgC+3TCXuTO/r7FOpRUl5DmFEBnWgjr1OwOQSwW/Vl0g93Iixjv5WEbVRilT0Bg/rgu5pObsR5qdy5aIGCar69GvSS/6De0Fh4GFgBwQg1X4qVMr1rinEeUlIfmzNwlkF7ERp+n/0zPQApzrhtJ66IeUl5Zz9K1rgJ6p7hGEp4kKfGFOOb/4XSLhWiRNm95CIoHAoCICozxo1MaI8qyOLlE/czm7MzIHXyQygcwUKa52xXiVXkQf1hFyoVhRzlsNnFDvXcqzUZupk90E6f4RHHZ4Hq3ejFluxssuF68G5xEam0i56IeHfQYlJ+qDyQgmA1FuQewe/CmX8u7wfP1/MAvPvEtU0g362fmxTZ0lRlXcOg+F2VCnKbj//pNQbxeY1AMQpLzY60tK1ZW42Duw6cA+bty9Q0xACNIlR8FWDs+1fsTT63H4RdXGL+qPGzDK/4JgGhsB6j6sM0a5V78dOHISA0fGASvAshK7tFVQHPqnj8GpqSsF27ORqKQ41H18+lRy2ikOnBCAFhiMkJ4DQ7rCugITOqOUXJsQOr9wlX5unshkKi7deoOkTOjZBuyUG4BhgAy57CBODm0BGD5gOcmhPTm0pRZu5QCWar9DAA+5HEN+N4rkEmICB9Hi7nHKM90RMOGgLcHkdoyUgv1oHbw5H/gcUfn7kVdK8HCbwa1YPesOXaN2RRY9Ln1Fgl9r/ItuoRNcyczfjEztyp12J8g42g+lRoxkc6nKx8ZYBWYjSGQEV2YTlbgOR10xOrkdzw7xZpFCQAuYBJBWFTD82gLKle7kuoQjERSsn/w+ta5fw9KqAv/mBlRuJuI3utBzxBA6jR7HlHad0Ou0dBrcnQpWAlBansnAvu1Yv2g96go1Dg62xG+S4NdMjaO/AZnZFZNeFLgdnB2pLKtg9MwXuXl7N8t+6YsgCEx6dhd1Ih5UHtbZJnAm4QtIgAVvvEuE1zCO7zhAaFQ4+9aKVRBtnCx4RGvYslxMAe06tA/+oUHUiq5NbIdWhMdEUZxfiJOrM71GDwagvKSUkU26k5mcxqT3Z/HCezP/nIPwvwSpRMqiTpMZvPV9BKhxW3v/wfPCTpP/VMP/+4SEhHDp0iU+/vhjZs6cSU5ODh4eHjRu3JilS5fWaDt79mxmz56NQqHA29ub5s2bc+jQITp06PCnj+s/wYIFCxg3bhwtW7bE3d2d119/nfLy8t+db+TIkXzyyScEBQXRqlWrGp99+OGHeHp68umnn5KcnIyzszONGjWqNkG2YuWvRCqVMuelRbzwwWAEhBqi2f0HoO+/uPDfEvV79OjRR7z7xowZw08//US/fv04deoUn376KSNGjKC8vJyAgAA6duzIRx999JePzYqVvwJBAHelWA3zSbgr/3rD/6fh3XffJSUlhW7duqFSqXj++efp378/ZWVlgBiRdfz4cRYuXEh5eTlBQUHMmzev2oLgn6Ffv3688sorTJkyBZ1OR69evXj33Xd5//33a7QLCwtj4MCB9OzZk+LiYnr27MmSJUse26dEImHt2rVMmzaN6OhoIiMj+eqrr2jfvn11G3t7ez7//HPu3LmDVColNjaW3bt3V/uvzZs3jxkzZrB8+XL8/Px+N9L8PlOnTiUqKor58+czePBgysvLcXNzo0WLFuzdu/eRIgn3EQSBb775BqlUSu/evdm+ffvf6pwoWP4DTpPl5eU4OTlRVlb2l3l0/C4mE6Tkie8FAWr9tgCxYtt+Jny4EICBkYGs+vwdbP0fH00CQKUGispBaQMeTpw7fwa1Wk2bNu2r83jjhn9N2trTyJ1U9L09D4mzLXv37qRMY2Ds3J9RyQTs7B2Y2j6C5OQkunXrybBhIznZvgVV585gUNkR8ssWosLvGW4rZODn9mC9zGCSSLihSSU30okNilvoKnTs67+TwrJSZowayNzpEx47fKNBx9Uja3D1CSUk5kEaxZXb5xn0Sht0Bh1zZ/7AM93H1Ziv77QWXIo/g5ODC2dXpWGvcmARJ7mO6B9knhtHx/ad6dikLb44cvLyFna/PRAAWbtOzDl5EHKAXsBuxLumaEAFaODWzGskl92l7eudcNQ6kSQ/xFb7F2itmYW0h4xGr4xm4dIUDh3KY+BgL84lXMa14hJF2gJCG3ag6uZdPsw+zfSI17l57SAnTtTG0VHDzC/1GIqSUe8XjSBjQpvwTLtn+WCvirDO7Whousquvb9SWqnF3imUeWEZFNqUweEGtEt04qjbewBY6lpInRnHrmUzuGO+SNpo8QpQmu7GQrtFNLgnMBDVBKKfkJNtMsKWZWAxY5JI+Tk8mGd866M8cq/subM7BEaC2QQRjeApfuSlJyaRmnCHrVl3SC0p4v3ho6m3Ow2Wi35NvN0LhjT53X7+tlTo4UK2aOofcz/VrgcgFsUgeTcU1YcGXn+6eld2vhgbb1tsAx7v/P/el6Fk5SvIKv2aFo1a8uZEO+Qy6P/1fC72n4ZtXhqnowNwt1WQkgVj3gKzBTo0hQ+nTAcW3evpC+BVDsbNZdve17BY4HKL5ZQUPUOXYBOhsl+4s1usYlevTn8u+n/Cd9JzPHtkBg7aYgDKle6iB5lgR27JWxRXTcNivv+wwESgZ2+cbA5wLrw/sXe3IzOL+aOnwwahyqqH5c5sAIweF2hiE4sFOF+rL/nOoQgutSjXlKAwG2h0ZyuCICG4QPQhaxANJw/LyL+uRFLPEXNdT0LyxejJC3VGE7ZrPTfXik+v7EIFmowoJfmQN2lOMQQ3/omidBeaRFQwqOFZWvXoyLJf+nLz9i6C/Jsx44U4jAYT6XdSGFpPTOG2dTXS+IVCQMCtYgSp17KZ9cWX1I1tiEQiYcXKCVy6/QMA9tpWNKw1nmGTRe+4Mxd/YtUm8X3GSTtyz7mj14oPQBxdnCkvKcUlTItntIbbW8Uxj545iRlz33tk35/ad4RLx88w8PlR5GVkM65NfwCiGtdjzYV9T3eA/c34q6/fmxOP8/KhxTUKAAQ4eLCw02QGRrT905dnxYqV/w12x23mvSUv1ygA4OsRwPsvLqRnm4H/wZFZsfLfj1ovVsN8ONJMek9Ms/sXvI2tWPl38L8bYSaRgI0cdAZQ/b7x7LCubdl76gK5RSV8+PZUbP39MWFGjwkljzEQtFeKL+DChXN8++03gBiO3b+/mFJ29vZd1Cojtcqq0OaWcuTkWXbu3IbFYmFQA38czGps7ByZNfNNJEWVKMwWqNLh/Nl8XI+fJKRlO8oUCvJLi/F0dgU7W3G97GwhS4/lfU/M+Sb2e3/PjS75yKe2ozytnMKyUgAOnhVvWC8l3CXQ2wN3Z6fq4cvkNsi9G3I16S7O/iXVoZgNImM5/lMilVUVRAY/qIx3n/xi0VOsQl2GRleFvcoBN0QhwWI0I60w0t67Pr6IN1r+Nl4AmCQ2eJX6sKfsLUx2ajpf+wBbiROYEMWyxWAqyMey5DvcHT1x1Io/bjyM9ahjN4CDzm8ztdsB7p7IYObMy7zjU5dOWf7kOCeSHJoNQGLxOSrfa4zbuPNMGxPO1DclaDT5aDS2HF2WgFdEEbkeo6koDyWCWxSU5TG6UyQ/3PwOhZ2B0koxak+tTadcUQkGKZI7vgQ770VHJck2Nzmp30KD4x2R3ZZjJ4dmd8Mx+SkYpehNsI8PJN8TzOQPjrl8dQnTDy/GXq5kYafJqGQKsFWBphKU9ggFUnIcNYTKbcCgA0EC106KM1sQp6XcglrRrJFqmHlkKa39o/m1z7vIjAbMR7fgUVTAL9eyWHDzIgAavY49Qb0f7DjV//Or1ZFUSCkV37spqXISkMu/Qq6YCzSA0B4QCvA98BMwEfjnU4E0OkjLhrAAcIp1/c22zk7+FJXEERM4jFefS0F+76xb9eMn+H7zFhj0SM7lgq0nOp0olgFUaQGmARcQvwRjAYg7swSLxUKFS23Sm4wH4CxGVty1J9a/De5F5Zy5/R4tHMNZ73SdU5FDaXl7HQKwv/4LuFTmojCqcaw6guzMGAyIgplE0CIYleiUCgILblCq8sLGoMZBV4JnWRJn63YhPKMKudYWld1+MEKqZwPOR9wTvE0Wwqctw1ah5+Qno2mYc7B6G5SVe6HyyCOkUwWVRRpsQoZizr+CxsaJYjsvlK4G5KHdsNgEM7ifAy1efZYWXXYi1Qk4/CKeey4m2uJm/oTajWN4ccxO1FXFKG2dkUgkSKVyPP28kdlYMOoEbB3vp5dbKHJYjUMryNbsI0bSGIBdC6+iqiPHYhE4vyORfZVvEV4vikZtmtO04bOo1cVs+O4Hss+W0q53Zw5v3k1onQi6D+9PZVkFYZ0hI+cM7WObIjU7MmrGg5TP++RmZPFy72cxGo2cO3SCH45voX2/btw4e5nnXp/yB462/y0GRrSlX1gr4jKvk1NZhI+9G238Y/6SyDIrVqz879CzzUC6tezH2Rtx5Bfl4OnmQ7PoNlY/SStW/g3YKUAlf1A1834a5t8hssyKld/jf0Iwyz+RQGVKAcHPtEBy/25VEMDfHQxGqu9gfwM7pS3rP3+QPlCBjk84QiFqRtGQdoRSVFTIN98sxGQy8tJLL+PtLUat6XS66vn0evH96j1HeE1yB6JgQbMuuNQPQp5+6d7QBHztpFRUgE5dTlF2Dn4WsYrlnm1b0WqqGDBwBFU6LT+s/YEqi4FYBNx3bCVwyisETJwE1ywIeQJyJHSu7EH85fk0jTPRqGUvnHtWcupaPO89P5LXv1rBlz9vxN3Zkatrl+DjLt785+XlsmjRXCwWC3fuJPLqqw/W3c8zsPq9yWRk7/ezKM5Npsf4uSx+61d+2r6Y1g264WQnpsg9Q31q40FVZgGRL7XBy8ubzVczeGnjBRr4OfPJG5v4fs0W8vPMxPudxLX0OLIYG7q/+QXcAPrBzavx2P/yI3Xj7wB3uN5+A5LT0Ri6GHCo643H0TAcnbwxWgx4Ocr40E+sTDe9qhNjynfh5FiJ0DwA1xIFS/1e4GLVSQJtXBAAiWDh0IVgutd2Yc82LyiGE0I4b/R4FUVYD7IrtCiCPND6uGJXWolr8wieK7HBRQH2Q5NQXcxCKIEoXTPu5l9i64GvmVa+kkvK78lbV0z/V/vjVMcXIhqCqxckXobMu+AXCvbOfHb2V36NF035YzxCmNp4IHQaAvlZ9F/+HTuvXcXF3oG0r5bioNeIQlpJ/oPjOFEUPkm4yKcVl8lVF7Px9nFea3qHWIPAkrPn2J2VR3tPb2SCBKPFTC1vX3i2BTgpxZTMnn++L9B98pKSkNva4voPFdKeROr826R8noDnAD/qfvuUUW/3zfYFOHJiJ++8MwZnF3eWbzqFr3/wvUY64AXADJwDRiNWAfhjfFEKez8FfQ60bABf/I7P5wujt3EtfjuhgS1R2jpRZYb1Gug9bx2XF75Jhx6DcHUXo+Jqh8Ib4+FOGnSMTWDPofXUr/stvt4PSlI3azSGHQc+R1GuwbYsG72dKx6bB9FHVsa2iCHUvzoJicaGxDSoGiWlyMGfnU1mYKtXk+cSTp5LOF0vL8YklRPq2QHb5vtY7nCaPuc/wKXyNhajgKrkNgA3/dpQJyuOWgVXsNd/zuZn7AnIvUulkxSXm2Fo5GJFSKWunM7XvkPZJ4+cTUZiD6wiv0Vj8m/YknrIgbIBFTjdO23kXbTl1fFR9Oz0NUapArNETkvbNiha/QTADo8svrm0kdHH30GlK+d0aBCOafXwUH1NnvYIs8Z0Z+W+y9ipagqVTq4uxA72o6jiFi5hOqRSGzzdw8jJuwmARlNa3dbVOZALazIRBKG6SqydowPlJaUsev0jbJS2LFx+AcXPNkgkErQaDb8u+p6v3vwEgE8aLObFMe/+5n4XBKH6l6AgkSBXKFiw9affPlisAGJ6ZvvABv/pYVixYuW/DKlUSsv67f/Tw7Bi5X8SQQDlk4tUWrHyt+W/XjArPJ/EgXYfYjFbKL6YQpOFzz74UBBA8c99c1MopgA1AOfIpB2hnDoVR1paCgDHjx9h6NARWCwW6vlFMnjQMKo0VfTq1Q+AW8np1X2pG4sVL3r06INKZYetrS1Go5FNm9YRFVWXwyeOkp+RwbCOfcgpKaBdXTFKQmVji0kK2elZbAM65gpo3nhTFMyaChSGFFCaX0qc61GxqodrFHWlAaz8YFb1suf9skncTqXl3E7NrBbMHua3snYTzu7g1DYxZUwqUzDi7Y3cum7mzdlzWPXdXnp17cKkSWNpgj8EP0hhnXc0gbwKLfsScpnUsA5avei/ZJDfS8uK8YBYIBa2b9jFskU/IkHgM9Mr1HE4QK2xYWxIm0nliTz6Z3xHRctyrsafx8sjkCnP3uJiXDqN5YGcLqtgy54YgvrF0yy1IZ82aUHGrPNs/6GKbzeXIRMEPvKtz+tZV0m7LYfi+yst4WpGNN6eahCkHLmWhX8dD7qMaI3ZYsG88jh5FsgDJvh8gKJEjNIJ1kezy7IThcyHzvYfU/FFCYoQV9H1HsRosPJ7C7lzFRq2I8zlgZBUy048FlDaQ1AkN3LF9NpSdSUVggwH3xBOZV5nZdEVZBaoU+XHZO8gyE0jy8GBhLQMsR9nXyJdA8jMz2fqedHk/1qFhhMfzyO7oow+TVuIvnUDGz1x3/4ZnF63gcXDn0WmUPD20f2EN2/2u/MkfxqPscRA1vcp1JpdF5NSS2lu3hO90+7EX+Xk7Z1kXL9Blx5DWbd6GSajkaKCXC6eOozv0PtpwwqgDqIKG83Ti2WJwJtAJGd0H7O4QCDgXvX5a4m/P7dK6ULzRmMwm82cubSSOQRyw6cDQmQH9m08R9Q/nIJ6twOz2cRbn7ShsqqQ42cW88lbudXVTHt2eg+Z7Rt8sMwGj/ng6v4FQewG4C2lA9fd+nBNUKB30SNz9aNEI1bJtNGLf7GYsdOW4VOaiNTOifVeJ9GaTThrRFN9QRC/7xYgNPc8FkGCYDGjMGowy42EFe2lVB/IjiYz6Xfuc3pcXEhQwXWkFhOowH0UQAmOd7XcveyDpUpD4S0ZToGgVwt4RCqwk9vT1N2ZuPJ8Ojv70LThJO7uF4eXV1qEPOdidRpphO04nLxzsRG0mI1QmKGusb0qysoxGgy4uLsxe95a5i5uhd5kpn+HJcQ07Mini2LQ6Stxc31gxP75+mX0CGxSnWppsVhQ2qlY9PlE4k4doOCmLf6hQdRpUh+ABq2aUlX5YLnqikoMej0/fv4NJqOJcW9OxcbWtsa4vPx9+Xr3KjElc+LI3z9QrFixYsWKFStWrFix8rfiv14w0+aVYbmX46TJKf3nOtEboUoH9rYgEyNZwnEnFFeyKKeDmOtFZGQd5HI5ZrOZqCgxXfHClB8RqnQ4qvX0WDsV4Z6Z3isj+5OUmY1MKuWlIaLhu0wmwze0NpM++Rofd1d++HwRiQk3+frr+QBstjvEiNFjOXPoEN7uniidnXBydYX0VASzhSpNI0olJsxmMzczr/ONywIM9gb69h3AqLZjcXV1e2TVpvTvADo1ERGRtGn4IMXSy8ubqVNnkJx8lw4dOj8yX36FluwyDV7eoUhlckxGA+7+kQB8uWoqDcI9cLaBc+cOUK9eGC1btq4xfzNDPhUpl9CHx6BNSSe0fghFuUV4OciI7fQmrQY+MMROvScumrGQYZZSx+19bmasI7FyD8jhVPIiduQFgct6ZDKwCGbmz4rBReVPwnkLHQ/LOLF7OOt+Lcb29C2uXC1Bk16MBXcMFgvJ+grkcqil+4EU19GUFSvx9DMTERBE/RYNERQKQi9vQ3PxW9IrGuJT/jLe+gZkKq4gWCAorTnGBjqS7uTxjvJXbro4oFpri8xWzoTBt9m8OZOJE2vx3XdNxQgziQTMZnD1htN7eCkrk/DGz2G/oREtRtcVs/DuFT5dNeMNvt61lZ6Nm+LrJkbsncq4xXflojA7Pj8Zus8EjZrR22ZjNIupaHPbv4CjjR2Cmxfujo4UlpejsxcIrxVEM+W/zzcw4VgcFosFg07H3TPnnkow8+zrR/bKVJyau6E2FvFOZDPKC4oYNEfGwNlrgXuppCmllB+8yoEDP/LzhZ8BiDtzCC/bWkgFOSqVIy3a93yoZwE4ce/1R6phzQJ2ABAia4PcvgdlHS20SNQwoLMNYlXL3+f4mW9ISX8ZU32xL4sgobCqFJycuZtyHI2unJja4rqlZl8izykChUFHgnsDGiXdpaXShsV+YphWTIQNtjag1YKxoDEWdwFBsJCXfIC8sFeJD79XxVSDqHwJ4K2tpIHSjpsZ5zgf1pcQrZrrLoEoC24huIZzsvYw2txajcwiVtgo1vYlzyma1Npqgoouke8USnTaIcJzzyHNOUNUxmHsdGV4ladWr6PF8iC83luXRoI8GgUaCq47UHzHBqm9ioZj0/hlw0ic7V+g9oozODo5kDs0C3/nI+hNIZSFZiM16UBmB0Y1nuWpBPg1JuHibQpvg3+bEsxmMxKJhNtXbjC+7QB0Wh3zt6ygTa/O+GunsnLuYs7O+4B3fq1Ap68k9Yg9n26eh+q7ejRu2wKN2QWFrV21YObk6sztjK3kSTYS0RekCgvZqRl8OV30bPts7beMe3MaZrMZpZ2K/uNHsH7xjyyd/SUAChsF4996+ZF93rxzW5p3tvpuWbFixYoVK1asWLHy/5H/esHMr1dD6n84hIqkPOp/MOSPd2CxQGahKHCUqSFITJ1SIuctalbFioiI5MsvvyI/P5fk5CScnV2o80xz7Hyc0RRWoC9RY+PmQEVFBZmpSax492Xy8/P4bulC/BW21C8u5qPscs5cS8Zghu4tm9C1URRymRyD0YCffwDu7h70HvZM9dgmTJhE3NGj3J2wBlWFBYNSycKFX3LjxrXqceXm5tYQy06fPkF+fh6urm7s3/orETbwQvfmj/g4NGjQiAYNHo1ASi9R0+DLvZRU6ZndLZrJX10i//gh9Gt3cOfuG4SF+KLNLwXcsVgsVFbWrLCVmZ7F7a1bCABchXJ+OVOCzEbKsy/2onnD2viGxlZH0wD0HNCFa9dO4FTpTdvs1hTUriIgsilyqQqDqQqX0BasWuFIl84l+PmXIEjVaB0UZHrG49zBQuRVCIkp4VjiEO6eO871hJbUbpJLiOCAI7aUT/2Q+mtaEOl+lGYDwnBuEovCBiov2bJjRRy7LvfD2bYdY5vv40ROLvs8VkKQhTeS+9Mm04CfOgCmg0egM30OtWJhbBsUSjnl5QY2bxbNZX/6KUUUzNx9ocezorG/TA7nxLCaLmVauHhPsNyBKJilQau90bRqFg1tIT0hnrT4W5y/eR2qACNs+uUEp3fGs2/OZzwT1ZFjmdeo5exLmwAxJdVBpaLf4Bb8cGoPhS6lrLi+h1lNh/3+cf8n0e3lKSRfuITSwZ7Wo4Y/1Tx1v29C2Jy6KLxtuXHoEOUFou/brcN6Bs5eyn3BzHI4BccqJS+1eonVF1djspiwtVPhovShgU1Xwlq0wNHtH8stL0WMFmuJWIb1Uf/Cs9fgg2/B1xPmvQqOdvera8rxkgaw2x1U3in4lxVCug0Yop+qkICT4xmeewa6mV7k9YQ0bHLMtO40hZu3d7N0pSiaK0ccY6drS8yVblQNPolTZSalghnBLpBtFgv9K6voYq/CxwNeHwdzlkKlrhMOzu8wsGsEqzePo4lrAqZbZVwN7ka5yrO6xGCaozc+Knfu+jZHbtTS+NIiBiRmITdqMAtSpBYT+Y5BeJWnILWYqdL0QF84idCMS+gaxdP+5koetppwrCpGEMTIUIsFLMhIK1qLh8MCBEGPjeIibYYnYCo3k3XGnpwLKqjUUXDTFs9oLdkHTuChzcazfwlFJRbc7b9DKpHjcQfSdik5edUBn2gXGo2CHh1nU1TyHHY+xdg95Dl59tAJ1BWVSIP68tUmT1QhkHwrESwCep2O5LMl2BqjyDpTAlQw95X3WHx4P+Pfk2Jqs5nalt307mxPh37duZn+a3W/DXoEsmfdYsSoRIi/dI1uw/ox9ZMHqem2dg+KPCjt7X53/1uxYsWKFStWrFixYuX/F//1gpkgCMS8M+Cf78BiEcUyAJP5d5s7ODjw/vtvUVpaAsDi6R8AYLCR8O3Ovfh7uHHt2E7yC/II8g3AzsmJhIR4Avfv5cfGsSjd3OhRy4E9yWqCPFzwdXDlgwmvUFRWSlS9eg8WVFQOJZWoVDZ069GT8M8dSVl9kpBxbflo7+LqZmFh4fTp07/6//j4myxfvhSAgIAHXmS5udlPvUlu5ZZRUqUH4ERyAXN6dCRt3AuUnTlF8dFDLN59gE0ZF/A/fJkIuR3hdevVmN9WaYtCoUCv16NQiDekRp0Jextf/Go1fWR5x+IOc94xkhJnR5Lt3keSK6fBT70IajqSjGvr2WXWE+qbiK1UgdkEEhxw3Nme4tFbcLkkRlx5OmQypPECAGSmbGS2dQnse4CKCiUnt8ZSkOpNLc9WRGYn4qloAhawsQRxLjkGvd5Cvt6P+PyGHLJVQboAeZAXXkD34DlQF6gLcd+8Tsrub9m8oxYT553h9Ik4GtTK4mqyLwMH2GK2mJEIElCJvk9YzOAZAPkZEBiBvoEB9Q0tLoPuff42cBtMa4zMbDsTu7QUBJOZshA53CvqWlpUQWlmBW/sWc74tj0oe3kHSpmihkF2x4hG/JC4B1eLLdE2vk+9n/8MfCMj+PDcid9tpzcYkEmlSCQSNKkXAQsSWSx1OrSj2ZCepF/bR/93jcBgADRVahSuaqSVCvIr85FJZdSKiOGTxRvQqheRlXiJiDZhyB/Julxx7+8pIAGo/8hYNh+Cskrxdf46dGo+D2iPWDUgmgg5kHNPBC7TiRU6XZW/u44xtTsBv+IrzeT78Jso6ixGEASKSlKr2+xwbIRakIGTKNKV2ftjp8ujCvFcZi8Tvy8GIxy7AF5u0DE2jQbhAdSv0x+DUcuvWyZSj1u4l2ewpflb2AlS1Jb7JvgCz3tHcGf/6/gXxT80OgOlKk+cNIVILeJ5TqMXt41W3whndVm1WHYvYA2j2ZnCypepsHUkKTaJ0MtuVGn7UqYdhKvzabLqfUPju5s50nY8ktxE7C6IqcFaoQ57YzuS1iwIpb4cSeFBojOOABAR1onElONk5vsgo4ycG0Zen3QbBydHpjod4PLNTTSMHlxd9rpBq1gcPQMxtV5MjlHGe4th/idvcnLPYcxmM6sX/MiQTyOQ2RZh1ErwDnWhqBQqq0DiHIltYCQj7wWGefhNQ6stx2Ix8/1HX1Gc5FC9dXLSsh7ZnwPGj0CukGMymug79t8nQluxYsWKFStWrFixYuXfw3+9YPYvI5GAjytUasGx5k1xxd1cEhbtxaNVBMHPtARELxyNRlPdZsHGFUx59nmmb9zET/uOIxNgdIzoE5aTn0vH2nW4FX8DQRAodXYGwMVWSt9wey7E7adD7dp4uXrg5eoBiod2V3mV+LdKB0YTXi28Madp0J1aTUsXV64Z9LRv34mBA4cCUHb+HCUnj2Ns2ry6C19fP7y9faisrKRVq6dPG+oU4c2oJsHcyCnlgx6iWbx9nWjKzpxC6uCAS1htpji7wdojQCmmqS+BvQO89Q7UjsLdw40vl37Enfi7NG3dhD3bDqBU2tK5Z4fHLi9L4sw1GwecnFNRN7rOB3GT+HWFmeVqbwY2tHDi/BWyizuRtFfKsGEHUKl0GKpU7OjwIzGBF+ka/i0yqYG0oigEzMT4JzJa9xk7qzYx/5Av6hIlgmBG4xxNiUTHgldseHFwHoLWQmydUrKOOSAIcCJtAkLgWgBsTHI+jJuGZJgEhoLJZOJq3GnCjTPoe/NlEt6LJ6d/LlO/UZC2+kds3JTsPefIvjWO+PurmDWrNoIggXb9waAnt7KSZuYxZHgWsMzuJSYy4H5wCyaM7LbNYrDJhICAzP5BhI1UKUEIhdU5B1m97iBxIxbR0ieKMxvnYpJKaN5nKiPqdCIUZ25sPEz6ppMkGB2p3fhRoejfxZ3TZ9i7aDH1uneh3dhnuRx/ix3HjuDi6MiQUFvyvxOP2cBJ63BuOpRp6zcDesSwOmcunT3GjHG9UCqkzJkVw6c/J2Aw63n2xTfwDzICXxNWByAbEPvK+jmVsjNFhH0wFoX7u4gpmVGPHV/7JnD6Crg6Q0wEiCmX/Ws2ahkAZ7IgyBFclaQYIc0EbRUgeULFH5nsOaAMKMZG8Qb3Q79aNB5HXkECGm0ZNiop6w3goc3HYtTR08mRF/3cmFNcRmulLS1sxX1/8RYcPS/2u+NIKvE3nufWnf3U6/wFUqkMk8mIk1THVJUtSd+7cam+PaV+2QzziESq0qMpulljbBagwCEQiyAhIvccAI72q1BrGuAiW497UWW15dv91RNkFRzoY8fAs3NQX/kBTc5AEMwEtMrli96BZKdMZrZOQZJ3LMKkhtS3EwgrjMPc0o4Mp1CMchUVOHDMazShedeZPPAb6tcdRNtre7jZuRiXg1dotXMjN+5spEWTcQT4NSLArxEmi5ln4o9xojyf6E1nKS/MQ6krRqL0xMMFIurVwTc4gMzkNDz9vAmsFUmDCYfRldgw68t38fOB8QNF/zm3nIVM6XmeF96bSUyzRvTp+hEA2745QAaZ1dunvLiUnsGxtOzWnre//QJBELh84iyhdSKo26TB43e4FStWrFixYsWKFStW/l9jFcyeBjtb8fUPbH9+AQmaDDw2HaCXwUTGpnMEDojlrelvsHzVD2RmZXA3M5VXPn2bbIMzAEYLNGzSFm1hNm0bNiO2ayeiGzUmq2NXWuzZyc3yckqdnHBQSKkoK0OXU4iNXAGOKjYd3k1ychIDBgwhzNmLgh3buPX+LOzrRKNJS0WTmowFICCA4QOH0qRTN9DqMWcXUnXmAndnv4Vjo8a88Pl88vNz6dSpG1988THp6al89dU8PvjgsxrrV1maj66qHDffsBrT5VIJv4xqUWNa1KIl2A0eQGGUD4KXN+h1WCQSNEoZBrkEp6JC2LsHakdhsVg4d/ICOVm5NG7ekFHjnxydoTNVURV1GMn5KGJbLUBlX8jciMO8mXCLDYku7Lv1HAm5zZBIRZ+6ffuaERycg7YCLGYZ11KbcTc7EpNZis4oRowEBlwjo25vDnm/jcEgChAWi4Rz5+sRO/w6TTXH+GFNHfwjSznjHE9M7TwK8iI5FteTd9+7ypn8EppU9ubH/Dyuz0vkw64xnD69AZ3Oj3bqsbiaAjEEJiORSZHIpNgHGSi9dJBVH/nw6872AISF2TNgQMC9DarghyPbiSwsJhQp67evI9eugIDRQUR8Xsb6uyvxLjNQqJBh6+6C2eCCU3kVXes35oUuPZh++BtumMSb+4KqUi4snsaOvWIU4aXs20ydvAxnjQyzUYwyyknL+LcKZka9ngtbt+MbVZvAmGiWjHqO/OQUzq7fSEyXTly/k4jFYqG4rIz09Ezuf9PKr+3CsWFfJHJbRPVQVBCPH9iGVlOFVgM3S9NZedgPnXYbHl6tMJoqKKsIxM05nVtJLahTC355axEXDx2nVk4dKm91pOlRPZtXLyfp9iuMefFNPH38a4y3Rxto1RBsFOLrsUS6iS8gxQhdC0ALTLCD955oEScBHi2pKZfbMqTPV9X/v24CN4kn0oeEt+VeTjXmCQsAZwcorYA6IQdo2wiOpOXygSmERgMPELS5O3aFadjvm4HZuAKtYwVa5wreKjzD+YBe7FIOxFH7PSVKLwRMOGsKCc+7QIlKDF2USJUoPLejVOXglllIZUUf7J0eiGwWIC5qOBV27qR7xOBwTUYlIFgk1DX8ykdfzCTzrAq/ZkaezdnOziav0HrsO9RJ+4z07Mu4VWSS4xpxL4JXyu3sDAoc1VxMMXH7ph0EFlPRvjZBhkzWbp3Etr2vM3rIz9SN7MGVyhLWFaYCoG8dht9cHYb9fZm8bDP9evqSHJ+Is4crMpWFUa+NRp9uyzP9llG7blP8fMRqo8/1h4TL1xne6HMAivMKWHNRTI+uKCvHWV4P3xAIqxtFm54d+f6Tr8nLzGbTd6voPHUM6acu8+kLryEIAl/vXkWr7h2ftNPRVFWhVKme+LkVK1asWLFixYoVK1b+nlgFs38Wi4UTATnopAI54eD15hpMBWqavNwNe6kdbz83lRc/eu1eUwtrZ77Mgt0HCXBzYcLEYWIhAakEZFISEm6y8/B+BFsbRgWHEp90hwtKWzKzM5n59Uf4uHnSp2tPdu3aDoBWq+Xddz8gfcNK9AX5FB87jNxD9FYzy2Sca9qc0zlZ7B4xkFc++RpXO2d8evQnZ882dIU5tGgmil1ms5nMTNFQPysrE31VFVnfLOROUQHSti04uWICOk0F/aZ8S1OfF2A30Bl4jG+7SSqwtL2FQu4SQSmvhbbjo549yRrjjtlGxoTPDtG0ubjc86cusnrFeuD/2Dvv8KjK7W3f02fSe++dBAgJvfcO0lFRKQJKxwIoIkVUsCEoCiooCAIqVem9hJpQQktI771PMjOZ/v0xEIzgUc/xlN9n7uviYrLn3e9+955dn73Ws0Cn07Pw7YcG/8XZWexZ+wm2jo6MfXU+p2u2sOn7y5jy0zHW68AGxHoZGxSfMmywlPNxFqFMJjfj4GvCaJKgraqjucdVRnU3ECK149i+WE6UKynDYvCdmxdFD18j71nvxjPgPcbcuYMJELkruer/JbYTPLFNc2RvXSrkhqErCaBv+GXO7Swj1JBNqBN8l1zMnnLLmGvm6OjVqxidWEya4hpFIyopCC7AoAWRSUNdmsVPzl78sMqenY2A+BNnkcnltOzUjjuXjtJOYDkc0yValiR8j9BgYnadDmXxPWIuB2Lr60lpYSWH84sB0FuZaDcoijE3OyGvTqBDSAuGh3TmVNWahuXsSz3HbCAoKoKspFQ0KhXRnR9Ne/138s302Zz95lskMhnv3bmOo7cXpZlZKOztkdvYEBsZRV5xEa6OTkT2Hk152TVq7xyl+uIWDDVFBL16rFF/A0c8x4kDPyCRyug98Ah29mFwX08qr7Jl0uIb+HrcI+dOOe/OPc3lsydADGlet+ls35+bVy7yweIZANy5Gs/qzYdwcnNttAw7mz++frlGi1gGkKr/x2212jri4r/AxTGIVs1HPraN2yN2aLuwCG0dgW2AGBdH2P4BbK+5zWlZL8xWmcSqrdijg+vu3fBUuCCuK0BZV0iE1zNcsVkJSNGYDUiFQtxrviJR/QzR9GzkS+agLkIiVuDo4I+p/B5Oqny0omAkVnsbjUgA1Ci8kKkk+JQnca/FIXQF/nSS3uTWvXTyA15CGJ6Cf/4RhPWVdDldxu3yznQa1oaM7PMMuraGTPdYLoY/iVZmi9EoZPKJFILPd6SZqRcVMUn4enwEQIXcCb1YztlLa4kKH0iowpZWuiqk2afoGDGczuvfIzgqnNiulnTjj2Z8wp0rNwBYOeVtjDohzt729HhVSI/OL9Gl3QsAuHi6Y2NnS52yFv/why8Fft70Paf2WqqOFmblI7dSENU2mpL8QqxDfelUfJnwE8eRYzm3Xz93+TcFsy+WfcSXb60ipks7vjy5E4n0txTYJppoookmmmiiiSaaaOJ/jSbB7J9Bq4fCCmyc7NDWVCG3VmAX5IFKW4iVhy35u7YhdXFl+BMjuLh5IzVW1hSUFvDWmGGgkFrKyMkkAOze/SPnzln8e8xmM9qu3bha9DAVSF2vIaMgh237dyOXy6mvr8fb2weTwYChrhYAiZMz/mvXU7VnH+cwYrifOlXg7sGb6z7kzUlzKCwvYau3J09On97Qt1AoxN7egaqqSsRSCcnffM7FLZtIaNsWdv+EvdkZK2o5uusL2mRMRagWwmHgNCBpvEnq0VOOJU00nxrL2Hu2wmBVCsDnrYIQmGW0BRydHRAKhZhMJpxdLempP97I5ec7+YTnJ6DNSAfgzsUL1Nn4UJ7rCMCl75vT/bkUumyczWn9LciC1v0jqLqaikRdT/a9loCCwPAy+nRU4h9eBBSxXN+M3ndreSO5CrVWSl29I3fyBuN74wuecVnHibBeXNAUk7hoEQagVljE5dvNQNkC9HIqgb1XuxMdsB2QYDaDT5iA/GozRoMAX1crni56jj1iCbu8cujS3uLvZiuy54mYcRxOSebUyXw2H+iOh4ec9evbYm1KJfFCPDrPLpytNNO85ato0pYB4OXtAuYanPLrKLtwBwBTRq5FMDObEYjAbIT+MW2wtbbmzfEv8LpxMlKJ5UfpPPJlVlWlYH+qjOB0Lamj4gjr1pWBz/0TRS9+gdlsRqtWI7f+cwbn5dk5AOi1WqqLinj1p11c+/kAoR07YGVvT3N7e6KCQyhKTWP7vCUEtuqCu3Y3AJqshEf6C4+K4cDlAq6Ua1h0r4o+5momBDsAFk+vLjFOHN99lvq0RcyeIGBwlxcpSs/D0cWFmv7p+ByQIBQIMZlNGLRGLh0+yeAJT/3T2yVSUM+Y2lLqq5VMiwqjIZf2Mew+9AoXEzYA8NLUc4QE/n61zvKqL6lV2xDo/SPwMmBJq5ZbwUplFCadkARdF5aaRtLzaz/s9GWYTTouho3GUVVESGE8u1tE8o3ORE97D6yEIqoHXuGW6hotzlrM/h9Q5BiKR1U6peX3GqapbHWINZL7ApHl9KU3ehB0YAZdbJdzstdkCp0jaWH3IYako7jZlmNV58i3bVdhkAgxI0BbOBC7UhXnLq8mx6cFtRJrih2CQSAkKFNNUfNk6iVaTCaLfNepKhIqP8eu/WjWOxRjEorQZcTRI+UUkeG9GBj/IcraQrRJByiWL2fMtAnka1XIBCKi2sVwaNseEJoxGS391VRUUVxWyp5DrzwUzDzc2HHjOGm3k+ky8KHgFdKiGQKBALPZIsaf3ncYvU6PRCoh/9XhmGUS0sd1pdmhK4hUWuycHH/zt/t58w8A3DgfT35mDoERob/7ezfRxN+R4uJinnvuOS5evIhEIqG6uvq/PaQmmmiiiSaa+K+ybNky9u3bR2Ji4l/ed48ePWjVqhVr1qz5zTYBAQG89NJLvPTSS3/58v8v8YgldhN/AFU9GE3MH/cCYwePZOGipfTfOp1RF5eQ/sVqkpcv4OacSfhs+prex44y6PAh1m3+nO3nj4CXJY3LUFvLvvkvcWzvTmprlSgUCoYOHI6Xyhux6b4adf+BDaCysgJdYQ1WVs0YN24S1ZcuUHznNnnePoiCQ/DsNwjbidMYOfVlYnUG+h09Quz1a9TrtHy49QvW7dlKrVHP5v17MRgMDf3qdBZxR2/Q89U4L+60bA4CAW2btWTh63sY+vRq8vQeVOkrAdCKtY/da2yQ8TTRhOHCBFoD8Hp4G0R5Wgz5tVTvSUMiseizwaEBLJzfh5emt+G5SSMoq6tn3NaLbLuWw2c17gBIZDK8g0P44SMHJHmRWDto8I8uRG5fQUtpG4QCISKRiBEdQpngvoxQwY2GsaidG6cb2tR4oLX5nCmdXmZmD0s0272SVkR2HMSlsW9hM+Y7wgafQn+5LZIKZ4x7R7Hw6TSmPpGLQGBu+C2iSkPpX7sEB59hjH0ylYkdP2B4zGe8pKzB97wfYaru7DFXUVFhMU2vTsmiMCMLU+UzBJZNZ+jgQpzbnqJZSyni++KWwb0NJrMQa7s2RE2cyMCX51Jn3wzBRRHNnDviFREOQLvxz3DIRcL+QC3mtia2LV3ItIFDAYvw+UAsA5C36MKyHssQ3q5BlVbI93Pm/v4+/Tvo6utZ2rE7k22c2ffue78/wy8Yv3Y17UaPZMw7y4jo2gVrR0e6TXgOz7CH4oFAIGDjlGmc3bSFzXNfx9TmFRSBbfF6dh2Z+XAz5dF+X7hcxJ68WmbGl5Cn0qPOUnHzyYuMTr1J31aZgEXkazWkHW2e7MTRpG9Y+NHzZFdms3bEWgZ1GkendsOw/weCx+9RoFXR/uJurE/9jPu1MyTHnbj/zXUu3DjFtoN66tQP2xsM2oefjVp+j8x8eHL+AZ5bmMTek4tIrMvB/fJXBMZvIKP+SdyFFjN6G0p5+eYzlJesBGM9ArOJmKzDNCu4gNisZ983vVgoUHNLVYVP/C6OmtOoVbhwqsXzDcvKdmnJyeZTMAkbh7gVO4QQ36ILZTa+PCheKxEV09LTDxebjfRN/JJhV94jPP8CAqElilKmVyHT1RFYeoPonOPURB7GKuJZ1FYS8j3acD7yGaLyzjDl5EwG3JuF1mE7lQF5SCLv0TUWUrIhJUfBT+k1DeOJuytl7sjR7Nr/MgaDJabPDGxbs4E95Tn4x+/C89w2tsQdps0UNa1fLKfjJBuGThhL1xcs592QgIdejZp6JbeyNiP3KWoU+dW+d1d+vHWK/k8Ow9ndlcBmYQDodXrcj+3ERqunt5MXDnIrfIL86TtmyG/+fmNnTEQkEtGpfw98QwJ/9/du4r9HcXExs2fPJigoCJlMhq+vL0OHDuXkyZMNbQICAhAIBAgEAhQKBQEBAYwdO5ZTp0490l9CQgK9e/fGwcEBR0dH+vXr95fd8C5btqxhHL/1Lzs7+zfn3717Nz169MDe3h4bGxtatmzJ8uXLqay0XOc3b97c0I9IJMLR0ZH27duzfPlyampqfrPflStXIhAIHrmxLikpYeLEiXh5eWFlZcWAAQNIS0tr1Gb16tUUFRWRmJhIamrqP71tmmjif4mJEycyfPjwRz7/Fjdu3GDMmDG4u7sjl8sJCwtj6tSpjY6JuXPn0rp1a2QyGa1atfr3Db6JJv6PM3HixIZrmUQiISgoiHnz5qFSqX5/5v8CAoGAffv2/beH8W/jzJkzFs/2/4MvxP62EWYmg5GSM0nYRXhh7eP852a2lkONCjdnVwa0iLCEXOSVgUCASaVsaFZ8NR4JINfW42eloHPPnjx44kx5dQ7nykrQO1oe1tu3asvQowMR37ThdcVi3g1eilkAMo0GJ7MZnxu32CIbS4htKlOmvM26157m2ICBaORycqRSusrlSP09KMzMJib5LuqqSpyrKskKCESjE1kiwoRgZ2dPfPwl0tPT6NdvIG5ubmQpFAh6B6N1kuPg74GmRMmIbgNwc3LFreNYEgrU/OjxLfYprmhiNEwWvdiwjqWlpRw8+BN+fv707t2P3oRgNpspLSvBycmZT1xGcmjfMVzHTaJVG0u1zMK0yygLrgDw4/vDKatWYWM9jxqtGQlGnnj5Da5cTmT3hrcw5tXxTvFy7Md8SerddVjdtqXluz4sy3mG7JuHsc1PRmAWEON7Cnldd4qVsUTI9pF0T8uOw50Y6+jPyRxQxKaBCYxmi8GUu6uZ6LIn8YvrQX7IZQShx5kksuOteUuYODKF8KgK2kRVUFFSwqXrLVgf5sQTys8AaHbVm0+LD+LlGoC7fRJFmgv4i7oystMSvvGIZki9hgun8zh/PZU9Z8pIkPtyou89unXfhrvKTJ9V9wi2jqRbmRJbx0tIgnri6wIjO43GaDLSZZXFVynuZjJHrl3CoFJh5+pKs5wbvHx6HTFuITwZ0+Mf7qIBQUFIFDLMZgGBof7w80awc0IZ24v0sjJaBQY3VBoEwKCDu1dAKILI9iBqLJoUpaSSccViBn9+yzaGL3r9Dx8uPpHNmLtz+2O/M5hApQeFGGxdXAAQS6V4D5qNa8AqbqbAnDctBWrnPgtj+j2c10shIb1Wj71EiI1ESPqbtyndYxGQRnz5ItqhahRW1pw6spvczIeKW422hr5dhhHUbRQ1ymr8AgNBZwTpI7mQv8tddTVqvRbxfV1VrdEA6dzLmsHray5iNgtJy4FllgxQRg1ejb2dF65OwUSE9Pnd/i9eL0Cr8wZg97mnkPp/Tam+FZ8EbaWZ4iRHZceZkzefbfn+uOcFoaoLQ6NogVSahkrmgEKvQgAYjTou3P2J3a3fx8MvgtKCI/iLhfQQCZDL7Kk2GSh2jkRp7cpPbRfQNn0vfveraCqtHUjx6UKKdycGXl2PKWkl9lZ7cLVZB4BJ60e1iyeXYofjVpNF84x4KuxdaZVyCOe6ApRyZ4ocw8jp3AqhcRBGsRxbrZJb/n2pFHRBcHslgaW2qGxPkOOzlZiCFwFLBV+nlPaE+K6lpMgGt21nCRxdw5lLa5CIFZiLI7h7tBT/sFAOl+ZiApCJuWdjJsTVch729rBm4ZxP0OnUlJTdw8ujRcO23Xt4XkO0n72tF5Fh/Ru+222v59LC4Sxct5jgAiWzho3AKC0hNPAm7X5Yw9oNd6D88Sm1v2TigplMmD8DgUDwu22beIjRZCIuo4wipQZPOwVdg10RCf997/eys7Pp3LkzDg4OfPDBB7Rs2RK9Xs/Ro0eZOXMm9+49jLhcvnw5U6dORafTkZ2dzXfffUefPn14++23WbRoEQC1tbX079+fYcOGsW7dOgwGA0uXLqV///7k5+cjkUgeGcPmzZvZvHkzZ86c+d3xzps3j2nTpjX83bZtW1544QWmTp3aMM3V1fVxs7Jo0SLef/99Xn75ZVasWIGXlxdpaWl88cUXbN26lblzLS9Y7OzsSElJwWw2U11dzcWLF1m5ciWbNm3iwoULeHk1rrickJDAV199RcuWjatim81mhg8fjkQi4aeffsLOzo6PP/6YPn36kJSUhPX9iOWMjAxat25NaOhvR2EKBAKysrIICAj43W3URBOPw2g2kqSMo0pfhKPEk0i7rogEf/7a/+/gwIEDjBo1iv79+7Nt2zaCg4MpLS1l586dLF68mB9+sEQsm81mnn/+ea5cucKtW7f+y6Nuook/jtFoJC4ukaKicjw9XejatRUi0b/3+BswYACbNm1Cr9cTFxfHlClTUKlUrF+/vlE7vV7/2GvzX8G/s+/HodPpkDZZgPyl/G0FsysvbCRj01mkTjYMTfoQxa9MtX+LS5cuUFdXS4/uvZBIJBRVVGE0GPGRS6BeT/CM+QhEEs7npJIuEBB9+yblLq6Mfm0x/n4BDf2Y9DpcysupdnTERiRmZIfeiL62VOEM0gQjN8nRiDR0O38Ol4oKANr3vYlS4ghksOnAHjRyiz16jVzO7UsXWL3B8gDb0WggAKhXKFBZW6OTmVi0YDFF5SW4iK344Ks1AOTl5dKzZx+y43Yj9nIgQu9CicBygCXnpOPh7EptvZpOLVrTOrwFP5QmEC+vpeijt9HW1DF58jR27/6eu3ctaYO5uTnU12swGAzcuHGNgIAgFi1axsinn2i0DeXWDg2fNbVVVGXe4kPbVJJbQJgsl/feOYhWo0OIgeaO+2kW+Tyz1oVQV7GC4dFruXp0I3Z21ljL9Ohcy+hfv40ip2pabpBRXJPL7hWeDHXIZXOGNWcNZQgoQXpsNRO7fIheW0uoeyJd/VNpdnknQrOYZgmjyW92EqPEQNfYUtKyXQj3y0OrE5KcF0bPqEQEylfBUjOAyy7b8Ipog0AoRFmsoMBrOEEfHiZQ0I+nX7Fsv47+npy/norIxpMfpPZYG8IxyVVkngkjP89MPnexkVnT6uwqIuouMLLzYARvNMccaGZMly7sPH+ep7v1xMrKCu4bhvf0jyFx4oY/tJ++W3aRqy93Y7qwPVqhmKLKOuzqaonZMp3M8jLG9+zLty+/9nCGe9chNfH+D2QFoa0a9efdLILmfXqRfOYcfWa8yD/L8XVfcvAjS8TZuA9WUFQHepOlsuQLmzfS8vsfCIiNwfX+A1FOoUUsA8jMa9zXjq5eHCyoo52zAkepiPIgi/GYQCTAu2UQyydvY8OaZfz0w0YAIqPb0bZzb4bNXgIyGY6Ao9QaNt2yLOSJMPD7Y+eBB/S096S3bwhXDXkMEdjzRIfOwD0MBgFms+UBX/8woBNrKyeG9V/5u/0aTTD/I0hJv4ydXEJsVAavTn2TJEErDpYHYSOyRIY6CqsYbfMjXl6hJOc/g9y1LSnKK2iH7CBJUUufE3cJtT6CSGjijvB5ENkiFkI71058zT3W7fsKpUjOzu7vo5TZY6OpoNgpjP3tXmPolVX4Vd7GILpflVUgpFo9DqGuN7aKow1jDfceyIRuc1h0+13ExkpOx4xBK7XBK+sWYYqrFDiGo5Vafhuj2HLOqpXaUOvRGn1hS/xNLohM4JrhR0i+hvgai1gmFFThJX8Pt03f4S7qT6rQiMLaCoO5jrRD1igzTNRVS0ktvEvnzYdx6eWAWKcksuIKMZ2nUaYop1+nlwCQSq3w9Y5ttI0FAuFjP2fV1/J69nUActLryG43miVbl7J9/zMADBvz5yI2m8SyP8eem3nM3XuN/OqH1aZ9HBR8MqI1I6N9/y3LnDHDImrGx8c3CDgAUVFRPP/8843a2tra4uHhAYCfnx/dunXD09OTJUuWMHr0aMLDw0lJSaGqqorly5fj62sZ89KlS2nZsiW5ubkEBwf/S+O1sbHBxuah0aJIJGo0rt8iPj6eFStWsGbNmgZhDCyRc3379m301lcgEDT05+npSbNmzRg6dChRUVEsWLCA7777rqFtXV0dzzzzDBs2bOCdd95ptMy0tDQuX77MnTt3iIqKAmDdunW4ubmxY8cOpkyZQkBAADk5ltT9LVu2MGHCBDZv3vxPbZsmmvgtLlXsYWP2S1ToHtqeOEt9mBKwho7Ov/8C5N+JWq1m0qRJDBo0iL17H3qGBgYG0r59+0bH5qefWooElZWVNQlmTfyfYc+e08ydu4r8/NKGaT4+bnzyyauMHNnz37ZcmUzWcC0bN24cp0+fZt++fbi7u7Nv3z7mzJnDO++8Q3Z2Nkajkby8PGbPns3JkycRCoUMGDCAtWvX4u7u3tDn/v37WbZsGXfv3sXLy4sJEyawaNEixGKLrCIQCFi/fj2HDx/mxIkTzJs3j23btjFt2jTmzZvX0M+dO3do2bIlaWlp9O7dG4ARI0YA4O/v3yhSfOvWrSxevJiqqioGDhzIhg0bsLW1PJj26NGD5s2bI5VK2bJlC1FRUZw9e5azZ88yf/58bt68iZOTExMmTOCdd95pGCeAwWBg1qxZfPfdd4hEIqZPn87bb7/9m/euH3/8MZs2bSIzMxMnJyeGDh3KBx980HBPkpOTw6xZszh//jw6nY6AgAA+/PBDIiMj6dnT8js73g8W+r90rf/bCmZVNy03Z7rKOtR5FX9IMLt2LYEN90UppbIGh8BwBs5cjNlkZu+qJXTy8iDu5hUc+w3h3P4diIQCjnl4ggBsfjpI8IgnwdMZg0SI19J3aBvTjKCsTDos+QBTVgYpBWuReI6lwHwVo8jysKB2soOKCgwiEQb5Q7X4ZloSEf7BaHU6BvYfxM3duxq+uxQTy1UPP3aXmTFk1/P6yPYEhYfj7+lJTXo+YpEIg9GIXC6nS5futG3bHolEilAoZGaN5SZ465E9HLt9lZqyEup1Wt4YPxOfZv4Y0jPITLK8bT9y5AA2NpaDVSgUEhd3BqDhbUFqUjobPvuGJ58bhaOTU8P4XHyb03bofO5cPkjmkcM4GH3okz+UFKvPuSWpRWA23O/T0n5/XS7ZOZboo2t5A5nXeiDXb9Rx/vRdYgPtmXtJhEbvwMwYDW26m/FoHs6w3Nd4qpktL+de56eaArR6GTYZ7zPWLx/P2NdB2oXssiSCdC3J97yDSqaHegGK2ngqXV7li21xqOsMDGt5ApEQztsvQ18yDqO4kmy3IziILKFO8rDOvLc+HYOgkvQET5JLSmnmLuJubgkgoNvzI2BrPKo6D+4ljsXT+g45gEQsYdDT8+nmpCO85A7GL+wQZ0mQAFNfbMvLq/rRMbRTo/1PZ9SjNeixlf1+xb3kihxC5J5I9GJMZsivNWLvKCazvAyAc3dvN55Bpnj4Warg14ilUl47sp975y/gfT9N9J/hxzeWoK6p4eCHHzP41bmY5JYLkMkMCns7er84tVH7fp3gdhrU1MKEYY37cpCKqN3zIdO+/YyBI57l1bfWYt/OCbmPArsYy8k4PCqm4aT/3IsL6DngVzfFOTWW6DKAzOo/LZhJhEK2RXSDiF9O7Ujz0NEsemE9WQVjeXrg4yNYi4wwuQrUJljvCM1+8fKprBLi74CAwQS5TuLZET/haKWhMxf5pMVYRim+BmahM5XR2TqbYc6JVLucYrdgJla5e4n/1JvBsRV4t32STrFfMX05mFLBpQKq+oL6sA9veVTgJhCikjuilFnWWyO1fTgIsx6hKJiYrEPUWTkjNBkIVN4jh1mUKJcgcEjBzfgzRYUfkKJtzhXftiAQ0qvoErFRwxns0JkPrlRTuu8qwvd1mO6XHBUBxvsCVUVALt53QhCZhEgcj2KVI+ZBBquVqJbyiiHUnNtPpvoynUY1Z+HLezlxbCMX39sOPIzmtS0q5slzKzGabKkLe4+UoMF8LDnLO4XZnHUOx7GgEk9/n4ZqldUVlXSPfR0nB39uHcvjhbaz6NC3G+99/wUuYjmeUgVFOg3BZ5MZN6M/tdVKSktcEAgFvPLcw7TOJv5a9tzMY/Sm85h/Nb2gWsPoTefZNanLXy6aVVZWcuTIEd59991GYtkDHBwcfrePuXPn8vbbb/PTTz+xYMECwsPDcXFx4euvv+aNN97AaDTy9ddfExUVhb+//186/j/Dtm3bsLGxYcaMGY/9/vfW1c3NjWeeeYZvvvkGo9HYcK2fOXMmgwcPpk+fPo8IZlqtJfVcLn9YaVwkEiGVSjl//jxTpkwhISGB8ePHY2dnxyeffIJC8eg1qIkm/hUuVezh/dQx8KuzS4WugPdTx/Ba2M7/qmh29OhRysvLWbBgwWO//yPnoSaa+F9lz57TjB792i+dhgAoKChl9OjX2LXr/X+raPZLFAoFer2lQld6ejo//vgju3fvbrieDR8+HGtra86ePYvBYGDGjBk8+eSTDdHfR48e5dlnn+XTTz+la9euZGRk8MILFm/cpUuXNixn6dKlrFy5ktWrVyMSiZDJZGzatKmRYPbNN9/QtWtXgoODSUhIwM3NjU2bNjFgwIBGkXcZGRns27ePAwcOUFVVxdixY3nvvfd49913G9p8++23TJ8+nQsXLmA2mykoKGDQoEFMnDiRLVu2cO/ePaZOnYpcLmfZsmWN5ps8eTJXrlzh6tWrvPDCC/j7+zeKWP8lQqGQTz/9lICAALKyspgxYwYLFixg3TqLPjJz5kx0Oh3nzp3D2tqapKQkbGxs8PX1Zffu3YwaNYqUlBTs7Oz+T13r/7aCWevVz3Fz8U5cO4Xh3CYIgMLCAi5dukB0dCtCQsIsYR5FlWAwgrtjI+8vvV7PxutnMOgtD9vbr53n1jklh67c4WKBGluZiEFBNigklgfDlPg7MGws5bn5rN6yHsPNG/TRanHWasn7cClFc19na+dc6q3WgdnM6PadyQ1w4OqngyneE49SaUZ9vbzROtzLyUAuk+EikPPstPnkb11Hal4WIqOBa0UqKiX2oDUR0Lwd2oJ8LnduTcS8t3jt2emcvXGF+Hu3mD59Mg4ODrzwwgwCA4OJiWnNxYtx1BoNZGWkECi37MypxbWcal0BgY4IpGLMOgMREVF07NiJ8PBIpFIpmzZ9hdFoJDg4hLycAkpSK9i/8yjnT1xgS/tvED4rhADL2O0dAjl8JJ9yp5641EVyTZxIpUANBhF+3tU42zozNGgqLY7u4qZJyVar49RrTMwNnYntuRo+fDuP9Z6zaJ/pgtLtHq/k3SDjopDo1lqixedROfYkUuPJEu/mHK7N5fNJ9UzpXw7JodyMa0+WRMC3LkvQFHakIPoSQTcSMOUUUme0p6zwY5o7i8H5oY3c8bRwPsypBSSMt3UjxkWNWmrLjwe13MsyAHZE++Sw+eAtHOzrUdXrLOmQvrZ8PiCY7Rfv4J8UhEwlwtPBgE+LZ9GJumBwrkVSnky8Ko18hwPkSpMQ3HIguMfzXCuuItLFHoVYSK6yhI7fzaJUXc3WwQt5qlkvsmuKyVWW0NWn5SNvAlqagzkhu0i9WICT3BY6tSM0OppR+dVcTL7L289OxGg08tq3G8kuLeaDCVOx8owi61460swyWvs/KoptmDKNc5u3YufmxgdJN7B1/pOpzEBUn14k7N5LQEwrbJydkQG1OrCSWKLMfo1cBote+O3+tn75AUaDgV1b1zF93grchjZOE+rWdxhbDtwAzIQ2i360g1BnuFtmyQ2NdPnT6/MAkwnOXQNHO4gOB3iVgV3+8Tw/a+D2/aqa36nhXXu4oQM7jHxTexPDEDPCI9G0a7MRF7fDgIZqkyNfq3oSJgklVnoUqdCMrdAiRksl9Zy7Fo3N+etUutmyucMghPIapubfIr9jLfOithNrX8rew9bs7buciw7RBNitIfrcHPpUpXJF5kitlWvDCnlXp1GnjcJamsGAG58DYBaDracb9YZwbIyXG9Zl3/UtEPksADetfThTXsjh7MtI1h1CDAS8uZ3MDycCsESgpvbaeu7ah0F1BgEuwxEgQJBtxmQvxUp6j8iwfhy5PBJhdSKG+wranYu38XBrxpNjV3Jo9W2Sr98mtlsH2vfpylOzn2fXYRVHLvensOp5jqdfwtjMjMpkYNGXX1Ky4DOCIsN4akVrbickcHRVHiaDkReWvcrP605QV1PLiV0HyE5JJzgynOsxQ7mpqmTliL4kV1TdX0sRIpEIseRve9n8t2I0mZi799ojYhlYHnEFwEt7rzOshfdfmp6Znp6O2WwmIiLi9xv/Bk5OTri5uTW8Dba1teXMmTMMGzaMt99+G4CwsDCOHj3a6M3uf5q0tDSCgoL+pdSQiIgIamtrqaiowM3Nje+//57r16+TkPBogZYH7f39/Vm4cCFffvkl1tbWfPzxxxQXF1NUVARY0kdlMhkKheJ3o+SaaOLPYjQb2Zj9Er8WyyxYzi5fZ79MO6dh/7X0zAeefv/KeaiJJv4XMRqNzJ276hGxDB4WknrppY8ZNqzbvz09Mz4+nu3btzdEc+l0OrZu3dpgYXD8+HFu3bpFVlZWQ3T41q1biYqKIiEhgbZt2/Luu+/y+uuvM2HCBACCgoJ4++23WbBgQSPBbNy4cY0i1CdNmsSSJUuIj4+nXbt26PV6vvvuOz788EPgoY2Cg4PDI9dBk8nE5s2bGyLKnnvuOU6ePNlIMAsJCeGDDz5o+HvRokX4+vry2WefIRAIiIiIoLCwkNdee40lS5Y02PL4+vqyevVqBAIB4eHh3L59m9WrV/+mYPZLj9LAwEDefvttpk+f3iCY5ebmMmrUKFq0aNGwfR7gdD94xs3N7f/cS4C/7Z2/e7dm9Du7pNG0Tz75iLKyUo4fP8Lq1Z+j0Juh3pL6RE0d7dp1oDqnmKot14nMtUM9IYjTFxMx6oyMGtmd5G9/IrvG0r5Wa6RMbcDPXoqixkyrSmfU9Rq+3ruVoqJCrKxtMEiliHU6XJ8YwbcFWdTfj35AIODiwZ8Z/PMGrPaU8+znT5NiWkeNezqKaVPZkxBPXp4lQq5eq2XND1+z5qWlhPsFk56dTu+TJ/EySLjtHY2DXEyIhyPKa1fRl5Vx+7UZ5Ic343xMTMN6l5QU8+67y5g/fxFXr8ZTqNNxUlmNUAAdomN4olsv3nnHwIW3KrELURChd2DMqAh69LBUlnvwv7e3D6WlJcTGtiEnM4/ZkywqukqrQrNfg3WaNXwL1KpRXyyi1GgJy81T5NCuqz+Ca3rMAiFu1iqemvoyAV/3RVApJKbSiZz1w1m3NRUfq0N4nTrF5XY+SKssSsozrn5sMCXwdg8NU97Sk32nF8tVifSzK2aGawhHWsrp0fv+Q2+zNMSHe3IiWUKdWU9qsTex8vH42hwgt6I5N8tiCQnQgqIOAJNJgEhkRmR+eKgoVU5cyi+mQGbEocQAWEQaW9t6AqMDUdUUUJ1fSFi7gThWujFDc4UZLVT8nG5kXxrYi8W00DdDl5dNnjqLnO07WBVoQ7d8yzLM+UXItmzHYcAIkvEi1sONM7k3KayzpOZuvrqXLjInmv/0Bip9PQs7jGNFtykN4zt8LZ5V2ywRh4vklShkMspO7+GJdh3Zn3AZs9nM6VuJWMvkrNq3EwChQMAQsz31ag1lmUdZdu4QQpGItolp6AuLmLVjK5lXLWlqytJSKvLy/wnB7G3m/KCn8N4u3IL7IBKLEQHy3zgLGXQ6jn22HqmVFb1emNzYc+0+vQaM5viB72kb253My/FE9eqJ8FcX3NBmLQEV0A24BWwAxsDxTEirhFhP6OD9J9cFYBGwEXiRb39eztd7LFM/fR2CfC3ppFEhIH7M9f/EuQ8pvbuXgOavkB8ymu4yWFsHH9RCffU9ystvgycsWyJmZkA0KvVKsrXr2Kkdwz1jS/KN8FklpBkErLCNI/X8t+yomUmNJICBIRu4EB5ItasdYMcq8zUMUUJWSoOZH78OVTZ0LTvBifFpVHp3p07mgMHKCXNtKFjdP06EQk62eBe/0r241XpgrypFhAkBIBZVYSN6KJaV2flxy7MDDnWF2KrLyHNtCQIBd4M608X7NHUFddgXehF0oS1dQj7nM7kr6sjn6XvzC7wrUxCKxJhMlhcPQoGOlyZ0oXmzkeSUQppwAL5tnSjPKGXYzCFodSq+2VON1aD9LFpcyqhhPg1isZfzh4QHuVN4DTyTwpFHleBhLUGz6SsAMpNSOXrkAuX35OjqLTcdXyz5EJPJkvMbEBHCtx+sp/PAnvR/chgeUm/2t4vhwuFT+AT588Skp2jRPgb/sH8tna6JxxOXUdYoDfPXmIG8ajVxGWX0CHX/zXZ/lgfVUP/V1Fmz2dzQh0aj4fnnn6dz587s2LEDo9HIRx99xKBBg0hISEChUJCbm0tkZGTD/AaDAb1e3yjV8tlnn+WLL774l8b1W2P8V/oAy/bKy8tj7ty5HDt2rFEE2S+RSCTs3r2byZMn4+TkhEgkok+fPgwcOPB3lzVw4EDi4uIaTYuKimq0DnV1df/C2jTxdyBJGdcoDfNRzJTr8khSxtHCvsd/aliNR/A4NaGJJv4/IC4usVEa5q8xmyEvr4S4uER69Gj9ly//wIED2NjYNFxjhw0bxtq1a1m3bh3+/v6N/D6Tk5Px9fVtEMsAIiMjcXBwIDk5mbZt23Lt2jUSEhIaiVVGo5H6+nrUarXFSgdo06ZNo3F4enoyePBgvvnmG9q1a8eBAweor69nzJgxv7sOAQEBDWLZg75KSxtv018vLzk5mY4dOza6Xnbu3Jm6ujry8/Px87PYn3To0KFRm44dO7Jq1apGUeS/5PTp06xYsYKkpCSUSiUGg4H6+npUKhXW1tbMmTOH6dOnc+zYMfr06cOoUaMe8Tb9v8jfVjD7RzTsN3KpJezFZAYrOQKBANuDxZQdzODWwQx6R73Kjm8Wo0BCB/y463GVDPVRdprscXdxwNteip3UipEerRCN9qRep6V1WHPEVnIyMzOw3fQd7lU1XDhxBNODm02zGcxmwjLScT+bhtN3vlzP7EuV6iTcBVN+JlZPP9N4wEIBZ29c5sTlM4SkpeJYVUkbmYzV9ancC2rOxbPHiZk8jfrIKLR5uVx4zI5rMpk4f/4sOp0WL6mU3eOn07tFa6ztbMnWVNO583lyc2XoUrPx6liBvb0lhevg3qNkpGYy5tmR+PsH4O8fAEBQaAD9h3cn4fI1+tR3x9pkTUZ5OvICOfKbpTgHeDC2/kmuma7hX+tGqr6cnxwGoTSJ+GaIL97hbRB0F8JlwAmuelWyNOoOuwozwABScQGpNmkEqQNwa3uPpB7VaNMCEVZBrbqGAa653K1TUikTEhtxkkK1L952tqiKFEw0zKKbYx39sk/i6KLDzlbBj9eXklMWiMkkIkWjRxHzE/nCepoJwR3o2TwB+5q2nKqp4PCtDjzveAiJswHPoEoMaldcDD48McgTg7QKW9cITIY8enedwK65H+MYXUTvtn4MjQjCu9tA/E81x2WvC2pBLZ+7LcNQUcWttlI6F4gQmQUITCbyb12jqiCX4e9b3hZ4WT8Up1IzsjEYjvK6TSCritPIPBHPOVMQ7dq2R556lQ6lBUTY2XBPWUddfT119ZaKgheS7zbclFXW1fJz3gUEAgFms5kQT2/cRPZ8nHWQ45U5kGsRpzJSc4lOyeXDgU8w/tNV7Fy8nIhuXQho9ZhorX/IWWAJQhH4RCmB364s+IADH37MzjeXASCWSujx/EQAlNr7h6RQzytLP2HSC6+zsktf3ts9hB5TJjF1w/rH9HYeePDg9Rmoh0PS/YjN60UPBbPMKjidA65WMCgExL8VyaIDVtz//A6lFct4UD42txje/hLKqiwppUumNZ5TWVvCviOWtIuOFdOZ32k0riL40VKgDqPwYep1vUjKPg0MUkxHZppOmgp6y0BlguP3i2y+fKeUOoeFqIKdEDQ3oT08gD7ulSRjRCQwoTeYQCxDLDBRfP/6qlAVEHjrc/ySN3O3/bNclbmArArX1CCERhElzdJI8/Ygw3UWrplBhNZsIbryy8duifiQEZQ4hgDQPPcU+S7NMQtEOKiK+XDX23z1bQDZalt8cxLJkGspa22pFnklZAzhBWeJUeWjq86yrLtARKa6imihig3LrDGbpQgEdzGZjKg0Jpav6cvZO2cAKKrwZfRwyxgWTPuK418uBStPhq88Rae2TvTtaPnyp/m1bHh7Na17taHWbTMCkQZtvh8ykRNF2XnotDoCI0IxY2b/tz9wcOtOWnVui7uPFx/v/Ya7CYmEtGiGrb0dWffSSLyYQFhMKNdv/YCfTxv8vP/cDZ5GpaYwO4+gyLAmf7NfUKT8bbHsn2n3RwkNDUUgEJCcnPy7Fex+i4qKCsrKyggMtOzb27dvJzs7m0uXLjUI/du3b8fR0ZGffvqJp556Ci8vr0ZVM/fs2cPu3bvZtm1bwzQ7O7t/er0eR1hYGOfPn/+XDIiTk5Oxs7PD2dmZn3/+mdLSUlq3fngMGI1Gzp07x2effYZWq0UkEtG6dWsSExOpqalBp9Ph6upK+/btH7nB/zUbN25Eo3n4e4eGhnLo0CG8vf+ZFxxN/F2p0hf9pe3+HYSFWaox37t3j44dO/7XxtFEE381RUXlv9/oT7T7s/Ts2ZP169cjkUjw8vJqdO37tQ3Db71U+uV0k8nEW2+9xciRj6Zw//LF0eMsHqZMmcJzzz3H6tWr2bRpE08++WSDwPaP+PX1WiAQNLzs/TPr8q++IMzJyWHQoEFMmzaNt99+GycnJ86fP8/kyZMb0lynTJlC//79OXjwIMeOHWPlypWsWrWK2bNn/1PL/F+hSTD7BXPnzuPy5Qu0bNnqYV6tv7tFxBKLMBqNKG2MGEUgMoLCzpqePIw2EKan4pWby9Iu3Ui2EwNm6gwaAub3x8coIzvxKl6njtFqxDBcXn0dY14JJ9o3w7u6CltbW9Ja9KLjPTVm6zT26ER8uvIzZlTZYSW9gdbOE6HJRKGPD05bvqG9Ga60aw9CISbMZJ/Yz7BtWxAAaoWCwyNGobt/MPn7ByKytka2cDF7f97bUAFRIhZjNpsxGI2IxWJ69epDba0SVW0tT7TqYFkpVT25t26Rnn6UTp0k9O7dH4UinAEDBpOSlMa6VRYT+ts3b7P4vQX4/aKwwZx5loPjxrbrfPfjZi47XCD6UAzNz5iIHN+FmIFO5H5bzj2ba9xMH8Az5S14psybhMJ9LDqwke4tPRhy6COwBmEOCM0GFjlH42Ksxd3HnoiPg8gxKyn5QoZgay9O3hCwxsaFqpgVDPVIRmWQYV09GmXtYM6814qDolIyPX9kTH0xreWe3I0cyJlJFi+XN1ODyCqxPNi46635UVyPWaDlqkHMq0IxMomBwoBbcNMbrV5CaY0jEdZ5mIV57PVchasxmJs58Vxpdgqz2YzcoTU/7NuI0fEO3RKGc+uWDS1/7ErryhLIsYiNVmZbXA2+1JluMjYug5ShfXmpw7Nc+HwDqpoabFydaOZiefPRxjMcPzs3cm+XkZWnIermKXYM68ag8jpktSo2b/ma8kuXGBlihyNweewwMkpL2JmZw8bcUqxlcpY89SxqrZbk/Fx8I11ZeHkDRMMwv8688+wkzCYzE9Ztg1p4kKbgqLSUXhbL5TTv05vmfSxhzPGpkJgJET7QrfkfObo8ASkWoSngHze9j/kXF4MHn+t0UK4BjaqWZRM6kJeZzLAR01DX1ACQe/P2Y/uCNkAQkAWMsZTl9LGDfCWEOqEzw2UddLhahLROZ1lQYe0/8DSTAn2AE8BApowSYjCCoz20CLGIZQBJGY/OqVA44OIURHllJn7esbjef4Hzii1ozEqG+57A1tWTO9qWfG4O5LtquGwFK+wgUQ9FJrirB2chVJjAIfMSlc26WjoRmrl4azrmOikxcg2fLHiVr09cJVHqzdOhtqztvglF0S1cZG6EJ7yDn0MNrqHNuVoImMEjORwrQylq/3JqrVwIO9sV52x/jMK2aN0Ok+vthlEkIbjoKhKzHjPgVpNFtnsMErMJV++2fJh/mDSziOqrQt5SD6dN+OdYVazFbJZSnfMD0qhqdFIBArOBqII4dL/YNiKzkbiDc9j6rSt6aW8mDLfnmT5SSipETHurDG/bS0hFGeiMwYQFPJzv7qWzlg/qItJ/WkTad5mwYCZ9Rw9h2KSnGDbpKQDKKl6mrCKdiE/7IRQKSbwQz5WT5+kxrD8rpluKYIglYp6K6UuHvt15Z+taYrq0B+DW5WtM7jocg8FAp2d8EPhdRSKWs+TVNBztfX5jP2mMRqXmqZi+5KZlMnLqMyz+6qM/NN/fAU+7P+Zl8Ufb/VGcnJzo378/n3/+OXPmzHnkprO6uvp3Uwc++eQThEJhg+CmVqsRCoWNbkof/P3gJlcsFhMSEtLwvZubGwqFotG0v5px48bx6aefsm7dukam/w/4vXUtLS1l+/btDB8+HKFQSO/evbl9u/E5d9KkSURERPDaa6898nb6wYu2tLQ0rl692pCu+ls8Thjz9/dvqpLZxJ/CUeL5l7b7d9CvXz9cXFz44IMPGpn+P+CPnIeaaOJ/EU/PP2Z38kfb/Vmsra3/8HU1MjKS3Nxc8vLyGqLMkpKSqKmpoVmzZgDExsaSkpLyT12rBw0ahLW1dUNBgHPnzjX6XiKRYDQa/3S/jyMyMpLdu3c3Es4uXryIra1to2vr5cuXG813+fJlQkNDHxtddvXqVQwGA6tWrWp4Gfjjjz8+0s7X15dp06Yxbdo0Fi5cyIYNG5g9e3ZD5c6/ah3/k/x/JZjpdDqOHj2ElZUVvXr1xWwyc3Pxj6jzKmm18kmsff5xCpmXlzcjR46luraOizeTaBsVxo8/bOPGjWsMHvwEd+7c4obmGu7TXJgxaCJuXRt7DWxyCOQjnxgE2bU8GWmPXCzEZDKRkp7C2awcZMvfwLG6mtzvNnJk9LN8OG8JAqXlQV+h0dDfuJgYz9bMinqb/blX6V2Wj3VuCkV+vtyKbtWQ7G12dkFm0PPAj6Gurg7x5Us8uDX3mzIbXdnD8PNBgyzRPOcO7ufpfsOprFOSW1JA37ZdUddr2H7yZ157bTE+Pr44WNsiMwn4wvkedTIjz5QFIZPIUKjV2GjrOXLkAPb2DvTp0x9rGyuEAgEmsxmH4ny+WvAEI55/mdb9JjXaLk5dnDhbegej2J6goBCCwnw5NucbjkgquNveSBu5PwMDujJjiyVqqbl6PLPs4ribnEJG/ifsOh7CE70KeT1rDjqTgG8de+MmELNQWcQqx+uoZ+m5/I6UuyV1SEQmPhxYThVCvnWRIbFdh+fNpxiVfj+6KCWaDznDmfDe1AlVIBBQKnLnekYgIGCAnQc7Azrhbt6EWgCIjLRXPYGtXkm+1RdUOE5G2ryE516M5fquwxiMOdQaNGj1aqKyW1M7roTrly4gVzghU5iwVbWnS8ZIqAPj8ltobi/k++IeeHjEUmcTj9mzlNG95/F8y/ZYBVtOvi0DoyhITyOk1cO0WQe5Dbcnfc3Qt9/kXN5t1EYjmZUSYnwjSEq6g1AgQKUzYzSZEQkF2Bu1xNpbExsTydL57yB1sJjg16hUDH5rEYdvxls0LBvo1CLKcuITQrDZm1LHGnzbubL36eUkr9tIWVYOU79unBZ0JcVi8Xc9A9qHg+x3gxXCgAQgBRhumXSvGOb9CFZS+PRp8GgsTg1Z8CpiqRSplRXd70eXPSAv/Q55mckA/HznEhNfnkfhtXjGrXjrkSUr6+CDTc4YjGnMGV+Dp6MjAkExjJwJGjFYfcnsKjhUD6+5ODCrqA5spODyj976ZAI3sVjYT8DZobHX2rND4OpdmDT80TklYhnzZsRTUHSTIL+HhR2KjDDV5mN6yN4CKymu2hQ2JJcglMsplDlgBCrva4jaRAg6A7F+eRRVOuCaIKGuNUiVldTKBdjUuSCuVyDTX2F8zF1iU3I4UPEMWc4CcI/G3rk1XjkH0anP837QTtxVcrZ/9wa2pQ7EBi2i8/VD3LX2plA9AAChScL5yCe5F2ypclfkEEp0znEMQjExOccRmI1cCR/DXvtwCotvE5V3BherOiT2FykokWElBoFAR7DoLSLOJaET2JDu1r1h3dW6KIRWWcgNasxmCbXagZjq7Vm/BXb8WMes8TZUKD2QCV4k2G04Hdu8xTPDRrKxOJU3sm/Q/OORKMZlYevkxZ1TltzYt198GY3dJWKbj0Eut8PFKQhX5xBcnR/e5LTq3I6q8kqebTsQhbUVUxbNZfdX31FVVsGRHXuZsmguwVEWP7+MuykNPpbFGVV4+oHeUI9W+8dTwopy88lNywTgyom432n996JrsCs+DgoKqjWPdRoSAD4OVnQNdn3Mt/8a69ato1OnTrRr147ly5fTsmVLDAYDx48fZ/369SQnJze0ra2tpbi4GL1eT1ZWFt999x0bN25k5cqVDTfQffv2Zf78+cycOZPZs2djMpl47733EIvFDVWi/hu0b9+eBQsW8Oqrr1JQUMCIESPw8vIiPT2dL774gi5dujQIaWazmeLiYsxmM9XV1Vy6dIkVK1Zgb2/Pe++9B1i82po3b/zGxNraGmdn50bTd+7ciaurK35+fty+fZu5c+cyfPhw+vXr959b+Sb+tkTadcVZ6kOFroDH+5gJcJH6EGnX9d8+lpqamkaRpWAR7f38/Ni4cSNjxozhiSeeYM6cOYSEhFBeXs6PP/5Ibm4u33//PWDxXayrq6O4uBiNRtPQX2RkZMMDaRNN/K/QtWsrfHzcKCgofayPmUAAPj7udO3a6j8+tl/Tp08fWrZsyTPPPMOaNWsaTP+7d+/eEBG9ZMkShgwZgq+vL2PGjEEoFHLr1i1u3779SNGbXyMSiZg4cSILFy4kJCTkkWjSgIAATp48SefOnZHJZA3VJP8ZZsyYwZo1a5g9ezazZs0iJSWFpUuX8sorrzSyuMnLy+OVV17hxRdf5Pr166xdu5ZVq1Y9ts/g4GAMBgNr165l6NChXLhw4RHbiJdeeomBAwcSFhZGVVUVp06dahAb/f39EQgEHDhwgEGDBqFQKBrZUPwv8/+VYLZ//14OHvwZsFTB8C6QcHel5W8E0HnL4ytD/ZJ6rY52418iPa+QEV3bYF9jCRHZt283VGppv9+MRFuOafijqVolakvqmxmIbd6BgvxkHJ2cadehE++dOUn0/R3UgIAdtwuZnplGlbMLGrEYR7v+xNS1JkFyh/V3LmEGBqbfxkGvxSk5ifSQUNT333wLREJ0IlnDcvu27ULvDr25vWAGeoUCt14Dke35Fq1eh59fABKJlMTE69j5B9G3feMKbxmFubi6uqFWq1Dl1DF+//NcaVPI147XLNvUvYhBXq4MO34MgUZNUrNIvveOYOjLb7FgZH9mVCSBVyClkmukKovZs+Z5XLzD8I/q3LCMSn8J5pc7IgTMBOJOKGNufoj+zjVMWSkczs3gtiKOUfJQ3OutyFVkIxaa0Zen8fHXvSmtUWJVvYs2/vVIAWdTAc29XREIhAxfHUn0KU9aC45Ztq0JLllLsbbz4pahHmTJKILP4VIno7zYsv1NwBLdQdyiL+KT5kpIByu6tTxCYlob5nv0xEYo42jlSl7Q7aR5hAcDSp7nB9uxLNZ/xeII2NplJrKjUnoYpnDMuJaoG3eoN90mVGbDOm0dFZkpyK2ccPYNo13Rw4ejmsJ7TLvVmZ/L3XjJ7xPERhOO1Qo8DJXgajFCNBmNnPp+G4UZGSgkIorsTEw+9wUB9h7sGraMT56fycBJz2FdXcv1Re/ySV46ly5d5PqVeMpLqvjmyln69euIf0Q41FaCwoYsXRU9Pn8BrVFHm+oILqUkAdDGLoJ5Y8YwNqIHAEq1ikunk6EV5FmV8lPhBZavemgg+UsC3SG9CLydQfqHzyIt7/+zoN58Gqv8+6FYx+7C+MZVQSUyGUNfm9domo30fkXNVq2RdRyA5tZFOj39En2HW8w3XR8TfLLnJJxJABDi6OLIlFHwgzGJ2/oXecnmLcL5nCS9xXTz/WZePNHKGT9bMUj+kfnoaaDs/uefgLGNvp029tftH3Iv/QQ5+Ql0ajMFicQSvr1dDa/VACxjrUMKwxXfoztxhj4r94BMxoR1HyJxCmCDI+yrh9xTUFYE97r4ouk9E4+vTNif0JLU5wbq/lVMLdAzLOIwcRevk5IBEkkpdZ6J4GwRpd1Lb9JGYqb/EytIzaznytcDsKkKwwxo6lOQ6goJqS0kq9mXlNqPQ+OUj8rdoWEdnFRFOKkepq8odA9FI71YgcRoORfa63M4GzYXo1UnIpLL8ZQcQWA0IKESm5QBFJtbIECL3tyfIIcd6AwbqNdHYTI/FCvLbu1BV9uNAM8E7IRfIkAHhh+RSUeyMu82Zfp6TkvhTuZB7pxR8P5T3THX5WKyMvLZvM8IHbQCoUjIC8/9RIuIR1OBz+w7gkGvp7a6hhvn46kqs3gFBkaE4B3k19BuwNPDuXb2EpUlZUxZPoWk/O0EB3TFw+2PmzQHRoQyetp4rhw/x/Tl8//wfH8HREIhn4xozehN5xHQ+LH2wcugNSNi/1LD/wcEBgZy/fp13n33XV599VWKiopwdXWldevWrF/fOMV7yZIlLFmyBKlUioeHBx06dODkyZONhLCIiAj279/PW2+9RceOHREKhcTExHDkyBE8Pf97USwA77//Pq1bt+bzzz/niy++wGQyERwczOjRoxtMjAGUSiWenp4IBALs7OwIDw9nwoQJzJ0790+nihYVFfHKK69QUlKCp6cn48ePZ/HixX/1qjXRxGMRCURMCVhzv0rm488ukwNW/0cM/8+cOUPMLzyEASZMmMDmzZsZNmwYFy9eZOXKlYwbNw6lUomvry+9evVq9CA+ZcoUzp492/D3g/6ysrKaoi+b+J9DJBLxySevMnr0awgENBLNHgRhr1nzyr/d8P+PIBAI2LdvH7Nnz6Zbt24IhUIGDBjA2rVrG9r079+fAwcOsHz5cj744AMkEgkRERFMmTLlH/T8kMmTJ7NixYpGBQEesGrVKl555RU2bNiAt7d3QyGhfwZvb28OHTrE/PnziY6OxsnJicmTJ/Pmm282ajd+/Hg0Gg3t2rVDJBIxe/bshqqfv6ZVq1Z8/PHHvP/++yxcuJBu3bqxcuVKxo8f39DGaDQyc+ZM8vPzsbOzY8CAAaxevbphTG+99Ravv/46kyZNYvz48WzevPmfXsf/JALzf8FpUqlUYm9vT01NzV/q0bF37y7277eEMr/wwkyCTS4c7fIWmM00f2MYrd598nf7yCsuw3+I5abRw9mRFzr6k5ubQ8eOnXG/pUf52RUAQqb0pMMGSwWJ6uoqdu78HqNQwqXcavw83HjrxWcbFNzKM6e4U1XJieNHyD4cR76/HwYHezpqKinz8gCBAJlRxlOFz1Jpo2Z03jrMwNtFibSrKkItl3O+c1cqXFwwCcQIzIZGqR6Bnr68MWEmQjN8tncrtSVFPPvUJOJSbuJoK0KnLMDNP5q9+w7y9tRXkcvkpOVlUaOq5ae44xSUFTO89yCekI2A963IDatmxeZTGCRmxtCC1sezuDHMEmlS4RfAOJtm95frxp6MOFoEBLOLO9ykCAQCZqxJwDv0oafJKdLZzk0A+hPKGFpCvY76KjV9p5zm/NVKGJlJf6GS0Ovt+f62DjeHm0hlTuiEnqQW2dLM5TYjY9eiM4AgZARTps7EWBvJwG5n0JlNvO8Xzavqn2gZk0+b9mZ6hXdk65E9eIS4E9E1AoPBzMa3dCQk2iMX6tCrLSpP327xBJq+w1Zai95kzQDNFrqrh1Oi1zIg/zDR3ofoppxHWzsJraTBlIsKWK/4mHyuslK9icxae9omW8Q6H4mCF4ZsQ2uyeK7MqfgCt3of7slzWBaUz/KpUqY+eY3LpVbM6b8HmdiAm701c0b2gYHPgVRO5u1bfLP4DQD8XB05HG1in9oiTOwY+iZPNevFKyGRlGRkYufmxtr8DMQSCWHvDcd340U+mjOZGM/7lSLb9wN3P1Zc38OiuK8BcMtzojSnGgArmZxDS9+le3OLiGI2m+kw71ni3S3Li3Lw4c4LWx57nJjNoFSDrQL+2efXLa2HMU4fjd5sQLt2LA49Wv2h+YqNMLzC8r+XEKbJ4EFBSi+bh0UEEi6cxMrGlkpDO9741DLmGRPBuTVMuV95sYP0DDudqzmrHc6nddBNamSu7ddYUi4n8PBRHeadXs/JnBu81XkCT4SGAH2BImAn0OMPjb2kPJV310RiMhmJCh/E9AkHAVhVC2vua05v2O5iuk01376tJP7IaQDGvTaLzk/0b+jnk+9g5zGomAsDgzczVP4DJ+848a6mH1KBnsut3sZTreHLrRWUVVjC0swISfHqQK22D/YpCxEIZDw7RMC6Y3UI9UVItTJMJmuCXftgJU1EIBCjGfwFyapKPK+t50Kzpym38yO84AJd7+1AZHpYNbjY1p/LEWMRmM0ElVzFIJQRVnSZWoUzUkM9yT5duOPXG6HZSL/E9fiWJnO7sBSR3U1EagccrbZRrPyQFr5jEJl3YZJ34frp10Ffj/baUoqW9qS8Yyv6Jn5BcMlVIkL6Mrj/MUafT+C6VxJRVg4ktBrM51vF7D1chan6HtY1C7GSXMOvq2XD9um6ELVpBSIRjOr7sBhD4sUE5o+eiqOLExKZlKSrNxFKTKw/sot2vR5GHGjqa8jNu4HU7EXAfd+rvyP/ruv3A/bczGPu3muNCgD4OlixZkQsI6N9/8GcTTTRRBO/zaWKPWzMfqlRAQAXqS+TA1bT0flRP6Immmjir2PPntPMnbuqUQEAX1931qx5hZEj/3uR1/9pLly4QI8ePcjPz8fd/a8rYNTEv5f/ryLMhgwZhpWVFVZWVrRvb6kM0f/CUtQFVfiNbPuH+vD1cGXx1HEcOHeF+eNHM6pXx/vl092pTS3i2I676Gvr8Rnehrq6WrJv3eVywiUu3bwKwLTJ0+jY+eFDVsaK5WStXI7v05N4IaolY+6V0SzAEn5YavZsUNe1ZhVfe28kp0rPUH0papGEu927Enz2BM5VlfQ7eZzTPXtT5umF0SR4YDEFQFZRHtmF+dTVq7mbmYpOr2PZl5ZwSqFQyKRBYzh14ixde/Vhw7E9aJRK7uVYIudkMjltIlrSJ7oDuXn38HVtiW+mPUvP9yA1NIc2jl6UuWZjP3wwFFYQ+dZKXN/5krKqGkL9fQj7/BSlP+/Cs8QOlbIUr8oOOOtCOX36BGfPnqJd245ci09B2tWKqHbNGWQXASYTFFQgN5vZMq8lQb3iEcZ5Yt0pFy/vQ/ikdSOxoANPerkQdkRJYQsIvhtO3aZXEJkzKawyklNSx4W4XNLvp0Ptrc9BrXVm5BwFMgWIZVLueffB0cGS8ioWC3iqB0y27sy00isYrlo23r17HpwtWwEIWTotgfrQA5y9kYGjPIoZnRI4NWsC3+nyCZe1xCQ1ctDhK7TyFFyx5TI/EGzqReuwenIy7XnTqzleyl5csTmIxCzlhNW3DFY8Td3QMyz2tObLvaEE9IlGlp1LRokn7aPqeGrODIhoAVJLpJGrtw8KGyvUNanYimX0kfqwT12Eo9yWth7h1Ot0TNy9neLzl2nZrw/i+0aQEaFR7H9BSff6qyQZ+uJj5YjK2oUtW46htG3HEy4SDpR/SalHJSgFoAa1tp6P9+1qEMwEAgHnRj7NsKvfkaCvYn700N88TgQCsL9v9bNn+bvkJN5izNtL8YmK/M15fk2mrIaZN9eCRMTK0Jl/eL5LOii4n/4eqKlhvLs9aj2IBCC7f0bbtXUdHy2dhUAg4K0Vm3itpztOrXvj62NGI5cgU4MW8BbFAnZ0l0F3GcAa4EFUmxGYDEBSeTarEiwVRV89/QVPhG7FUnHzz2EyqrGxNqKsBb2+vmH6VGsoN91P8LQaDUCvJzPJT8vCztGBmJ6dG/Uze5wJX5cd1Jp0PGc/BaHARM82drTJHIuX1YtEyUo4lToBRY/O+N/6itahKkKDYln22Rgqq5PwclYAItbe3ceNISoij/XEQa/H33Es6WVnsJZdRC5zwa/MG9uyF7nr15NiJ4spsX9JItmu0bjW5mKrLkeAmUzPdhS4RCHRa4hKSUST9jWpJleifJyQmlS41OZhEFuiYpN8u2OXG0Fh30/JDAjAp/wQQ+M/pkI1l9LqWDztd2HWJKOwcUB5cRniCB9KOsSCUEhGQF86GKp5ctg6Pv4OFNfa0sY6kpXPy1GIRDw7BMqqHLGz7kiI9XA+ezkNhwA9IS3CqdRM45t9lu0nvi+aAbTq1JbjhYkAJF6M58stQxE5lZJd9wPtsJzL9fp63v+sDeWV6VSkyIhymc2bX3746O9rMj22mmsTf5yR0b4Ma+FNXEYZRUoNnnYKuga7/lsiy5pooom/Dx2dR9LOaRhJyjiq9EU4SjyJtOv6H4ksa6KJvzsjR/Zk2LBuxMUlUlRUjqenC127tvqfiCz7T6DVasnLy2Px4sWMHTu2SSz7P8b/V4KZRCKhf/9Bjaa5dgz70/289eKzvPXisw1/e3hYUijsI7wZmf8ZJr0RgULCojfmUVZehrP9wxzjmvJydFVKi4+AtRxV0h38nplC2LwlVNXW0CU3F21uKj4F+RR4elF73wQXoZB8pYC4AhVI3HiHUgrsrSlzc8W5qhKjREp4m05IdRpySwp/GfiCVCwht6SArUcfNQo1mUwkZOWz8VIqPncyCHOSNYqMWDhpFo4KGxZvWEVVbQ19RvZg3PipfP/5Rm5vvckBRzva+Gi46e6Id7v2xHbuwvY5qZy9fAV0+azZ9i2zpk9HszON5isGkVB8nK/vTca6uRSBAHJzcyhJ12LtHcWxGhvCY0Pp4//wJCGRWB6CZveyY2wtdNJU8Fr7A3x+dz7PRLVlQYvDAGQHKhgSUIBELCW9zExQcBhSqQTxcoNFf3M/SMfItsgUltChlMpsLtW6kK0XE+JYi1QHo86NwLvWh/yYT6gLKWfDz50oKXWkVmvxtruSFEZUeDq61vfIdBaTWxzCzkrLm8j+qadJaT4YB6PFP8dshhdvicAhjXc36+m1sTU+Sf5UWBm4bfMT6jpIUlwiQW9mFo7sPmnPx1+kALB8eQsWzHvCUhzgfnWU4uxsdn78IXIbGzz8VFzffYcDB+7h5uVK0onduAdEIDIJaTlnKmmFBSx56jn6hT70YqqsrwWgFiOZoVH4RHQh6246VXZt8ZB74aEI5VL595RJqiHKbBFcEwXYKqxoP28Wz/cZwIsDhiBr25cjzh4UGIVM/P579p64zY8LFiP9jYpq9+LOs3upxbhZU1PDGyePPLbd45izcxtnN20homtnnP5E1bOuUvCorqBUIqNy5vOkvbWA0A7tG7XJzbJsa6HezLaJszHUa4ls3o6S/GyC+3Rh//btpBhgoPzXETKax372sXXF29aVgtoyJK6RVJvA4U8/v6vwdH+OFQvhXnp73F02N3xjJ4SVv6ov4BsWxKIta3kcF+K/5NS5GQiFMKalA1ayakDL8CBf8ouOkJ5VwJsCM9dUFdiHTyO33SxqSpJxVuzDSqC5HxJvpMr9Hk65HbEtc7N4pKmmYTZLqa0fSIF9MfucjoLTaORaZcOyD7V9Bbm+jsDyu5TaeKHQ1ZHvYhFK9WIFUmUodQZvBIBG3QWp/CgONUpstDWoJdaEFMUT5FnCvsAhYDaT7xKFVmZNl5YXCPEpJOEGiAQV2PteQz/4OCJpBvb1u6lTuLC03XieGWapThrsA3HXwFZnTdD9LDcPF3j/5QcjfYmugydQoKmjracvOw4/3H6/pb0EtfBD5GR5+xl/Yytjn/gMgDp1OeWV6QDY+ui5sPdUo/m0Oti69Q7fvD4dRxstG8/uwdPvjxUCaOJRREIhPUKbbiabaKKJvxaRQEQL+x7/7WE00cTfEpFIRI8ef66y+P8v7Nixg8mTJ9OqVSu2bt363x5OE3+Sple2fxKRXIrEVkF9vYaycouHkUajZnJwJG5mAT/+tIvPPl8NRZVcOXGSu917sNqgYt2erby+/j0qqorodeokMYk36HfiGE7l5YSkpYJQiIdnAI5yEX52Esp7D0Sr11Pu5MzNFi04MGAgZ/MyKC97GMr6IBFcZ9BzNvHKQ+HuV6lCi3cfIbdGy8V8NfUGE7/MwjVp9ZRVVVBVa4nEupuZwgdr3uXuXUvlq4oqJdez9BTXmLh26x6X4o6hL7hCJ19o5SskLS2FotIKHLPakZJ9gjwXEyqZGX29JQ3M1dkZ2/7BZPhH8XOchH6fnuFsZjkGD0fyKgXoPnEgrcVgJljV0kpvES+E6Jnt6YJDmYLWJ70RGsDqXA0SsWXcQZoQ6gfbU3FYyYLYPEa1icPZPofDTnqKalwQ1JqJcgpnlDCRPuVXEK73ZfJnM/Cu9eFy6Ke0j1XRu7uCl58+T3RfGxDqQWggIKCoIbdeaCrF1dP0oKAo9WYTWzSHKTH/iJ/KxHfnu5Nf6Ut+lpB6NZx+/hhHp3xDufcd/BwtnkZ6vZTNZ9yY8K0PNs1DG7Z5Vmk2BzZ8yTvjxrLjg5UAXDr4MyW5OeQk3aUoqxRVkeXQLC0sI/vsdZwUdiTl5ZJWWADAz5fiIB8YBTwBH4a8SGfv5syOHUGX1gPBxp4iWx1J9ZbfUWmoYIiiBX62bvd3EQGHl6zg+7jTxKfeY+YXn3IzKwOkMohow3Pfb+fEzev8dOUijuOGcy099bHHg6OXJ5L7ZZRdAwMe2+a3cPL2ZsSbC2nWvdvvN/4FLiKY/N4COoe64HTsIMWpaY+0mTB9Ib0HjaFnjycw1GsB0NepmDhhDgev/MA3M4bRs74C2SNZdfOAZcBKYFrDVDuZNTNGb8B1wGco2y3gG9UfG2tC4jbOXV6H0agHUoE7AESE1ODo8Gh6mU6rZdnzLzO935PkpD6mxCZQp67g5HlLdcXk2DdYp32gEGmBL/HxdCAybBOVhkIAVCYRWpOE67dBrVFhNluOTZNZjsfdcMxWBZikWgQCM8+P7kGU7zicrDZikD0UDK10NQ8HIBAwTOpEz5tf4lBXRJn84b4tMAqxt7mJVJSOQKAiq3w/KSUJlKUf4JnLK5h8YiahxfEoawt5MXUHNpiJLL7GnZgZ1PTxxyR6KALLZZb11xXUEPORiilHZpH8bR8qq3IAmDwSPnkdNr8DQY/Rpkp0GmLvHaPrjSu8nn4DV0eIbQZTR8Gw34j+t7VxJ7bFWIRCEd06PIx6dLT3YUDPxYj1rlRe9+OFpa9y9S70fxGeXgAL18Dms80R9PqJwsJaLt5PpW2iiSaaaKKJJppo4u/NxIkTMRqNXLt27bEVoJv43+b/qwiz/yQ2NrY8/fRzXE24Qqcr8ai3bKKrRMLBQUPIK7F4QOVmZnIy/hImk4mr9+6nb5nNSI0W7x+xwUD/E8fI9vOn7fiZuPsHIdfkAGYiLxzBOjuL3aHRlHn5EKAQIQLUv/AN+qUwlltSiK217WPHaicTotKBlViAWGiZx8rKmiA/L0QCLX4egQR4+JBdnI+yVklRsWX8trZ2tG7dhgvnz2JJTwOlSoudoyeqqiJKlSa8vX3w9fUn+7ylrKxXpYAUXxHyihQcFXlIylU89+FeXrlR/WD1ySitZeqnV0gT1uHuIuejfBOn42/QNdCDidp2YPQGQwRCBPT81IzTjZu88EkkFa0CCfSu49X08VycXES3n/0ZanqDWmENP7R/mTs1GRSle5Jy6xxnBOewuy9+xfnswXQhgjydmsq2aQ9qNFoiYMqcEMZs5OlWNvSKsUJlkmEvkVB8wZZP7l4lJlLGtdsdMCNA77GGHOlFAFzsg8mt9AEzXPzuHrFhuYw6sQkrtS0hoieoEBSj18lZW38GW1d7/KPrIfg0mAXk6BxIPGOpunb34gVqa6px9vJDJJGC2YRGZYVdoC2VSWrkjo7oVNVgNNDaRkq0VEa6Tks7jQaOgrJQhVaop+PFKI7P+hClToVQYBHbzlYksb1kBxeVBzDoypAKBXwx6CUuFibR2iOMAaHtiA4M5nqGRXBqNfdFFo5+mg4dIziTl9iw/6i1Wr46epAvQx6N1nQPDuadqxdJunqNeVfOsPCZkfy4YDG9omMeaftnSL8Sz+3jJ+n8zFO4BQY+8v3IZW+iqqrGwdODDk+OsUwsUcLVbOgYjLOrB+9+9gMAP7q/Scb+M9gGhLM18QwCa1fiTu5n347XmDBjFDDwFz3LgaX3P58CCoCnATFRNnbIXC2RVAF/IIL86s3v+fZHS6SqSl3BwF4LgRHAWR6mfTbm+M79/LTJUglrycxVPPXmdK4kDMfB3pcXnt2HlcKBW3f3Ul5pqbTorb3HWe18XjCtwlagxmTqjMHYDZk0jx8jrvF+2vvoE9uxr/giJflPAFmIxXLmTD6JkRtcSFjG9cTr6F1smDHxPGovL6ztR+F6aCb2yvaIEgdS5VnFtGYdqRbI+a66BG2dnpt3feli8KNF3mlEnhKMFcHUOAUQLXXlu65TCQj/DGfMOFzriqE0Bvx28G2HRYw//SpZbq2wU5fjnH6E5zNPktRlCSdl/hi+jOSGMhon3+uoPdO4GxHFhLjrHPluKPVmE/kqEeKeBdzLOEGnNpMRCKBVuJHdX33HNamE4c8/3Sh6Nlldg/WZaEKSIohzrON81cPtPGFY4+2+5Wc4cA6Gdhfw/NM/NCrD/YAhfZczpO/yhr/fWg8qzcN/AAKZEy5+4XTs1+P3d5AmmmiiiSaaaKKJJppo4n+aJsHMaIIKpUV8crYD4eONnOtLa8jecRGXTmFU2htwdXWjb98B9O3djyvtY9EBUr2eEAdHvFvEcuraRZCIaBPRkvikREIDgskvKcRaKidg5Vq0cac4ZtJhzssh9sZ1zEte5uiYZwAzdjXV+F+/SryNKz+rZDgZ1dTUS2jnIsa2VkmVkyWFUCqWoDPoG8aoN+ofO/aeflYU1UlwtRJbBDNnBWp7KdZ2es5c+oZL6RAREMLE2NFcuHGFzPp6TCYTEyZM5tSp4+gNFrFMKBQS27o9bi6D0NRW0F3hgEwmRygUEvnaUOqyy/CO9mPq9pnsWTuRu+dvYAaMmkqeGejFKYOaWFt3NDeNpNXUgSOUievYIfoJdLA7Xclz7+9AlCmCBPgw9w7vZ+Yw+MWWjJoLJ0eFsPM7Hb1masgPqcFeaYlssjXZU5udxVPVm6iq6A5W3pjNIBUJ0BnNONR5827xHQp09Qg3dkA0+jR2Ci07dg5my5BQkkPextVzA1CPtVCLT5/5nFFto+1tKe4DzxPZIpWdO5/kXKkLnWzBaJKzxnsomxVJSN2+w5xTSJ2yOfJ6S3qlwCTEzeyHXqhj/jQpbV60ZWHCOjr3s6H51RB69G2JTVUQ8YcP0qpnL858fQjnRDfaBoymWH6H7Nu3sAvsiE9rJxylQro6CeDSYQiJYYhBAEI5wgolt5pl0HXIS6hF9XwV/CpLNm4iv7aM5yP7YcjMo0huwt3KgVJNOiqzFoyw/NJ3XHr2s4Z9Y/rAobzw2ccYTZaoo5M3r5NYdRnPZrbUJutRa7QIdEKGtO1AWU4ODh4eSGQy0NVDVSk4e+ITFcmxwhxu51sifzYeP0Sv6BgMOh2q6mrs3dz+1CGprqlhRe+BaFUqLn+/k/fvXH+kjVtgIK/+vPvhBIMJJnwNxUpqFbXkjYwjdMoWJI7hjP3wHbIGXOWjJW8BArxsw6jVlxEa+TXwNfAF8CLXL51h2bwJ6HX1fLShD1Gttt/vPAlYyTAFuAst2awdZfwuer2aCtUkdIZgauqMWE63e/7hPIHNQhFLJBj0ekrwxd11DuPHFnPoRCZqzQCsFKMJ8h+MQm5PVLiS8WP3Uqs9xPrENxHH7yM7byKjBpuxse9FTa0zTkcHcjfDlu/F92jmkQWAnY07nh5J3Mv6kbGDU7FTwKkLdahldfS4fZR6kxHvVtMYHv8B3csv4tx+PaH5/VlxopywoHeJa/4c1W0y6X64hEOxH6OTWCETCHjl/EzqVKUYvToSFzWJz5r3Jq95OfNy96NSWApRnG0+gRSfLghNBsZeWIpzXQF1+ZeReIejUNphBorL1hE/YBdCIEf5OtyPiNMqRUjECiJDBzRsr22rv2L1/Ici1ojJ4xo+d7F3wyffASMgqLJBKLBUWNUbLDaKD9IyDQbYsNsi5n+1C54eBGLR7xv6925vqb5qZwNzxsGh8xATbmTc5j1/iY+ZRqXmw5cWo1FpmL9mOU5uLv9yn0000UQTTTTRRBNNNNHEH+fvJZgZTVBVCyIROFhbRLKqOku5P6BIqeReVSWdQgIQy2WI7qeaAZwb/QmlcfdI6yQiL9yE1CRinFN3un44kbCFy0lZsRixnR0mO3uOXj4LJjMLOj2LMcqfkAP7MJw+jbJZM4ZOncuXJw9SJxfh5RJISMJlix1ZTTW1ybfAxweNwgq1XIFKKGJQsC1OCjE1WhNdU5Ko06hJcHIGsxnfrEyKHR1R2ViKCOh0ukfX2WxGKhLgby8FOxnEeMK5bKjQkCAVM97DCzcXR/p0GotIJKaVXzA/pVynY5uOhDQL58yZkw1dOTg4IhQKuXj5MjExrVEorBq+8xkcg0/uQ7+l1IBnyUq8h3jRBEpaSkBQTuyzMj4mlqNHi+ADoD20slXhaS+gqMaMwGhkyZrXeWf7+6z1TGLBvts0Hy5EYmt5eB01xgZpXjpfaL9gZPlEy4IE1dRLcsksvoOdHGzrEpB4OGIvsqGlnwSbGx7E6jsQ3NPEK0fNmPRC1u3ozcD31MQNaIlPWjMChOfYb3InwDuHZJ0TKRdO0Z5kzE8nYzruhr1BSIfOFzh95kkyylpRo3Hm9YgefGLTjtHFpzl671WEAj1hbRMY6BTFjRGHsbomRRyiY9mCMfT9ZirleVVcuv4Z1mYF9Z9rqH09nP7fT8IEVAwtwqvSH0OKno3NrzVsQ61Gw7ieHbCWS6G6nLiKUrICxfgUm/Dr0ZkTJKCUWHIDNyuPkF9rSRE+ve5T3O4VY5CK6LVkPi91eI6e+15FZainuUsAAAaTkW0JJ5j5xacNBdadbG15vn1Hvk3cwxSfngjbCwkJDCA6Ooq9ry7m+x278Ihszsr4M0jP7gFVDRpHV0ZWJSLXS3BxtqPCVol7qAPqmhqWtO9KUUoqY1csZ9jCBX/4MDUZjZgMlkhKvVb7x2bSG6HcUgDCSivFkBxPwY4OBMywhBW5tQ3Hwc2W6tJaOg205s1xswkO/+T+zDmUFOYx89neDenKB3bsJarVg85LGhbT4Q8IZQ8QyyeQV2UpG51SoOdMAqRkw+i+4Ozw+HnCY1qwN6MTiBK4kZpBbOQZAJ5/GqwUV4AreLh14a35WajUs5j05gJKKvxpFz6YyjJL4ZF9JwZwNd1i2BXib8JKEo+D9RGCA+TkFdbTs/Ns5qwcSnLmFEL9bvDyM6/g6fECrh4t0eZbfLp0YitAwNsvj8Daeg4/Hf8ShXcsUoOKgdc+wb0mkzJZa+R6FTqJFbbVWSiVFr+/qLyz9DCqcAtuxdDSG5gVjogNWgJLb1HgFA6ASSimVuGMc10BsZkHCZTKKXMrhaoOGANOAB6YgDut3PDvWIdA64hvNzXjx27Fwf5hKLu2/mHhBF19431FLBDyyig5X++Bds2hR1t49ysD14/+zCs1Hqz5qJOlnRiiwyHxHoT6P6ye+Xt0iYUjX1guJ2IR9O4AlrINfw17N25j70aLaOvs4cq8j9/6y/puookmmmiiiSaaaKKJJn6fv5dgVqFsEMeQiMBGAWJLJEC5spbo+Uspr1HST1nI6/UFtD15AetQSxqarsYyn9LREu2gExr5+cZJjiytoGuzCOT5ORiUNcQW5NF88UpkUinF9XUcW/sRPeMvIgKamwzsO/YztVpL/k5BaSGm0HCcq6upsbah2MMDBAL0UikHe/ZBk1uMk8LyE9lJBdSp6gjJysS+pgaRQY9TdTXVdvYcHjQYsBj8A8hkMi7nVlNSZ6CVuxwvuQCTWIxgZgeQCDGfzW7YJB3bvYhELMZwP020RmQi6atjXPv+GNHWgaQ5FzW0FerNfPnUQnJ9tZwLD2PRomUN3ynLc8m+dRxnn2Z4h3Vif6GUjJiFjI6WNrSR39/dggM0fDJTjJtHMO5ln9K+UEmBswKNlS2Ls7P4cOFS7pTnEi4NpyrFBVmxFIlMzPSzbXAWdeW5q5PZb72HmPAkQqq+QQ64lbah3P4sJRJ39nwzCDspPNFTjcAVrnycx7RVp7Dt1pwZF4Oxt9UzVn8djb4dRUFXSOqyhWAgscyXIpEfhbeNFFScpSLEHU+9ZcxOcg0SsYm86jCecfHCQSxFJayhpNhSSdJklrD4ZjmymZvZ1/JT6lqW4pv4FtvsP8fL0cSEVhlYGxUAqERKfs7ajvGqnn01xcz07EqeayYxaZ0RGSVYOXuhrigkRV1Hs93HiLC25kD7FVz9/gbbWyrBE2bF30J44hwBsdaoraTEHb2DIFSAWW7GqsIiool1Rg4fPc2ePYlseOUV3Dzt6e0fy+wTn7L59lHqcjRgsOz/fi5ubH5jPmuu/UCxs6QhrbOktpLorVMYcvgqNkBx0h2Sb2QQrbJ4WpmqSjmSFQ9AZBt/yi/WsOaHPURWCSlKsfieHfxoNQV3k+g7Yxq7lr2Nu6snE9Z8jMj114b7FmycnJh3YA+Jh4/R4/kJgCWATKUHhRikj9EkiqUSTi0eRcRnW3C0t0RxabQ1HPn0UzqMHYuDhwdvbt1AZUkZ3sEBgArQAfXAfK7HH2zk7Zdw1J8DYSYGjI9BLFn52HE25ihQT61pGALARghSycOBanUS3ryvJ2fkwgevPr6XLT/FM2mEJZXUzbUIo0mKUKDHSvFgbBLAFSuFI+dvLCYjz+KXd7JmGwHuT+JQkoDZfmxDf5dlt+jj2QOpSMOzo8DVGUzmfJZtsET9pedFM+eDozjaSdnwFuyI6ManF9cyzPQ9encxU7+9hk4eRouqC7RRXsCICNH99Gy5dRUt4wdzz7sUqf29XxbupazwKjviN4BTLAig742NBJZfJc29A2ne7XCqK8S/7Db9ui/C1zsGs8nIN/eexOwGNSZ37mjeALk1YSWXETkJifIZzozX3sTFwzLuK7dg/1no3msWMwCpTMaoF597ZHsO6wm92paRlnWGhJtHMV45hS5Rw9kLAu6MPUjzdpbU4Sd6WgSz1Gw4ecUSPXYzaR+1tSV0aD0JsVhKQVYu2SnpdOjbvaGqk0z6yCL/MnxDgxo++4cF/YOWTTTRRBNNNNFEE0000cS/g7+XYPbLNJkH/jQONiAWkVdXTXmNpRJcmtQGfX45lWdONQhmXbbPImXtUfxjHDl49QRlumoqAwXU597gs0Mn2K22CGpirZZYqRXKlDt8UpqHxt6Bepkcubae0C69ybsWT71/AHW2tiAUUuzhxe6xE/jheg6RVUZaukkIykgnJvEGaisrNtvYYefrikIsJDEmlnqFAq/CApxqLIKF8L5I9ku0RrhZYom8uFKoYVjYfWFCLkbgaw9T22A+m4WsRENydhotQ5rxqW8q7joFV+3yqQkRgADizFnYimzRYoncEFwsxzkdDCoB1e6VjZZ569RG6ioLKEy9hKNHKAt6NWPGrstUZWhxDJYRbnRmoqgtlRVVLJjxJlqtjujWLRjUvi1y+zhCF7wFNra8eOgndiWeRwy01SYjKTQhXi5gYLQNQq0Xp4wuXEvuwNJx/TBKd8MlN1CNo5/exGxvBQmfW/ysKoBNuyyRd5OLU8kSSFlwyR+jUUjXvsWs00SwxCuZ/VUPK5xKBGY+XWQRtVqFP0sz5UHUPjoMtTLiLnYietYOllrHEqe6RUFne5z6BDL3x1i+3voDKpUCj8xuaFpK6Kl9jYArATz9QRnFtVBc25dYv+MUDEzF5pwrF8afQxJog6TOjONPhRT4pVIAJNvcQtX6aRSuLfk+ZTq3E9NAJSCvVsnPh5OZohxEnMttiqXpOJWrMAoEPHPFTFXPDqyrOQrXoPuQaFQx9igvnKVWYU9VlRWg4+LNu6zrNJcXNq4mzSynk91oTrl+j6HUgI/CjXkjx9D7tfmYJWaIMnNcdIe+Hq3IsqrEhJm7vX1oeSiX6qjWfHr9EvNjwojQ1xInqocsEAmEaAp1UGs5ruKqKwno2Zn8y9dQVVZxYdv3ZF69TlFKKneAFtcNtD2xGrwdMZlM7Fq8jIq8fNqsXEmFszt9evemeZ/eDb9NUR3oTZaMab9fZU6bzWaW1MDhdpGw5T0+u1xGrFjN288qUSkXcHHbTpZfiUNmbY0wwJq4ShUpV6/xVIf3URYVkXhwC8HdOhIQHEFhfjbhPjFI1U5cOaRg4ITv+P3T5E6Mpqe4ZujI9KJ+zEoqpa+jhOj2nrwzW0BBKbSKgLjrlrS/R7P1jgCvAG24dOsDJgwTIBSakUo0wGXgW2A9ezXj2KJ6j2EKXyZaQ6uICJwdjFQpoXm3O/zs9SlFJXfocetb3GxLMJickVnvxayux9XNIpYBCAWHeHXCavafBbVGSE6RlLIquJOqJUh6ie2xF/D3LeLNg83ZbTcPkVGH77FrCDAiMEswWLsgVpdQWtMGc3EzwtOakdpDSKH9LhxzstCUiihNseF8z+aYhSLsa0sIKk8AIKzkEoFlt5GY6nBxCuaJ/u8AcPzs+wCoi60J8PQnqVkvvLyasS9PxTsHV5LKTqpLNSz6ZgP2trBorZl6rYAz10R8++kLBNtZ/+avs2LtU1xJ3YDR3AOReByWwgtmqisensPyix+2zy6AFesPU5g3AoDK6hzaRc5kbMteqOtUjHrxOd784gMAUjJOcfPuXtrFPEeAbzsAdHoNX3w7hNyCBMY+sY52MQ8rLv8Zug7qzbeXDqBRqWnfu+s/1UcTTTTRRBNNNNFEE0008c/z9xLMnG1BIiKnII+KlEJiY9tYptsoiGkVyYIJYzh7Mo6xN5OxDg7Dtf9g0vMKOXLxKkO6tqf9F5MB6DT5CebMfAGNXosZqBOKmddxFIttzXhn3iVh4nAMIhFVY54EhYIDg4eg0Gho3qkPR5T1PHXzGolt26GTyTALQaBV4msn5XqxhmAHKQKDkUODBqNRWOFRr0VkFGIQg14q5XbLaHLbd0SelYlncRGZgZbIA7uaakLS0yn28CTN1QOZSIDWaMZXr6KznwP1QiHqn2+Q1yoUzc1ijKkVaIBPd21m+fQF6K115DoYsZJYoVo9GMPmawhuFtOqdRvi4s5QV26gRGakcKAEiVxAgK09R48eQiAQ0Lt3P6QKW0qVRtJKzEjiE+jv2ZLMCV2xDfJAjwmZyLKrFdXXodNZvNZqlbVcy6lA5yeil42lYIGXfzjOuSlUVJYhF5oxmqB1ZAf69hpOUfcsfqrsyQvXJjNlmAuGaVcwqpYiqu9IewkcvtydUOs9KOuFdO58E7lcz8WLzdEbhRzBmyq9JZ+uKN2KNtFlXN9fxtZYA30AgV7MmYSHXluaaj1F5j5EtaniRK4LzWKyaOluxFqipp1bJc4jwpGLrNELvic01JKK5tsijeTjWoZavUTsjS4MFMWzgQwcFKX42TnicdzyW9X4VQMgFksZWNUJtZvFW6pYWo7cLRqloYLbglSwEYAKrAVCWg+IwXmnPQeqV2C6a6JOWMUXrq8QGN2ciPZtOJ18G1tbW7QyPVelNRAYC4BIIsRebkOLgH4cvp1DYoqBkBaBVOiL6O81juZdtIzy6saL69Zg1gN6AVSZuSBL5f0us9DWVnLo3gkqo32ocGtJXEE5p0/sYstpETkbtzHA2YXzwa1wlNuQnl3IyKRlYAalbT0rBphxHtyF7kvOIFcb8IlqRlFKKhKBCE+zLdwrBm9HEnbv5acVH6AJDOZ9oxPGKhhvBe/aPzx0TWYw69TUn/2YCkcHXHrPRCAQkHn1Gu8PeIK7y1fBiKcQAIFDvsa2ohiNKhgAVZUlLXN6NRyqB5sbScQO7sel5i2QlpagLC3F0dub7/MzUOshp1RF3q3bNIsORyT+x6dItQmeuNObbLWBsDvZzPQoYVLG/Uq2DlJ6tH3oO/XeS5CWA8N7/7qXJUAykMzTz0zlUNxCBnT5ELFoGNAOaAG4s6D6DeqRcE0PoxXg5nSDnateQqu/ia1VDTfvvEeB0IMKey+a2S/EJBAiLLMI6npDCHXqYKSSa9TUvcYTPS1RVZduwooN0DnmGpkZK7l+ezdisYA3XwLnQFuoAKNISpZyPS7S3cjEyQg1JZyKmkhIgg9OVl9TbwzGWngTT2Um6nohWSfs0NaIkaXlomsRTo2NG4mOrxBe9xVForEEaraAAMorM+i/czrfDP2I67ctRUME/iLiBswhLv8GK9UFZBfdBsyYpBLOVkhJmAuhflAr0CJBjlahYdaFe7zmBIm3XsXboyWjBq9p8BAzGg1kFceiM1qOPdvo0fg51tKjz3P4tXTg/JUvaR39FKP72pNTaBE0R/aB8Qtq8Hey/Dp16hqKcwtQ11kiNzPu3ANAp1PzxZYh6PUart3aQfOIobi5hBLk15nUzFMAnL209p8WzABadvh7ll9vookmmmiiiSaaaKKJ/wX+XoKZQMC19CQ+/3wNAOPGjadPn/4NX783eRwMvP+3AIxuznQbOpHiqhre//p78o5Z/GSqxFomvzKLw1Omc6pOBCIHblfU8IbQmY8zU7kTE0uBlxf29fXUyOXopVKwceTFTbsxA3ZdR7FoYC8Kako5cMHyYFWnN9FaV0VkbgUZISEWYxzALJfxi7qY2MqsqNGoqfHwoMTDo2F6lwvnsVcqCU1PI7PvEJ4ItaNGo6dDWQXWchHeDiJATdGOeKzFdujkCurrNWAGFys7XlO14oaxgs99UgEZsj4BeNtJqX46FMGVOLQqHSIJSOSWB9G8zHSysy2V+oRCId36Tmf7iVdQ1qrYtn0bmTu3UeUNzV8eSlDnWCpz4zm5fQXNYtryyqJZ3E5Mokf/zqz97D2ShRLcky/i7BTA9/uPkZkn4JsfP+fWrUS+37KOTuGhCAVCvMXBBEtbcl26nUVL7OkU7UvrLD2+lsw/nAU2fDABqqRGkmsKARg1+CbDO2nYneKAr2M6tVp7hrS/TYyDgJNloQR4WdqZJQbWe53G8ykT+rvj+MBlOUJ5Jd/JlhIYWERkbXPm7NuH3qqGPa0mEdBtOdU3WjFnxv3yeJjRqFRIDUYM91Miv/Rvywz3EJwWX8FHNBNh+iHYO5gu53uSPzyXqEUtURTaklmYz3Tfd3FWFdM+9Tg2Ie2xMgaiDsmit10sm+xewfcFT5gLvAJChNiZnHmu+TI8xxZA6g2Serfj+wBvnj69FrxBZhKjFeswepro5z+KTWk/kXD7GApnKxKKLf5Wg/8fe+cdHkW1///XbE/PpvcG6SH03nuvIqAoRUBsFBUrgoqCDRURFekCgkoT6b33FkoK6SG91832nd8fGwK5YLtXv/d3783refLAzpw5e+bMmdk57/Mp/v0Y5DuQAW+/Q1OvNghCGoIUbN1s6B7SHKPFxKC9CzGaTWzxa8sRu2JO5lgAAZPZTGp+Hj6ubnT2iwEgyi2IO6s2YRFFhu95C4BScy2Pbl1FS8cAwjp1JGHVVly3JuISHs4Bu1Byd96g4Oo1bFxdKffxxyyXA5Bxd9DnV8OxLPycVGRWrsFw+APyAZmdGnXH8Zz/cSs1paUozp1CGD4GL0w4V1bh7OXFzJ++5/r+g/R59mkADtaFu6pp2RazrR26+FtYbKwWhfqaGiwWCyaLBKWdHU07dkBefpuq62dxaDYAQfLw2FS7dXDb3aqspJUFozPn3NupbPh47dzS+vcgPYFLFJq9eNMhgm1duiKTLsTqLjoZyAG+Ilou4YoRQqTp2AiFwNso5CdRWLuMaDdHLte6kRzzNB4x03lZyGfXlscA8Pdpy8IVmzh1FRxtUunbZgBuam8U/b+l2weXmGo3jPWrKwAodwijoDqcmZGDKcuKJaEoCUF5lcraYfirD4AIwcVxeDtsQm5rQESgWe5w9KIFey8L3q1rKb5lQwfhGocIR1XlSJ5sIjej+1DlXUR4Uhh9Ml633jUF11h4fiWSPGtih6TQ4ZwzmpAZ9bz9mRytdiXuTy7j/Igaqt298Uo4j+RcBzQe5RSFpVHpk0/IuXZ8VzsFO8UJUjNOEBMxlMjQvgBIpTKeHN6bz76vxGyx45nxPRjUfRqVVbks+CwMo0nHzaRdPDtxN+8+f++KtGo2lhvx2QT7FDJiwFxsVM5Meu0FEq/cYMaiNwAQJFLkMhVGoxajUcuFq+sAmPL4VjzdwiksuU2rZvfcYxtppJFGGmnk382kSZOoqKjg559//nc3pZFG/iP5q++hdevWMXv2bCoqKv6S+hr56/nXU3n9h1FWVlr///Lyhm6FaO4FkMbBDrMoUl5tDSReXFnFkm/WY9dlBO2mv8hVdQXNJjzH1P7d6g9JLS7l8uhxJIdHoHFwpFKlorlvEB3cvanWCfXB1ZNycsmvLMVYF9hcFEX6eEh5J/MyEakpyM11WSnrDpCYzYQXFKJ2cEJlcy8RAYC9ypbWt25grpvQG5AgyKTYKSSESQw4amu5cSaXomoz2T9dJfTYOdSiaBXLAE9XNxR1IoW/1ha1yRqUJ2rTYXwPHCVeVYrXwNZENA/Czs4OoUKLzGjEMy+vvg2CIKBQ2WNfJ6YpZZDdGpI6wdYLu3j9xbksWrSD85lRHNp3irAQO2a9/iwafQ0WUcBgNrFk8w+88tlabialcvWmGo1GgZtKQyv1Ha6c+Aa9qZYk4xWSjJcoOtaKVVt9yDTaE9dmMwkdvgegRlFDh6HBjFS0QFI3tB3G+JFv44Sh5Dz2I4txeMKMtLI1UYOfI2oU/FwRSpGPK0mtwjjwWDcmRstYPrML9t8UYTNbpG3H+bwf1JQZFd1RmFXYVXuiTPCn8GwLusq9mHZoAs+nP417pQ5pnchz1mc/V2OyyOkl0GK9CwHqCiSiAZpkkdP9CrnN0jAnZKEySbFBSbSuCeoSP1q2as0ItZqXv3Kk4MxyrlVv5MuLY7DdB/xU19mPAs5AFHi/GQxa6/h8vewmjx37kmCzE4/rIxkQFIHCT46dQkW0YyyXKw4DoJXU1l+329XxdP/+Rfo2n8hj3ebg6uCDxSRivGLh+4Fz2Z98Eb3ZiAWRd8USvjZloAyU4+LgwNguPegSFcM/4uPqhp+bOwu7TiHGLZipsYMYM2AM4Z07IQgC0dMexevAfHaPG0tioQx94lXc5Pa0fvZ55r7wFDNsLfRTwtt3w5tdyIPiWqSpZbiIPvfGXJ3FYttHRmDj6EjpmCcRJRLyJQoenfM0cZd+oO0oN6au+BrfmGji01KZItOhFsDvwikMrm44hEfw4o4f6f3MNGZu24xEIiHxl+2s6teMcx8MofjDGDK/GELe5tkPnOddYuQgs96uRJrgmQE+0DsYhoZCsPOvHteQj5hVfoPexQnkWNwpNN/dvhWrO+YR4F02uexgk0sfdrq1Qip8BMQCYBIVHNGNp519f8ICBhPo04MPYrrTv+U4pjy2hcG932Xs8K8oKrdamzmr3iMt4wB781OYU6NgaU1n3qpcxphhFuJ7/sjRJ5KYIGynVpzKm96huJz5mFtTXyBjWgukKjUIUmzyBpKck0h57aMIiNjYtUEQZIiiBNfWFppPLsWp0mqJFbW/Dz7XYok60AeJUYamaSgOfr0pcQwk020a8lsOiKL1ejqVJCCIIt4FRWi1vQAoVw+l2t0bgKrAXOxtwbnAG/+4WLqe7YdrZiA6Y3MAlAp73F2bNujdwb0GsP9bJ/Z+I8PLI5zicgmHzlVjNFmf95rakgeuyJRRAqFNXiEsbDE2KjWCIDDrw7ksP/Qj0W1bAJAcl4htzmPE+sykefQjAAiCBFd1EG/OusXH88ro3fVXgtU18v8dBQUFzJgxg5CQEJRKJf7+/gwdOpQjR+4lvgkKCkIQBARBwMbGhqCgIMaMGcPRo0cfqO/SpUv07t0bZ2dn1Go1/fr1Iy4u7i9p6zvvvFPfjl/7y8zM/NXjt23bRo8ePXBycsLe3p7Y2FgWLFhAWZn1nWjdunX19UilUtRqNe3bt2fBggVU1oWD+K22eN23mAf8ahs/+eSTv6Q/7pKamsrkyZPx8/NDqVQSHBzMY489xuXLlx/aFjs7O0JDQ5k0aRJXrlz5zXodHBxwdnZusP348eMPPa+kpKT6Mvf3j0QiwcfHh/Hjx5Odnf3Q7woPD0ehUJCbm/uvdUYj/18wadIkRowY8e9uRiON/E8yadKk+uevTCYjICCAZ599lvI6z5PfIzMzE0EQHvjt/uKLL1i3bt1f3+D/I37tvBr5df57LMwsIpRUWjNhujlZg/o/hB49elFaWoJer2fQoGENdzrYQLXWGiDJ2Q6F0cTGF6aw4uBhhrdqxpJdh9DqDGReyaFy3Q3cPV05VJTNI+FOHL9TQ6nWTLpFqO/UCp2JDw9eIaCihH5hHrTyUlGtt9DCXcqus4eR1U36BUFAam/Lqa7dKXd2tlqkAWZE2p07h3t5OQ7VVfzo6QGCgFQiwXxfgP+4Zs2xCQjCNzeHfDcPFA5Wq5lup07gVFWFKSmRc7oOxNRWUNXWD9/D+8hq3xmAovJSKix6nBydOLr/AD3Og27XJgqSssh6oTeiwUzJqTicUnJw9fXDXC1gV1VFi+txtBs3HtuAQHr27APAgHaBJCTdxtVeQkKtAqgGQOqgwKi1xkEzeEazukkZBg4wIjiEwionAlxMvDB5GgGeIUT3P4mXvzs3iwvJOrGbgJBo9Lpa1v3wFV+c1tHCvhN559vTq30BEcHWmHNx9lfwZCCuBhd+2ijh7b5+hKvHkRSdh7aJC57ftqXcropEh44AnDC4c/P2IMQnCtFkduPE0BeIvVmFXG8irVtv1IoMrhXFY7ER0R3OodPl8yCKiLShWK5ldQs3vHLu8K26OyE6N9B057rqIGd0eQRFBqPysSens0Bsd9DpaxHjvbCpLKFGtKCrWsqhdZWYRZEyXRYjmE+tWs9bz4xnbeo+oktf56mmA1h5ZQ5nk34mz3UvElHGOM1rNNG2QNnRBg7dN2ZjO4NEwoXKOACe07XAUVRirLLwxNgRXClJYUSYKwt2yTD6G1Bq5Kwd/ypZVYV8dOIHqIEab+sPR3mNNRuk3mgk5oWp5FQV4d/VAzt7FWsGvkKNUUdTtQ++Du4ArNi/m/TCfF4ZOQZXx/v8J4EBIe0YENLuV29X+zrdVzBarfGkEgmthw6hs51V6KzSQ141uHrYo8yqBIUUp/4TMLkZkNo649xuLAChHdqzvCSXrXoJr1aYkKXfQrh4hOz+O2jRFuAtth5qT3JWJjLgKxdPtr85n6LsLKoBtY8PxlBnpk3rQ+uOPTEdSqCoupTUa8kEP2LC3hb0+UkPtP8uUXJYXx3Ppu0/MqBpABL5VIhxv69EPrAG6ITVkuzhTLFvRqUIUTJYXwvfaOBdh1jcpQpkgoFycwvU0hZ0VV4BKikrD8PZaSESyUAEdtBb9RUQx2S7s1hwRC6UAkpaNhtd14Z2rHg7j7e+3EJ8ZiQugMi9QHC6WhN3SjqT5TEagGK5lE8KlrAozQXPbp8jcQ5F4xzKrZYv81HQZGZ/YhUvC6rexWAOILHwJdz7dGS/8yVq5V6MOPUtHlXnaZp3DsFijQUmFSXYCjJyZNWcCZzAlzHjmPWOnCtmgSAPJ5wVj9Kk8ArzE1ZSWZJKmdtpNIY2iCYBm1obMtVhDNU356Z1yGBb7UhsAFwEdHzMmGGxRIV2xc0l+IH+lcvg8w3wyzGwVVnQ6iNR26zGzfE0TzzyygPlv/oBzl63/jUPh47NH7xmLwwcT0VJGbb2dhwujCMytC+uLiEE+FrdKG1t1Bz4cSfrF39D+2GRCD43CfLvwNB+7//qOGjEisVsoehUEtr8Cmy8nfHoGoFE+vet72VmZtK5c2ecnZ35+OOPiY2NxWg0cuDAAZ5//vkGAsiCBQuYNm0aBoOBzMxMNm7cSJ8+fXjvvfeYO3cuANXV1fTv35/hw4fz9ddfYzKZePvtt+nfvz85OTnI6xap7mfdunWsW7eO48eP/25758yZwzPPPFP/uW3btjz99NNMmzatfpu7u/vDDmXu3Ll89NFHvPjiiyxatAgfHx9SUlJYvnw5GzZsYNasWQA4Ojpy+/ZtRFGkoqKCs2fP8sEHH7B27VrOnDmDj8+9BYzo6GgOHz5c//luUoy75OfnN/i8b98+pkyZwiOPPPKr5ygIAhkZGQQFBf1ufwBcvnyZ3r17ExMTw7fffktERATV1dXs3LmTl19+mRMnTtSXXbt2LQMGDECn05GcnMyKFSto3749a9asYcKECQ3qNRqNPPbYY3Tt2pWzZ88+9Ltv376No+O9JDb/2Pd3+8disZCWlsbzzz/PmDFjOHfuXINyp0+fRqfT8eijj7Ju3br68fRrBAUFsW7dOnr06PFHuqgRrFOE67ehtMKarbp5OPyNj5b/aQwGAwrF35gZp5H/OCxmM5kJ8VSXl+OgVhMUFY1E+vD5+l/FgAEDWLt2LSaTiYSEBJ566ikqKirYvHnzP12nk5PT7xdq5L+K/x7BrLr2XgZMqQQ8nB9aTC5XMG7cr8SUUSkg5L6V0bxSgpxtmNQhhqNXz+BcZ53jrJIQF3+R2lI/AByUEnwd5JRqzexJLuWlXi3ILszh5h0NhWYJ5c6e+JTVkCZKkEgE5FIBURQxmoxU6804KK0PixIXFyzCvUmsIAhkBQTSNCsTiyCg0unQ2dhgtliwiCJ51Sbiiotp4SxS4+hIkkOkVUm/e/x9Wf80wV4c/vIFLEo5LjuvIN2dg9lspmPHLjiHWSeYbSYNZ7HlJLprAWDvAclGJItP0m/DNhyrq8nz9uZE957oVSqM7y5k9FNPN+i+Vn2n4uJxACePYPpObsaXu9aQ7qLFuWswwusXMBdo6P7R4+zbcAKx2sDVR+w4mVHLiYmvEl1njdOxvSsKx5/Z9EUNbnIvAlqUYRJVJGeUMzCtlq5TfVCKGRgVKowmkEpEzmbkcUvxBZOjO3AtPZeAudfZsL0tqQF61Lk29N7RiVyPO5w3y6iWmogxWUhxsIpDtkIqye/XENPCAM7Wt6Zvt6cR3s2CvRNoo9wx3bJFxgWOtf+QvtIwLLoYlnf0oqI6A9J80MqrSTGWcDQ+lvx4JcFTlvHx3E5U2SjZpvyUO6pEbJVyHtXqkJktmOviYl2x2091qyt0e3oJLRc2oX3kLkRBZFXIXj5ImkqC8jJ31CYiSkU2HVyIe4Ifz3/+JbL7J1u2DtCuH44p+xFE0GLCESUVUgOz97yPCQunc2+xafIbnLh+k8lj+9OqSShZJQW8/fl60ArsKVlDVccizJZ7zr85pcWAgLZST7ahiLG73uPG5FXYyq1K18Frl5n+9RIACvIKmD/0UbbsuUBJSSVz507G2dnh4fdYHb2ag7870HQ42bcuERQRisrOFqjTvjUinvN+RHEuGZ7oCBN6ILGT497/pQfqksnljJNDRPI53po8EMcMHTufURAbZSSw+VXKqyIBMAGrZ75I+4H9MWjzCG7dG5+IcHZPW2u9HueO4evsRr69CQkg6xSGg6UpPuNHAE6AF3AM8Gnw/SvmPEFK4nWuAS3bdScgOPS+vY8BJ7Bmt0wFAur3bD0IOUUwYSjEOsE6l89YpXHjS411wmYUY0k13cJNUoSntDPL1VCqv8mG79qTmvkJkbG5rA4bwc3alqwM7cIkz9NIhatIxEos4mhM2CPjNBLhMpCKVALB7bbzcWwPPKveRK3ugsJixDnlRxLTd7A0Kw83tQ7GlNLF9jA706sxo6bEUou3qRZEkTbGYq7EzUMhfRODuQkS+5vkVywG4KqdQKW99fkZr5xPD+Ng+txYzflmjpj0U3mvqyv9aq1WXadsTZzccRaTuQcA9g7dqMstQskd66TUQXUAB9UBQGCuz4+0ajaaEbOs4wOs8cYSreH/KC6Xsn7bB3RsuYcpj981x2xI6h3rv7U6CRKhgrLap/D1fQovjwfL+tZtk0nB0/Wh1SGvmwjI5HJkciXtWj6YpfOjGXMpLy5FFn0UB62R22lHaBY5rD5BQCMPcmf7RS7PWk9tzj0LcFs/F9p8MYGAUX9Pvz333HMIgsDFixexs7uXQCI6OpqnnnqqQVkHB4d6C6qAgAC6deuGt7c38+fPZ/To0YSHh3P79m3Ky8tZsGAB/v7+ALz99tvExsZy584dmjRp8i+1197eHnt7+/rPUqm0Qbt+jYsXL7Jo0SKWLFlSL4yBVXjp27dvA3eQ+y3FvL29iYyMZOjQoURHR/Pqq6+ycePG+rIymew3v/sf9+3cuZOePXsSEvLXZH8VRZFJkyYRGhrKqVOn6mMYArRo0aLBuQI4OzvXtykoKIh+/foxceJEXnjhBYYOHYpafS8Z0FtvvUVERAS9e/f+VcHMw8PjAeuz+7m/f3x8fJg2bRozZ86kqqqqgdC2evVqHn/8cbp3787zzz/Pm2++iXDfO2Ej/xonLsGS76H4PucSdxeYPR66t/2/a4coioSGhvLMM88wZ86c+u23bt0iNjaWlJQUmjRpgiAILF++nF27dnH06FECAwNZs2YN7u7uTJ06lUuXLhEbG8vGjRvrnynvvPMOP//8M88++yzvv/8+paWlDB48mJUrVz4wRhcvXsynn36KwWBg3LhxLFmy5KFi/h+t966bWvv27fnyyy9RKBRkZmZy8+ZNZs2axblz57C1teWRRx7hs88+q3+GmUwmXnrpJdavX49UKmXq1KkUFBRQWVnZ6Db6X0T8ubPsWbWCqtJ7Vv2Orm4Mnvo00R07/W3fq1Qq65+/fn5+jB07toF12Nq1a/n444/rF2hmzpzJc889B0BwsHV+3LKlNZ5K9+7dOX78+AMumRaLhU8++YSVK1eSnZ2Np6cn06dPZ+7cuRw/fpyePXtSXl5ef6/ExcXRsmXL31wU+uabb1i8eDHZ2dkEBwfz1ltv8eST994zKyoqePXVV9m5cyeVlZU0bdqUDz/8kJ49e+Lt7c2aNWsYPXp0ffldu3Yxbtw4CgoKfvW8fq8//pf571lXUcge/v8/iMVi4ciRgxw5chCLxQKiyJ3cbL7evoFDl09htpiJ8VAxqIkDw0IdkUsF5Jp7LzKOUqtVV7nOzOJj8djaOtM9KhyAvoF2qMP9GB3syPtRXZk2bFz9cUqZgNZoFcAscjkmGirtyjr5y7vfEJqHRtVvF4ArBVri8qupNlvLiEBJ7T3R41SXbiRERnF8cD/Kg7yxKK0/hGVN/Rg8eBgvv/w6TZo0Rau1CoHXyUdvMUKtNSi/pEKPbVIJjtVWSzHX0nvurFqFghs34qzfa7GQnXCCvPR45O4d8Q7tiKOjIwkRTblkDCE3W4olVILUWYvxdD41q26i+fE2JS/HcUZ4m8vbErhyO56PVl3j4vUE5LIqpFgIKPWk9ffvceiUjqS0GpJ8LWSUWWgWa0ThUM7eGzpOHnNgRvp79JX0IK3FNp4fdYEPvFvR3dmbZS/1Y9HIAZQby3k6dQzJV4awMs2FSmEFyt0jMJcHosgYTZMIE8n9XbktiHw9V8fST6QsmCGjRqgkZag7SxcO5dBjXbnzqC9u9mYUFiPVZQe4GHKMLV1WcWrAZ4S90Yznvqhi3sR4Wid1o6OnPUaXXLpXj0UURTQ6A/kiBIkifQQBL181EW2bkibx5b1F88gtyaGLNhCA1kZPFgYvZUXkHXaFGjDWDYninByun7y3Sn4/Qnw8DjJXPrS5wGu2JzBZTFjqBNPsyiIePf4uP+qP8t3Gz3Gb3YGg1Y9jaGmAziL4W0gpjkOwtz4Ounm4MtLfG39HB6v7J5BWkUdu9b0fuQJ9GahFpFIR/eFLTB/1Aq+//hWLF29k/vxvH9pGgOLMTHQ1NcikEOkPFnkN58ty2XbxNAUlJfVjW1Vcid2Z2wgWEfZcB7uHv8TdT4tWHenfaTiCKKCtEji7piWiuJChPXpir9VTtOVnjEUl+LY7x1d5VczZ5YNUJuPRJ55h9fMvcfy9T2gZar0GFsDc/AuCZ+9B4XYCqAKSsVj21n3b20Anbt1agX+nQUT1Ho2tvQN29o7/0CoD5RY1hWZ3uC8a4YUbsGQjrDZCvzvw7ck09p66QYhkEwJW69EoOWSbQ7ls7IyXGTrdgC7JGuLKrcLiydIMrmlqMYkyVhV0A9RAW9LMu5AIJhRCBRcNx4DeQADXb/fgx73PYlvuTL5LGGKJPaftS0hEw7nQ4Rzo9BwuCYVc9AngM+enmOx5BgFoJrNw3kPCcbti7LNOcDNxDSE+7QjzjCS/1UlkdjVIJCLPuUUTKHfAo8yD9NblrOz7FTcDejEhwp0++j78st2DAXGnEHRG3LecprjKAZnUusr/5JDC+r653/INoFeXV4hoas1+6/oPi3oDu4C3mwlXu69Rym6TlHqIX2PG49DErwAP+48J82hD19iv+OjFh5d9/jH4YBasehdC/B5e5tsjPzHxjaeY8c1ETGbtQ8vcdd8U9M4AqJSOODs9WGFZcQk/LFtD4tUbv9r+/wXubL/IydFLGohlALW5ZZwcvYQ72y/+5d9ZVlbG/v37ef755xuIZXf5LSHkLrNmzUIURXbu3AlY3erc3NxYvXo1BoMBrVbL6tWriY6OJjAw8K8+hT/M999/j729/a++/P7euXp4eDB+/Hh++eUXzOZ633FSUlLw8fEhODiYcePGkZ6e/qt1FBYWsmfPHqZMmfJPncPDiIuLIz4+npdffrmBWHaXP3INX3zxRaqrqzl06N4z5OjRo2zZsoWvvvrqN49t2bIl3t7e9O7dm2PHjv1m2YKCArZv345UKm1giVddXc2WLVt44okn6Nu3LxqN5g9ZGzbyxzhxCeZ+2VAsA+vnuV9a9/9fIQgCTz31FGvXrm2wfc2aNXTt2rWBoP7ee+8xYcIE4uLiiIiI4PHHH2f69Om88cYb9a7GL7zwQoN6UlNT+emnn9i1axf79+8nLi6O559/vkGZY8eOkZaWxrFjx/juu+/qLVx/iz9S75EjR0hMTOTQoUPs3r2b2tpaBgwYgFqt5tKlS2zZsoXDhw83aPNHH33E999/X2+9WlVV1SiU/ZcRf+4smz9a1EAsA6gqLWHzR4uIP/fwxYi/mvT0dPbv318vDK9cuZK5c+eycOFCEhMTWbRoEfPmzeO7774DrItMAB491YIAAQAASURBVIcPHyY/P5/t27c/tN433niDjz76iHnz5pGQkMCmTZvw9PT8p9u5Y8cOZs2axcsvv8ytW7eYPn06kydPrv99sVgsDBw4kLNnz7Jx40YSEhL48MMPkUql2NnZMW7cuAeeL2vXrmX06NE4ODj86nn9Xn/8L/PfY2Fmo7SarJgtYKv8c8dWajhyaD+b91oHjCiK9OnTH+E+O225XE5GmZZjmTWEuihwc7BnwYQxfLptJZWaarpGeBBXUkmN0UKlVseSU7cZGNOE3vZyfAQzRuSY5WB7LRunEa1QyRXojAYUUgkWiYjOKGKrEJDJrJNFi0VEY7QwaMgj3PAPxP+xKYxxceP22qVU1FQhCAIuKinlOjOXC7T4OCgo05rpF9GE6hqr+0OVkxPXm7fA0yUUUlOwbLmFEOCEuDORNNdg9u7djclk5MjyZTzm7knbxe9xTnGH2kntsV14Eb8rRkYsewlzTCz527dQ1roNXk5OyGRyTqdf5fTF08RGNGNot2jiz2xl0+5qqjUivQZ0p1ZTS/HZ65T5xxLvHsCjmkpsLRbcpLb1fRqc4UGsEExtTSnP/rIP9b58enUcgrv6DmVV5TR3a4Z7lg+FcmegGAC/dv2RaO9wK/cWehOMKB9LuBhKuC6Uw8mXMUUkMcjbgQ1f7afzkCYYY9Ipamsga4Uj3a+MJ079EyaZErt8uLFhPCHZSUh2taO64iQFyt1cPLsAgOI8KQeZh5vt91iQkB/ogQQzXwwPwnizgNt3bnHzlB87r/jw5rfueCllePp7E/Nza4aodFzu8bn1JK8FQyGEt22H//CRYLHQw9OTHp5eaDQa3pwyAW+dnk12i5ioj2K0JQQVMk4WycHTgViJK9c88uiSax0Xp3dspXVvqwtslV7D7bJsWnqG0t2/G7FuU3gv43FqMaERjDyna0GqTTUVcsiikOLaCr5UlCP61F2DOl1iSH5H1l9/nWRZDkM83uRkUSmfto7m5aF9GLJvO6ihq28soS7Wib7ZLDLjyJdQLmAGDiq1dLjvXnFysseg06FQNYy3t+ujxfzw+luofXx47dRhvjp1hPNnT9C9eXtEk4mktFS83NwQBKhUVpHjrKddhRJN33DsgMQblykvK6ZTj4G/eiv3f+oxEnb8gEqpIlrsz/cz9mEb4UHXyBacuZqB5pU2DJr2UV3pTcAyJjzyJJz6BYCR7TsTV1JMx0HDaN+1HwCX48fQPHwLVTWunInrzfCeycACfvkR9pwJxyeyNYEu3owd+xRyWcNnz4nqLUytcceIjG/UEgbWdYmdDRhdoGIA2F2GDVuaAOuYqZnN7t7z0IoLaa+AgSrIMcPXGyB7CEA4t7p+Rofdw+jtFU2CrTOJteVM8qwETgN23DRMR8UhKkQXEkyj6KD0wWDMYM5iAb1eICa/hozhH9OpIBo7O1dCS2SMuFLB+RbuLHhBS0FJf7zcDhCkrOApz6asCrO6b6MMoqJOPC9S+3Am+FVsqoMJ8jUyJFTgmU4ezGYU+wrymLY1D6ONjnSvbH5JPkx0pTVej3dWHINvvMOj0Xp+SGuByWx1jflgjSdBdWKYXqYiwb87LdP3067ldDYfeZ8lP8KrT0HXVnA701ru0T63CfX+iSfmTeD4uXSuxwfRo9Ns7uReoVITxbUkG/p0BJ8676hmofDBXCWvHyrAubQpLwzqiuM9I50GSCXQ9XcSVLr5OZElX0Lq9VqKtCd4btK+B8p8un01ty5eIyQ6lLySS3i6R+Ds6PNAuVdGT+PqyfOobG3Yk3ERFw+3B8r8t2MxW7g8az31wT7vRwQEuDx7A37D2/yl7pmpqamIokhERMQ/XYeLiwseHh71ccMcHBw4fvw4w4cP57333gMgLCyMAwcOIPudzLt/JykpKYSEhPyqFckf4a6rY2lpKR4eHrRv357169cTFhZGYWEh77//Pp06dSI+Ph5X1wfNM7/77jscHBwYNWrUv3IqDUhJSalv2z/L3WPvXsPS0lImTZrExo0bG1iB3Y+3tzcrVqygdevW6PV6NmzYQO/evTl+/Djdut2Lb3vz5k3s7e2xWCxotVZxfebMmQ0E2h9++IHQ0FCio6MBGDduHKtXr6Znz1935W/kj2G2WC3Lfosvvocurf/v3DMnT57M/PnzuXjxIu3atcNoNLJx48YH4vpNnjyZMWOsyWNee+01OnbsyLx58+jf35qgbNasWUyePLnBMTqdju+++w4/P+s725dffsngwYP59NNP6y1t1Go1y5YtQyqVEhERweDBgzly5EgDt+5/5I/Ua2dnx6pVq+pdMVeuXIlWq2X9+vX1433ZsmUMHTqUjz76CE9PT7788kveeOMNRo4cWb9/7969D2lBI/+JWMxm9qxa8Ztl9q5eQWS79n+Le+bu3buxt7fHbDaj01m9HD777DPAKkh/+umn9b9HwcHBJCQk8O233zJx4sR693pXV9dftaKurq7miy++YNmyZUycOBGAJk2a0KVLl3+6zYsXL2bSpEn1i1svvfQS58+fZ/HixfTs2ZPDhw9z8eJFEhMTCQsLA2hgsT116lQ6depEXl4ePj4+lJSUsHv37voFoV87r9/rj/9l/nsEMwDlH3wJFEXrL6hUAhYLFFdi0Rvqd1vq4oP5t47lhaeeJTUvm7QauH7iAmbxNkmler6eOoVj8ecI8QmgV5tOHLp4ijHtQ7ljsOHwxTgALt8porjGSLJR5BGVEpdiON26nBNb1xLl4EeiMQcRa/ymztFRDO3ch11nDhOfmYxRlDOyYwe2JV2jxGLk/KZv+ejZNxjbZyhLtm6koMZIUa2ZnoF2qFUSKvUWwl1t0VTnIQgSRER8qqBpZRNGJbzIvNCXqd6XjAi4IlCVcQGTjVU40Wo05OxcTlBUNKNatKJ8g8hRnZHiQDAZjYS8+ibBr74JwFjgvZ+Xwc1qMJi5cSOO2BA1NbUWqjXWmc71K7coLS5FDoQUJpPvGkinth2JDQ2iR4/eeHl5U1ZSTuLZa7xRNoe0IF9GbNhK25Ib6KNbMOTx1zBbzCTuzIcwqC6zI1OTja1cgkVw4NFJb3Cj7SbGvNiC6Eqr1Z1G0FBjV4JnUQhX+y1l2P5XcZ4fSGKHHGIGdSD7gxx2nV6IZEsm4IWPtzd900Uizf2p/DaFC72+QzTX0Gr+t5RuGYT7mN1EJIym3Kuaknw9h79WolYrWDOoNeeScomr9eD05f5U6nScPiRh9DQD+qJcTuuO0s/lsfqx5OcZzDu6V5E9qQAHrEZAQEJmBh8vWYqP3ogAaPR5GAR/lKIMERF3PwU7E2fTRGWHT69rmNtX8MPJONzCrC/1WqOeVmumkVFZQIzGlp2TlrPthhOucm9Kjfkst7/JcKfmtF6dyJnS28imxGCSgCj9B/cOEWZkPYJadKC9MZIutbH8rDrDoox0SrNvgUyEOAG5yXpvfX52P2UZ0WirzCCIIAqUyUScWvnx5ZTHqZRCUGU2k22cCe3YgeC3X+PtLRvp07wVgXv3A1Cel8cHS5fwTXoCAA72t4lQO+Pvfm9y9dX+nXzleBEbewnvhUfR+9JpnnusBxaLhedeWcSEZ19/6K3dtFM3Zkz3Itx3HVKpHeFGA3N++BiLKOINXB3yIgdNd1Ad3kpVZVeGPGJE5uKJaG8P1dVUyex5ctVa0nW51Biv4qhsyZ2CYbz2eQVms5ynRsmAbQBcOQ+asnuWUZlXEsk6GUe34QOJaN2cSoOZCbcUWIKsL44n9UYGqj4C3IgJnc6HUwRmGMGiv9f+Gu1kYuVh9Z9j5Na/T3KxGqjJwM6kIyZiCGMGfkKhyZkKk5lHnCfVHzPYpi1f1WRRngcecXCjJUSFSJDJAD2ozOWMu/QNEx7tyvYdCzj8uT3utXp0x8ox7OmDo+teml5aTprOFkhlYVArPBVWC9qRg7ay/PsVWFKH0SKpP3qDQAWwMRkyg5JZrLuIWTATYYFOiZ+Rrw7kYudHcKtIxVmTT1VtWwTpXk4Wf0Wh+AQ2OGGWmrijAqlpFvZOP3IteCClbgORnNqHyQbyrVo5h8/D4jlWizSptJpDh1uSkqTlevx2Xp9xjVGDFrN0VW+27ZmNztiapMJLHDwr8ORQuJUK4wbA6PxznHdtjpNHG+a7P3xybbHAQ4xUHiAx5RBGo9U6N6/g5kPLKJRKWnXtAICzy4Bfrau63BpI3aDTo9M+3Frtv52iU0kPWJY1QITa7FKKTiXh1SPq18v9ScQ6S9x/1fVNFMX6OrRaLU899RSdO3dm8+bNmM1mFi9ezKBBg7h06RI2NjbcuXOHqKh752EymTAajQ1cLZ944gmWL1/+L7Xr19r4r9QB9/pr4MB7CxjNmjWjY8eONGnShO+++46XXnrQhX7NmjWMHz8e1T8sqAwcOJBTp0412BYdHd2gvTU1NX+oTf8M/1jHtGnTePzxxxsIX/9IeHg44eHh9Z87duxIdnY2ixcvbnBceHg4v/zyC3q9np07d7JlyxYWLlzYoK7Vq1fzxBP3woU88cQTdOvWjYqKinoLuWeeeaaBK2xtbS0DBw5sYKmWkJBAQMA91/9GrDHL/tGy7B8pKrOWaxX5f9Mmb29vBg8ezJo1a2jXrh27d++uj193P7GxsfX/v2ux0qxZswbbdDpdA/fegICAelELrOPSYrFw+/bt+slxdHR0g3Hj7e3NzZsP/x27yx+pt1mzZg3iliUmJtK8efMG4nDnzp3rj1OpVBQWFtKu3T13e6lUSuvWrevnYo38Z5OZEP+AZdk/UllSQmZCPCHNYn+z3D9Dz549+eabb6itrWXVqlUkJyczY8YMiouLyc7OZsqUKQ2EYpPJ9KdilCUmJqLX6+ndu/df1ubExESefrph2KPOnTvzxRdfAFaraj8/v3qx7B9p164d0dHRrF+/ntdff50NGzbUh5D4Nf6q/vhv5b9LMPsjiCLkloLOAPY21lhnMgm923RBlErB2Y4uXbqTeOsm/gGBtOzSme8+/Zalm62uFlKJBH83FzyMtey+Yg3Y6qCypVXb9mTs2U6kQk+OlxOZpRqe6t6R1cfPkqepxdfZiEqbQ7pgVYCLElMZFqTmiFxCjVbDtZR40vKyqNVpmThwNDfSkhjZpRe7zxxBJbPGPFvxyyac7Oz5JbkSrcn6cudvMiFR2OCotF5KiyDQQu2K9NQxgm4nYZTL2dTNDRuLI9VosaupoeeBfciNRip69OK0rS3tL54n29+fbefPYLh4DhuFCq2/9aWxJFiCf34JFQVFVEpM5FWWoQ7zJ8NUChnlKJ3tCY4ZTG2VnM6dU8jOq6FDGx+OnNJSVmsiIrYF8yf3oGe49YfeZNBicM8nz6aGhPJb1Gpk2BXYoFM40irwME6HO7C8Yg2a6hzGl2gpn+ZObE5n/HMKECQiV1b+xNepZoznTxMeo8X/qifxTU5wIPpLHPzaoijLQF0UhEuh1aQ98tZjSFbIcEuIpuWz/en08VgupVzD3s2NyLea42pywbhNxyT3ZWiiamjbrpil++ZQvuNF5trOwXPvVnZfa8/1O9bMe/0O5eGvsGNN1iAq9NaVipObbQgpXYGdtBoVEeQUXiQ3Q4OPJYTwsyOQGRRYpluQlEhICbnFtc7nyMVAJ0dPylxqqCnNx97FHYlUhiAIVKIn0kNDtuc5soFOFgUxNip6DOlG6NCpAFw8fZSWF8t4pNIGo0Tk9I/f8dj0ubQI+wa9MpWegdHoS8t5/unP0Td3xfQwAcAILa+G0aEiAhGRbJtizrW6BekWSvVaKBNABrIoCQWepexJOceWK0ncOLkCo96A3E6FUaMDBAL7daZAamHhT5twNJrpK5eRcu4821Z8TZZRy+pD+9j51ASKM7MIbB5LefMYqBPMJAVpdGg5jCYh92J/dY2K4Zt9v2BRSukUGU1u/KX6l6fszJRfvb0lSltC512AzZlgAK1Jj9JGhbbWKkI8a/yJ6hOPsOD5H4BdFBeEMm32KYQBr4O5AruyMTzy3Xucf/IyjspqYBTDe25Dr7fBYILHBgJYg1s/8TS898oNqpPcGDH8KRKOnwfgdkoGyVHNCTaYKc2rxMHFHoVShq/DMmBeXUvV9Gw2luNmWC6H/XVbI0PuRZe/FLeJnQdeo2lQNxaOXM+6I1ICmsOrXR9F1u1RNmhghQZASkoZ/OACthJQCPCiA4z+Fo6WwM7DsPNLWPoGnLlqwt8jgxYRF/lwWUu0ukpGmuYA9ohGCzv3v8aT4zfS2TGWtNp0uji74yZXkp51lnU/Po6DvTfd2r3C6atJpBfeE4C83GBpdRz2xR6E5l1GYXcOG8UNQjQ30DtNY2un+fjciCI40xoo5mwfgVLPn7ErciHseBdUNfaEhX+Odtg4FFVF+PxsNe+KT4Um/lBckoqf+hd++iWdwb3nIpFIOXDQ6uJqMt1THNOyrBNulfwKEkGDRmfPe3UewkmpOgqHWcdBtdlErcXM/XYjecUwYxFUa+DD2dCqTsswGEHxkLUYre5elqXggI6/Oib/CAu//4rNS1fRrndXfAL9/6W6/lPR5lf8peX+KKGhoQiCQGJi4j+dza60tJTi4uL6uCCbNm0iMzOTc+fO1bsIbtq0CbVazc6dOxk3bhw+Pj4NMlRt376dbdu28f3390xhfs2y6Z8lLCyM06dPYzQa/2krs8TERBwdHR9qPQZWC5NmzZrVW33dz6lTp7h9+zY//vjjA/tWrVpVb30F1uuyd+9efH19f7dNdycNiYmJtGjR4g+eSUMSExOBezFrjh49yi+//MLixdYYjaIoYrFYkMlkrFix4oHYdnfp0KFDA1ELQKFQ0LSp9R0iOjqalJQUnn32WTZs2ABYRa4LFy5w6dIlXnvttfrjzGYzmzdv5tlnnwWsCSfuj3nVo0cPPvroI9q3b1+/7f5kDI1YKa34a8v9VUydOpUnn3ySzz//nLVr1zJ27FhsbW0blLn/Pr0r5j5s22+JS3fL3C8o/+P9LwjCnxaoHlbvP7q1/5ZIf//2fywjig8zNW7kP5HqP5iR8o+W+7PY2dnVP3+XLl1Kz549effdd+vdgleuXNngGQoPJq75LWxsbH5z/913gPvHtNFo/N16H3ZP3N32e98J1ufLsmXLeP3111m7di2TJ0/+zUWlu/f/v9of/638acHs+vXr7Nq1CxcXF8aMGYOb2z3XkaqqKmbPns2aNWv+0kb+pVgsVrEMQKOzZsT0c0emMzAgdDRUa6lMySHcVo0uuwRTsAJNbW394d0DbDm4aBG376Szu85NJG/dJS61ikMrWG+AiV2jmdhjCF6uHrwxcgivf/UhYT9uQG4wUnLbCY3akbE9umHMukWgrR2ee35BadBztkMn9I5OfL5zJ1JzLUkJSZgldoD1+1OyM+gc25b2PrZ0a92Nt0aPoLKmivmrPkOr16HVGVFkFzC4Vxh2H39LzucLyT19lET7axgUJrCAU1Ul8rob1cFSS1tFMFVCCPH92mHQWFdvf5K3pr05Hg9zBRfOnWXX1i3kltyzpEEuwWtWf4xRYYxyaEO/XpdxcMsiJFLkrRf68MPXk1Gu+BAvZydyzpQz7vRXjGrSEqVMTuf0Kg6Hq0BQoenSmrSP0/F0SUTr2gKX2l5c0l9l10VrnC6L3MhTS87xvLY9C0O3IrPIaU1vNGeMZFYWsSn/e7bMm41KsKfTt2H4VnXiZNObdNQXkOdQiE+1J5IqWb0aYfxMw5VBnxCY0Bul8RQutd+CXT9kmsnYrh1DhW86i17ewBH3OM65JGCXK3I4sWW9WAbgJJEzIvUUmvsC5M9vVUqFTI2fyhufXr3I2f0LmUkSLAYzEqN1FV1SYn1gBtxpyrGw3diqnQFw8W2CJDaYJ0Y/QVF1JT9mnyGmwAZNyr2sYgazFIsgwbdlVyxmCyd/2cfVw4eIqFQiWszILVBaUMyBS3okMkeGdWiFjRxsvLyImTOVTW7x1opEkOgFQoy+uDZx4saNOzxW2gtH0Zb5Uav5MPJHjBIT1ADFdYPbG0zOZhK0mcze+jWFKTo0emt2UonaAi1EnCy2PNGnD4NefxWAKrmUaid7WsW2wLFHD24d2keoty9Lkm+Q0bc9a2bOoUtUDL6eXrg5OvFol+4P3Kbp733CkLMXadm/Hx0jojCGNOXGxdPcSU5i/ORfCTx1d3g6e8HjzljSyqkylvHGpGUc+2EuEtkZhozZy+E994KVaKqzgP0gFIEMdOYE1Cob2nhVQ7E9OsMRJG56Hh98v6vlFGAXoZEq1u8eB0zCoPPjwpZ9FGRlsycoCovmAhEyb+aGO3NglwGxQEV6P3+wenlisUg5cMb6f+V9K9/3r4IfOL6QisocLt74keyO74NNMMe+hoDh8MQQ8Lrv9+uaET6vgbn3za8FAUb1/oqurXchlbxMaEBfQgNkQDfM5ns/1l+320ibvGZcca2giaPVGqp7fGfSd3amTTSIMQK/HHyTsoossgu9SCkeCQgoZTfRm6wr3U0DIDIvDNeTlYR5zIVS69qEl3s4A/2acTbhMHJJLmAVzKpcrI3XeJTxypN36B7cHE9XkEqs3/9FAmzJhG6toW3Y66z7JZifT7+ErfwiWu2rTHl8A89M2E1S6iE6tr4XC2nUoM85deFrfLyfIDzaHg/1Jb7c1AIkcm5fvsjGlzqzvCiFQWo/vBQNXzjOxUFhXZjGA2etgtnq7bD2Z4gJqiKKDTRvG0r3odaLGODbBj/vFqhUTowc9OkD4/DPENoskvkr/7U6/tOx8Xb+S8v9UVxcXOjfvz9fffXVA25yQAMLn1/jiy++QCKR1AtutbW1SCSSBi+ndz/ffSmVyWT1L/FgjQ9mY2PTYNtfzeOPP87SpUv5+uuvHwiED79/rkVFRWzatIkRI0Y8NFYYgF6vJzExka5duz6wb/Xq1bRu3ZrmzR9MO/swYSwwMPAPZcls0aIFUVFRfPrpp4wdO/aBtv2Ra7hkyRIcHR3p08ca8uDcuXMN4rTt3LmTjz76iLNnz/6miHft2jW8vb1/87vmzZtHWFgYL774Iq1atWL16tV069btgVhpGzZsYPXq1fWCmYeHBx4e97KUyGQyfH19/9Yx89+Aq/NfW+6vYtCgQdjZ2fHNN9+wb98+Tp48+ZfUe+fOnXpXLKBeuP81a5S/s96oqCi+++47NBpN/bP1zJkz9cc5OTnh6enJxYsX658ZZrOZa9eu/dPidyP/f+FwXxKVv6Lcv8rbb7/NwIEDefbZZ/H19SU9PZ3x48c/tOxda8n7fwv+kdDQUGxsbDhy5AhTp059YP9d98f8/Pz6hDL3L5Y9jMjISE6fPt0ga/PZs2eJjLSawMbGxpKTk0NycvKv3n9PPPEEr776KkuXLiU+Pr6BS+XDzsvT0/N3++N/mT8lmB08eJChQ4cSGhpKdXU1b7/9Nj/99FN9jAWtVst33333/7dgJpWCoy3UaMG5zvVBb4SyaquAVq3Fyc663VapIunadbqFuJAe4YOdRMLzA3sjkUiICGxCj+tqygvLOG3REZdVQ3NvG5xs5FSp3Pl61xHah3lxK+02Z7PLSHFvweN5RlpePYvPxMcoCfBAdqmApnvOY1tmNVWNSEzkI59YMisrUEoFHgmHcr2Ua2U12MmleNvL8PfwJshZwZxhA5BJpbg6qendujM/nTjE7uQqAnxCafKk1ZTS5rUFHCvIpsPRXST2H0gOUNO0KSUyLUJ1OSd6tEKfXIG0bxiqupumWrChQuJAqtwfD3MF165ffbAPjRZS151ni5OMb2ouEmzrTovI2wB8uacMxzYtEV2cATCobQgM9cIiAy1Grkh0IFgnqqLWFzdnq5VetTkfLVrsxXuTFQdBRG7wpImuCePynsDd4EHL6taMBebLU7mSfZXgN59m+fW22HUKZtwgO5THm/KcIg2HkEvE3RiITJRiVBjZYd6Np4OFwCtDeXqrkqNdzyBIALsfqdEMpDS1P3vPaBiYfYGLw5YgSsx8OLI/t6bfe/GVuQkcqyrASSVHU2tCkBkRWx5jt1c+nSQSuj4/AO3uGyR7G/GoUmCrc+A7l3n0fG4sbJASkBmB0qRixNmJjIvYRo/KeGSO9nDnJqvOrsbGqxuapjHE9O9FtTqDiuIyPPx82C4k0uPaduwKj7E18gWSr93C3tUbs8lIZaE19V/xnVQqdi7AacBCXty7lVPlO1CrHHjzyTE8siQVuUXguL+BgjxILc6DUjnTWixiV9IaWgoW0sXtRJeqyLXVU1xhAgQIs+DpqKYQ66pPbm4J2jA9SAVsSuVo1XqwQGWNhovZCfR08mZjlbXs1K2beLR7LwBmjxzD4firvPDVlwB8+vMWesa2IDg1mwNfvAaPj2XQKy9xcu16XHx9aD6gH7cOH8UeSN+1D1EUkcnllOw4R1VKKsvTJvHhjcu/fZ8rZUhkTvh+ZY9OauKRxa0QHFcBMGDEVUoKZVRWmpj8XFPgEeBLIJ123hP5tGcEJz98ja5bhiITRZJn7CJq8uj7Km8DZAHewELgOypLLpJ+w2oxF/jzd4TbRiAiYVDnR9lzw2pifn7rI3zY4WMm2rpx9vhoPl9vre3ZMdC7PTjYwYDOScAdoC9ym9dILfahZLiSQnkwdAGP2/BJlRZJlYTHHZXMsoMvNNZ6FP+wcPT5Kzn4eVlX0DZqWnCopi9T7KCbEqRSOU88so5NO6aRSwF5jkXERo9kxEBr/JS9J+MJUC8kI7MjcfF9uFyYyM3Ix3EscIFi6xepHUoprTZiNMnRNc3hKXdvdp26t0KodhnJnOfWcebit7wVtx57O3fk/ROJDrdQEBjJZ1lgG7eGM+mTOCeRM2nMRlrFWmO1zHoCnh8HMhm89PaXVGqtQcRrje0QBasFSGRoPxzsPNh75G2C/LtToZuCSjGat2ZbgxBfvnmSdZu7oz8+BBxbIWTvoJXqAqNyu1J4A6oGgeN92kiHWOuEqaYW+lh1O/bUzV8ub3yDCxnbQRDYeHEvobFhfL1uIFpdBZ7uEbg4N7pA/at4dI3A1s+F2tyyh8cxE8DWzxWPrv98nKpf4+uvv6ZTp060a9eOBQsWEBsbi8lk4tChQ3zzzTf11kdgjVdSUFCA0WgkIyODjRs3smrVKj744IN64aJv37688sorPP/888yYMQOLxcKHH36ITCb7t8akat++Pa+++iovv/wyubm5jBw5Eh8fH1JTU1m+fDldunSpF9JEUaSgoABRFKmoqODcuXMsWrQIJycnPvzww/o658yZw9ChQwkICKCoqIj333+fqqqqB+KdVFVVsWXLFj799K8XhgVBYO3atfTp04du3brx5ptvEhERQU1NDbt27eLgwYOcOHEvYU5FRQUFBQXo9XqSk5P59ttv+fnnn1m/fn29sHZ3YnKXy5cvI5FIiImJqd+2ZMkSgoKCiI6OxmAwsHHjRrZt28a2bdt+s70hISEMHz6c+fPns2PHDjZs2MCCBQsa1A1WC4GPP/6Y69evP1RkbOSP0Tzcmg3zt9wyPVys5f4OKisrH5ggu7i4EBAQwKRJk3jjjTdo2rQpHTv+a5bKd1GpVEycOJHFixdTVVXFzJkzGTNmzO9m0f076h0/fjxvv/02EydO5J133qG4uJgZM2bw5JNP1ruYzpgxo/75GRERwZdffkl5eXljhtj/EoKionF0dftNt0wnNzeCoqL/T9rTo0cPoqOjWbRoEe+88w4zZ87E0dGRgQMHotfruXz5MuXl5bz00kv1C1n79+/Hz88PlUr1gHuiSqXitdde49VXX0WhUNC5c2eKi4uJj49nypQpNG3aFH9/f9555x3ef/99UlJSfvd38JVXXmHMmDG0atWK3r17s2vXLrZv387hw1YPl+7du9OtW7f6jLNNmzYlKSkJQRAYMMDq/aFWqxk1ahSvvPIK/fr1a+BO/Wvn9Xv98b/MnxLM3nnnHebMmcPChQsRRZHFixczbNgwtmzZUn+B/iPwcLb+3aWkEoxmMJgaFKvUVLP8hzVUaWoY2bYVzw9+rD5/m4hIePtYNv1wkG1NdFAFelHE007O2ridxLgrycmzxSJCarmeG06unLcT0Eq9UN/KRXV7M/YyCWanMD4rL0MhWshwdqesohYEGSKgkEjwsxMRLEqOZ9UwoFkzurdoz4ELJyguL8PexjrbyystJMSjCbWJV8kpKyOvuBwfdzXKNGda3LRmXaspKwW1Gp3JzJFpQ2B4FJb51hvPLJOh0WmROHtxRtkWqR7CaouRCBIsE5vDrSJkCSX4uHkhCAJ+fv4srsgFXTUOdkb6tsik4m6/6EyE959AcmENhTa2ZB8zICnVImkHFqOe0k1XUbQLAFdbVIm3yNE3wVGZQ5deXVB1tyEwM5jxu+SUVmu4JZGx1PkgTxti6FXanzhNOdRNcDsbnZjyzqv472rGJEHLyLNnODV8H7Zt9HyZ7kT/+ARwOsllnyasEy6RkVoBOTDOdignaxRcqJXQyc5CmlhGkt1CTpT0RK4Qie5aRIemXdmafw1vVzVhQ+HGTxZUPmY0ejnLMlOZPqAJQosKlt9JBpfuXK44ik//Ayx3zOWCwo0LTUVWX3qe8WWDMQg6LqT9TOvVgygaXIm3zhWPKm98St0waMspNxdiW2k1NbKYDFgyqvjwQhKb5SvBDCyCGcd+pFo0Ua0po1y457Li4umNXGVPSVYCUpkCKtIwFsWxvWoz1eZyqMzn4M4fiSiT4dwyGD8POcuS49FhJjUnizvNE2g+ZiKrT87nQJABiSihR64zu91K0LtaQAY1CTqwCDjY2GJwNljz6oaKBMkdSMwuAz2gFXjq1me0UHtirjM5Xn/iaL1g9s3tnXxxYTuCVEA0C0TJrYLpD6/NxajTcfX4GcoFFVW5uVyf8zqv7N7BwBdncmr99/R9fjqCIGDU6ylKzwAgJzGRMb3CefKZ1xg65iFuMToTbLwJR32QpnhiB6wZVMije5fi4PguEkkpE56VABmAH3AcuBu7YwcTYo5x6+MLCGYLMiCo4mGmzxbuWn5CDQpbBRaJCYlFhiCtoKTcKrSm5VwjxC+W9ByIDRMYb/sK3jLQ6u7VJEjg3efhRnIGRWUj8PO6DbzGgUsfYjBAtaROPZBAZQ/Qh9rwmgb8lDDTRouk4BYy52Cm2zcMFG9wk2MWFZRa1LxZtQgRiDfC5brEPb8ceB1NrfUFRsTCjYTtmEw65DIlIe7TqNWcR237A0bDeg41n06RcxMIFPHVbCNYiGRYzNu0a5nPlvLuzK/tAgZ4PCyArLTvUMpSadN2NqJo4ef9VstDucyGT985jiCIrNy2mNj4RxFr5oIcLBYjpy9+S3j0SO7oNUTYOGG2CBQWgbNzAO6ln1NU/RqBPjlsCGvDvPM/sTasM9d3TCU79wp7z4Sgto1CKUsnJ+cjnhj5Kp+sqUBqeQKv7p7IM7Yy66PPuZJkw+J11vOvqILX7kvU5+sJO5ZYjZDvxmUf1hNWbwPMdW6foohRb8BsMWE0We9Fvb76IeOjkT+LRCqhzRcTODl6iTUhyf2iWd0Pb5slT/6lAf/vEhwczNWrV1m4cCEvv/wy+fn5uLu707p1a7755psGZefPn8/8+fNRKBR4eXnRoUMHjhw50kAIi4iIYNeuXbz77rt07NgRiURCy5Yt2b9//+9aH/3dfPTRR7Ru3ZqvvvqK5cuXY7FYaNKkCaNHj24gclVVVeHt7Y0gCDg6OhIeHs7EiROZNWtWA1fRnJwcHnvsMUpKSnB3d6dDhw6cP3/+gWygP/zwA6Io8thjj/F30K5dOy5fvszChQuZNm0aJSUleHt706lTJ5YsWdKg7N0g6SqVCl9fX7p06cLFixdp1arVn/pOg8HAnDlzyM3NxcbGhujoaPbs2cOgQYN+99iXX36Zzp0789lnn1FaWlof8Px+QkNDadasGatXr2bp0qV/qm2N3EMqgdnjrdkwf41Z4/++gP/Hjx+nZcuWDbZNnDiRdevWMWXKFBYtWvSrLr7/DE2bNmXUqFEMGjSIsrIyBg0axNdff/1vqdfW1pYDBw4wa9Ys2rZti62tbf0k/y6vvfYaBQUFTJgwAalUytNPP03//v0b3cD+S5BIpQye+jSbP1r0q2UGTXn6bwn4/2u89NJLTJ48mdTUVFatWsUnn3zCq6++Wh9SYPbs2YDVinfp0qUsWLCA+fPn07Vr14dmL543bx4ymYz58+eTl5eHt7c3zzzzDGB1f77rWt+8eXPatm3L+++//0C8wvsZMWIEX3zxBZ988gkzZ84kODiYtWvX0qNHj/oy27ZtY86cOTz22GNoNBqaNm3aYDELYMqUKWzatOmB58uvndfUqVOxtbX91f74X0YQ/4SjuJOTE1evXm2Q8njz5s1MmzaNzZs3065dO3x8fH7TdBGsL2JOTk5UVlb+5TE6/jSiCJmFYLaw8uhJ8ssreXFQXxxsVGTm5/De2qWIiLRv3Z7p/a1WJmfiLrF231bKao3sSavCLAo462F2lh3bPHUk2plo7meDjUxCkLOco5kacqof9FeWCmAWQW3S091bicLNiVKtiQt5WtrWVDK95BYaOztOtu+EBinBDrbERLdEq9dhp7KlqLwEo9lEctptopycWZdaRInGxBbJ+6R55nE4PR4Xl5NIHCxU2ztgrnNTcFa7UG4nJzvdHh9JBjKZ1UWkuY8fw0Ij2b74MPFtRQRPB4QP+gJgp4Ev7B6pb/uZO+nMX7SMl2IqEKRwOFdChUSOMKUNXX4xciMjnrgaBYGmQiSIuHt44qt2Y3T3geSWFLJ8x0ZEUcTJyZlPP12GRGKdEWWkZjJn0svoAREBQQKtWzrSpYkNy76PoENubzRmE9Mj3PG3c4dC68z2huQqqY+uZMexUobrLIxWVVPsoeJMWA6rkuwQ06xuDDUVHsQUTeSqzUoeid5EJTqia6eQnDKLEy2vMfE16yT4RE4F0e5N8NKmoc65jQgsXtuc09c8aOJnj39IJYciJCCHAEs5LR97AdfcAH651YQSW5Hjxz6ne4l1Rfjs8F10emsoG17J4NETAVTIDHgZbUiyvcLTTq/SxXIawWJAqgzFIlpNayeUvEuYvjU8CfuHXGTmwaU45VXzZJUfIS26kJeeBYDFUEl+WjJmo3VCr3D34u3QdAQREGFQmozO6kB8h1pd4Q6mJPPDvuuY1RbcY53oIW/B4eQTlHtaHwMti+xJcqlFK7NY9aCr971BSkVoK4IM3JLtKSm656oMYKNQ4mxjS2F1BfMnPsnbI62mxAHfjCO7qghyIfBcMc8ERvP61h/4ZMhI4vbso9OLc5DXBbq+vGI5Ty9fSpsRwx64X05t+J5jq9dyIuE4GnsLTmpXDlwpfvCeLqiBHxMgzQ3OhWAUDTxf1Yt8tyx2nt6ORLIWGALcndTcAWKBSuBV4CPIKsUw+3ukSgXmj0axZNU7lBSX4ddxOXYOzkwYthy57BvAg+1nx7Do230oTu9GJbPDzV9H8zELAQlPDBmJu0sgd/Ksbot3hRiDET5cK5KWLfLsaAnXsqsoydnJvGesfaa1xND9rZsocsAcCDajjBTflOKQmEv2C/4ggfdroPr0KJJSdmCjcmL+Syk42LvXd8Os8r18oR5MrcWWLsV3KLa40l4BW10BjlBYPIDMbBMbtlrLu7uG8tbsBKRSGau+H01c/DZkMiX9e7zFbLMtySpXBIOJiPGL0b3UgUEV62gZAyVdB/N6pvWHf57PbvyvhXHlRiB+riuZ9OhKlq3pR02t9To52Eno16cn876yivUyhzNEqHsgtZgZNXIlzwkuJGur6GcJo3Z1R0SgX0cNh8/bYBEl1IRlcb37cQAGqn0ZEfcVNxJ+plQzA1c762xI7dyBZyadY+ycOrdiwMNhEQtnt6FK24uXF1svwqg+8NIEq9XBe99aXVjnPQNuzg2HU60OXv+whLhdyxk2LIw5b1ut4BKS93MjYScd2zxFoF/bB8fhfyl/9+/3ne0XuTxrfYMEALb+rrRZ8iQBo9r9xpGNNNJII7/OiUvWbJn3W5p5uFjFsu7/pkf4mTNn6NGjBzk5OfUWV/8K77zzDj///PPvunz9/1Lvw7BYLERGRjJmzJj6LMON/OcTf+4se1ataGBp5uTmxqApTxPdsdO/sWX/vXz//ffMmjWLvLy8Bsk4Gvnz/CkLM6VSSUVFRYNtjz32GBKJhHHjxv0tpvZ/OyYzmC38fOka01dYfaSKq2v4cuYUgtyjmfHcLPKLC+jerRfoLYh6I3v3H8QiWnC2keJhJ8PO3pV5qjBO5F3muqPVSu1SvlV4Ka5VEuWm5PGI1my/GU+mrpJhpVlIRZFzAWHk1Joolym5ppfRUy7BVq7Ax15Om51XUOsrUFdUEFxYQKa/P/GlVdht3YhPfj6X27ajsm7wO9XUYPJtws6XxlN+6xopX//ApJrrAPjoZfTzdUJiMiGRSrGIIhXlZQjlEKAoJD4+mMjIfCLC/Alf8hmpNdX4O7sTT1/E8lqcKkWqnARa6N3ADjRmPQaLic4BIWyfP5Nzv1h/zPr4WNiZbUL15mmu1urRqAWC7+vmkuIi5j75PI5KG3zcPMnvPYI9B47g0aIfDq9vwcfRhtcDSjl97CB2ns6YCmswYUYqF1DYmDArdEyd5ccb875nqrIb/jWxUGO19BNkydg5vs31w3KcbJXs0lsIDHalNMYGJa74DT9Kzn4TYoIPn6tm0SowHFFsR0rFaG6G7MKlcjTjfGJIsjNzUTwPgkCwUzQ9mwaQfuU6ggAKWzULZ1iI25nNyzt8ScqUYJMlRRdiJiYtincyriOtqsDG+zMsLmHUhJ4mqUZPkSyLS9n7ca/0JmnCa3w5qj39fnkE16PNCKttwUuSyRhNz5OqPEkzbSznnbYD1hUZUQpCaxgQ0o4liu6cvbGTIrLwCLyXWc3W3qFeLANwVruxtfujzP3sU7KamkhRW6gK0HHXq/5Jn3DiO6cRZ6ikuLaCXIopd6/LDiZajSy3e7WnTDDxaXEmV+UlYAQQwCyAwSqY2crtuWthpZSp0Jt0PN6jF/kexexNvciC1PX0zW1FJ98YXm0/lte2rqQ200CWtydXm/qi1es52DKUK/YW+rWMxJiWi2Ay0P/ZaVzbvZe8pNt0nzwBp/teILs+OZ4OYx8laVhr0pPjadW+R92encArQCdgDXjaQYw7oksuZ5zf5/NNJ8m1pEGBgF4XhY3tP66IBnAnfTcznnwUg2Edn61+lMjYNih2zARg/7bv2P79cpDYIVyfg03ws3hanqN7PxEHR1tmr3Ijp7ScCBt71AYNYye9iadTDbfOiFzYdoScyGgiOrcn4r6nbbbOwL4LUqRGKa8tMWMMrmZck3svERmmbhRPNTEifwfdw26w+t0ZGKo8AH+eN5ipuJNLrMeTSNpfI/MOaHWV1GiKkcvdeeVTSLkDNSM7k9vHH19pNjtdd3LT+BRd60OxvY2nuwlPdzh7GdIyBV6afhapVAaItG3px/UEAZPJwJ7D82gv80NhHIluz0WUhRV4nzChiWzLjcQ43n90Bjl6Z0ziNeYE7uN6cTzXryZSUAhHz3xeL5YBVGssJOe1RJSaEcxS8gJcOd1xJeuCm6OQCCSnW59bJzV5tMZ6f6+QXYZOCrzimhGsd6dIYUOBQctwV38mjtnI9fgdODk2Y/UPiej11xgx4CV8PaB5uMB1q6c4oqikqrqA3YdCCHbrSGz0azw31mpNsv0IXK3zuHvyDVi9AHzu6Y7YqmDpO27wzlsNRk1U2ACiwv6DLKv/QwgY1Q6/4W0oOpWENr8CG29nPLpG/C2WZY000sj/Dt3bQpfW1myYpRVWF/zm4X+fZdlvodfryc7OZt68eYwZM+YvEcv+U8nKyuLgwYN0794dvV7PsmXLyMjI4PHHH/93N62Rv5Dojp2IbNeezIR4qsvLcVCrCYqK/j+1LPtfoba2loyMDD744AOmT5/eKJb9BfwpwaxFixYcO3aM1q1bN9g+duxYLBbLAzEr/iOQScFOhVRyz1de5mwPtkrQ6GjRJIIWbeqWnuxAqKqlb//erN+3jTKtidJaM8W1Jdzp04q16VoEEcT73O61RjPFogMfXzrPwBbNWC+rpHr9AQDaBnrwOnYgioQq72WnqdXo8ahVg7QAM3J8I5sxdeAofkrKJPKtaRzu3ZdKhQIBaJObxyVfH2YOHE6wjz/BwU3J2ToaqdYJs0TATmZ9E7DIZFZrun8g1M1Ck8RbNGkWilAX9F9h0OBv70nv7t1plR+LptyCp6MHF7NusnzJEtAYGPzcBEY174PJNpjSgjSyS0wYS/QEXhOpdQaN2pqZRK5QUlVZicVi5vSVcwzq1AuLAFs27aOsopK88n3UhnQntaSGrMxkPh41D4VKjvY9e46JJ3ETnDBXnMT2ahxVeasJ9FJSKsqwSEVEsw8V9qGoa9N4s1ZBjSgg1Brx9rXnlNJCFCAg0EobTtt2Y7hurqLlzTAQrTFPgvr14FPJKuTpu1FKbOmU3h79ghSiaoYgVShIDr2AaaAPNrUB3Ik0MXDDcTpqywls5cvgy30Jy3PgeloFe8nHvlzOj026MjPXlrC01pgEHeXSIiJ07dClatiQ+QaGGhmeliCuD7rCUdX3VF+5Q+eaUfTWjQLdKAyxeuwDHbjl4cFR+xakuECHkCKEzwR6XBpHs+KunHbcAWYN1aX5CIjcyU1HJpEQ4O6MxSWQETOf5/Wt33Pb2wROkIyFjOpc9MlneKRpZ8arA/lAHc1r5bfoFNiSNgFtOHvEmhRAIZHTM9idYSXnMSIyVtmUq0ZrFHSJUsBia4YKaOnVlNemjGP93sO0ahLGgscnUlWr4YXN73Lg8kW4I8OiFEksukMn3xheaDWSEIsPg2/NBcA1wJ9zSQkcrouP9+3NC5z92Opu8vmosVzeYc1I++Mb8xg+9zXGvP+udbBW65Av2MWGoDlkzQ0joOPdJeH5QErd33MgtIPewQgE04UuXJLN5sLpQ4x8fDo2tg0DegOc0sP7209RmW9NbHFg5/dExrap3+8XWBdQ2aJBLFxDbclW3j8Pe7fD15ua0T4skuySYmo7DOTilysRdZ15Y5gvokUALgM72PjWu9j1akX3OsHqdJEWk8wWqVHKy7l7ONPKj+8Ln8XhYh79mpuZUL6Aca6r+CDEGuy5oJstG3e/QXTUBV4JbE+uciQBPtb+U473Iif/Zbw9ozhxCa4lWb9D2OTAV02S8CmtppnUk0H3TgnoBpxBb7BFp3dgSN8ZONS7dH5Ddu4X9Y8Li6gkO/sc7jU3EHQbqI0chU69nJvGEhL6b2Pj5TL2x7TG0dSMxOyJBAUkIZd1xmjSEtG0L5VVudxOO1L/zSmmSjwCB5HlOBBR3YHPS8eRe7ML53Kv0L3be6Q7RaK63AIAUWqm2K+I1j88gkSU4OIOqW1GUW024qmwIe7WdjKzL+DuEcjV9OVANVl5l2kdC0X3WRE4q8dQpblGeWU2TqpsHBU6VErrOIu+L152tQaOX4LHf9+j6t+GyWRCJvtTP93/cUikErx6RP1+wUYaaaSRP4FUAq0if7/c383mzZuZMmUKLVq0qM+W+r+KRCJh3bp1zJkzB1EUiYmJ4fDhww/EEWzkPx+JVEpIs9h/dzP+6/n4449ZuHAh3bp144033vh3N+e/gj/11v3ss8/+ahaXu3EpVqxY8a+36v8SQQBvF4aOHcRaWzkFpeXM6NYZCqzBq0VR5MrTEyg9sBu9vQuBg5/GP6wtr46aRsv3FqM3i8hlsDH5Fub7hLLW5TJuOZrIrTJhEisA2Bd3k5llN7m7mGUxVNPN35vgy5e5YPHlYiV09rfD00GF1kfDNYde3JHJWDR4NI5NwpkdGsmGj12Q1s1kJRIpfV94nZublpNVmEuwjz+6yiqUmbW8VelLgVKkuV7ObTcZeqMRndODATQ7Zm8lLDWFkuI73BkxCuHyJaq6dqNv7150ibZaYNy6nYVzdy82bdoAldbgS5cuXWB4TE92nUmtT4/r6OjI4BeHYSsoqennxVq/FGokZoIvakhbvp+tx/fhEx5KcNNwamqtFngykxxEcJTJeNljFk6RZlLPneTOsIu0Se5K8LXe7Nv/PPqiNPRe4DyiCe3FdCTJ57Eg4CR8yimiqNArkZkNiECMPprLCZcJCnDGVqmhqSmKLuPHMGWqA6wHywoRiV4gb28RVXIHqiRZrBLWYS+k07zSOo4tuhpC8ueR830VNlGv0nN1NG6lOwDo61bABE8jPdwv8dStUACUEglmQaRGZs2AIhNVZNgU8KZkC86iDMt1DWITVX2/mywGDBIdt1zOURkiR4GEgEl+tG/3KHH7QFYLObeu8/nKeTgYXXmlcC22RDC07Bk+v/YCdmoPaiuKadK8BV3d5DT1csGiskfi4Yba3h5094IAvd1kGH279KedTyRcO8kAW096O/ih6zkGW0cn4srT+CX1LHeqijhkLsZYd9yVzEQcRBPV4TZE2rlRYFODptaIWKZh3OH3kWRI2Hv9AgeLLrIscjjHVxxG4u6IWSpALWhydZhjzUilUga1ac/8cU+w8KdNrDq0j74tWuPr6kpuaSmVpWUcW78Rz2ZdqXbtiijsQhCtAvKlbT/fE8x2xsGhBKRASLAHdJVhMZs5sdYbmeIWXZ70QRBCHxjjUwa/zSNuLyBtJ+WDN58mMCSCx6feC175ZiXktB+M+4bF2JgNdO9/XyyZGgPNfWPp0X8kxw/swN0niuJ8qzlSUT7AHDbNGcHs5FFE+gdQWXyHWROvU1yYRIhzW2zl1uCg8loN2vv06sF+dqzuV0hprTvN12cyaG0chzqkII8YyeuaThSKoBXvpZdvNXwvLQbt52vtu0gl4HI3YQkQ3qQvEU3nABAWBPa2VdTUOqKQ6+hbtph5X83nB+DzV6FtfUzpRWj149h60Jem4a7073Ffhxmr6BylICXDQFmVCp3fy9SWuCF16EbsI1GkFr6EziSnOLAArcoBrcnA/PTrHKjIRbBImJXpCAIolQ54e0bz3KT9pGSc4Eb8DoIDO7N+6wR8LSZ8Sg5xoiSVH3NUxPreQiJAu0ufcXxeGcuz4bwB7Bw+4pbRx2r+KFpFsLISGX6eMsrKs1i9+VFE0YJUdhSd0Sr8Hjl/ha7tGgpmKdn+nLzugau6OSXlGdwpmY7JZHWR7dIS3pgKi9eBSgntmz0whB7gRuIvHD75Mc0ihtK3+2v127Py4al5VpfbxwfBs2PvHfP5ejgTBxOHwdAeD1T5u4iiyMujnuLYz/t54qXpvPzpO3++kkYaaaSRRv7tTJo0iUmTJv3l9b7zzju88847/zH1Avj7+3PmzJm/pe5GGvlf5O+8X/9X+VOC2ciRIx8amPQujz322N8W0PXvJjkrhzeWrUOj09HJzYOuEdZYUrrCfMr3/IwEsKkoouD7RWhazuRWlQN6s3VS72Rvx5ODe/PmsnUAuOsl+OikXFFb3TNzq0246QWrR1thPndlk3wUnMiu5rhnXWoeg4XT2Ro6+dlys1kk5W6uAFTG38CxSTjG6irazvqKsKxEijs0oalfEIF+gbg3DWfDvu2cj7+GPqGYJnlRhMa6EnKzlOKODgTU2OK+p5Cr/UWq/WSYLfdizOV5+xCWmoKzUsWj3/1AUVEha9eupLyiDJPZhESQcP3maX7avZkm/hqu1R0XbO+JwWBApbLBaDRiZ2fPhx9+jkqlokZvZEXFVWoldeff1oHON7sikUgxSQXsnOyZOu8lFq4/yHWVFwhQZTZhW+2CWFVMdslFOu6ei0qjJjEyAcI7cVWexrmnBUQxHfV264xWgoikvJZ1AdWcd+iKV1kOA0wxtA3PIzzQHpe8MELEyUhehoKCMj5ftBAbW3tGmZ8hBgdek8+jRrCmGJTUlPKT7w6CbLojy7EnwWElAYKUdkpPkiRZ+CWOhqgxiIbj6G2d+U7yPQCpyiyWOQhkd8rgTtwa1tvvxM4ykEJlPsvst7HFZDX3GbnNkfEvD8HbLxJJpZE7KUewER0441vAVp9vsLeo2Hr1FdyjwKUYxq0BuTGWHc69uGF7Aq1Qg41oT548HfegSCRSGQ5NfVCGOiOXADU6JLoa0OtZ9OQUTNl53KnO56mxTzI4pmv99b4eH8eRtDRGB/qwc8cmTrmU0s4rgo+7T+exXe+TbKolWhJF5e1zRPycRsGUaHCBeLGErvl+ZJy5SYG8HFo7YikFELh45jafZ2wlx8u1/ntkUimzVnzN0j0/06xfIP2D2gICZov1nvn86FY6hEWy7dxpvH8+yKo1W7Go3MkZkUibV/qgPvscOfGJDH7lxXs3aZgnSASwiKQ5eVGQAKW7l/Lja8cBORbzW3Sf3DAttT5fy8Uex7BozZT6FLBTZs2UGRbVguZtuvDZglkYezyJKboTxj357HG14G6jIiXxBjMmDUZhEPly+Od8OP5z8t5cjJvHzxzY+QrnT1l47CmATGRSKVUFO9h5IxFtrh85WQB6XCI0xMaYue3akun9kxiguncdnKUyXnH1Jc8PVk7txbQNx2nl68AZRSfyvgdZd9juPoFptgJi1mnW5Qxmv3oYjxgBdwv2thMAORCGINxzhfd2hzULTnP66kGahZ0B7plPfVkKqUUw1wEG28Dq7bH8sK+uPQ4Q3nYbUv0WfOa7kZg8gMzog9xRR7DTOwSe/BG5UcHzzntwPTKF+MzuOFdepMjQAbNEBlnnEdV+YBFJTKrAzdALJ5s9xCftwd+nJcEB7bl6W01uqSNqRz/KKjIRpbE4Z4UQ5FOKVGIEJPToNBuAZ8ZY/2q1zzHw5jauDc7kwK4mlFfBh6th2ZsgkymRSRUYTTpcnNVIBCOCYGBor1hKKuAfQ2n6eSpJSIvjeg6QA5fioWNzyC4AhRx++tSaNVP5EMv1n/bDqWswbgB0bgk/7XyOiqpc0rPO4Oo2EW83F9KunmLjyQD0Bqtou2nPPcEsvxi2WcO2sWrbPyeYlReXcuzn/QBsX7GxUTBrpJFGGmmkkUYaaaSRv5k/JZiVl5ezceNGJk6c+ECw38rKStavX//Qff8J7Dp1kYJSq1XZ5qtxdG0WCQo5pYVGKm3dcaqLwyMi47KqiILcIlp6qtDKnJjZsQeDnIJ5T6FAazCglYrEVso57mbAJIhoZVCiFHkz2Z7pwT3xN1fy1p0r+KekIAZZRQapaMEsSKg2WDiSqcEj2gMpZgK8gyi9eY3yk0cInPwsoUPacHDQXBTmfng/EcE32zeQnZsNQPKddPwzRC4NBb1tKba91VS+14U2na1WgQMdWuE4tRM//bSJ8grrucb27odvRBSBz81EJpORUllGUkYqGRlp/HzyMDKpBKPJCKKE1Ix7bqN3biUz/8prmHRVAGg0NeTm5tCkSVMGrzjBzdpiRr6iQJCAvUHFhxmOdMrfz7rzKdS6XSeiOgEPNDiYbanFhlickczRU1FShW1+DDYaa7/I8p1Z5zwEQ/+DSClCEGB3CyMyo4H2cc+gtzRnSGUBGz0zKFSqiSiopiowAYAyrzjarrXhxzAJmrRdjLoxDD8/Of4zfqDqQhi6y9bYX1KZFPc3OxJ8MpM7Q4+zd+ceqvIrUYoyRnjaUeOSg86lDNXcgQiSgai0OkyvP4sMcAoupudLuwHYFDiTN9ev4K2wt7lUm8+NWk19f9kjIeVsEDmRnWhnPkqf7AxKmo3ghJCDKJRSLdWRe0pHGwl0PQ2KurhhUbrOJKvjuNLpOB6RgeTapGCTa49eq0PR3BGTTOSUKOCb7IksuQko7LimOgA3L3MyWsfuPe+yTfUeQ5p2pEZbS/dfDlKp0/H29dvUmEygFtkSeYLx8ta8bP8mglsQZeWpFP28lWtBwRhRWUe93kTV9TPYe8potSeLvbatqLCts4AyCOwtK+SuP3LbFiFciksHIC03j7QLOfyccoYdvRfU98fppFu8OngsnANHrfU6CLoSTIYcvs9aiirUkx9XLqNjRBS3zl9m78mDeAQHMOmnZ7idZmSfzhdSQJJ9L/GAvlakPC+P7JvxRPXsjkyhwKwxY9FZlROV2RZkVvN/R2cXju7byo5N3yJuWUvf5xbwVJtenN0VT5cRA3hr5UoqinMB2JFymNkxMfh0iQSWMnSMmaFjwJo44GmSUg+x5/B8BvQAmZMHdvYO6HU6DIlJ9H5NQR+VLZtelPONegGT3p7DpYPH2XbagyvFVh/Jyqdi+G5lDA4iqF8HmcRE02wZkdHg90gZTqEr+Dp0BbtPbKFvx9HAR8CbdWc9C2iYxdPHI4UxA5YC7lTXbubxQWBwhE/DADPMq4KuSpDf9/SvtKvAWzoOuZ0J3rDj6Lu2mCU6fCvjsK01orGXYlAYqPAqYMrYl9l9aB4SqYyAIzMRBQnNWkzgqj4Gt7OxVOcHU80Emvk/hrOLNUD+ym0H+GHfIxiUOmzEwwQ5vcT8mfOxAMdOzeJGgvXZonYK4Ep1KcEqe1zkSmxt1AxpN5WWgXBkrzXkpEPdsHN08GLm1GOkZZ2mXYsnmYUcqUSOg53VVXfyCEhIh17twN4GuraGtT/DlQSwt4VgX8gtgglvgtEESoWZZa9nER4ShEQiITMXjl2CqCawdFPdcy8Pdn4Jvt7NqajKpcb4DjM/8sJ4ejqGjF+Q2qhQDr2KoFTj4mQBJCRevYGzuxchfh6k50CbGP4p1O6u9Bjen+M7DzByamNsl0YaaaSRRhpppJFGGvm7+VOC2bJly7hx4wYzZsx4YJ+TkxOnTp2iqqqKuXPn/mUN/L9iaNd2fLphGxqtjsd6dgYPNcU6LdcdLEiCniKrJIWAGFsih44g+8YNCrSptPS2Y2qHkZR9fopzd07QtpsnJwuzqZGJrA6qpVmVlDgXMyCiNgj410qQikou2bnxnXsoZ528iXKQ4VWVw8iMVD4IakueRIkoinjcyaR5Sio3fUMxv/sBMYF+yKQydv7yIytiozh96w5ur88jzEYkU6KimauKyHQZen8V1c5WAcJQUYGw8AT60ipEN7guS0S2LYfy6gok09uBvxPnfsnAq/1oXJ2dsdMbUZdr6dmvJ2d6ygEwfn4GCowgWKi+F1uesLAI8pJOoHOQkF1mnexa6izX4gsqKdfATwv0TOcw3pdKqQzqh1kUOKVqTnRpOhJNIaYsA60tp2nVYzhvvNEXaVUVn6/6noQbGbwn64Cv6MemzGR6uVaw72goji4KpGVNGLduLenO+zgzsj0/TN2PtqiKJ5Z+g1vaJc5oY6lJjaBZsA2Bib2pUGgZsN4OpW44NhYba0LElDJUbZLxzAqmzO8czTqMwNROgU95NTmZR6iusIoweiQ4ZMwC2SnKvJ7Fs+JdpC6OXEsx8PSFYYzprOSja8V0t+xBkIjITUo89J70bf8C81X7ya7R8NyN27S1UeKRVUrN+eUgVRDvKrLFvhXPpD3JO0IlKU6LkBk1RJXY4vydhYuuGwniSQQE9FFtCfOZS4J5Gwm5t3CKCaTIzwYKRVyNIjKZgMpgi+T70SBKoDOICgsZTmZKbK2pMtfc3Ef/gDa8PvMdqrU6ELCKZQDlVout701XmHr2NgfbeHNHn4K8f3OMVWa4LeJtKaflhUwECxydGkW5tx0VPkq4KYLJ6uZbWVULCgEhRiTLoQQhQkRMwZooQAS1ygEftdu9AVQFRoOZ29+so+RqHOdWraPSYyAFdqkUpydDLXyz7xc6RkSx4fjPLBbOYskAQtS0ixzMXVPH9s+8hI+LGblSSfsxj/B6TGuqiopo+8hIZm/djG1Te2LWtaP8RDHezwYiTYaA4KaIZfu4+OUOnGtkVNgbaKOpYvNr74IIyVeuU9q6G7HDtNg4qinWO3DKcgO3GxrCY0YjkSwG2gBbABWODt706CgwpJ8IFNG9e1feaFnKpHeT8IuuZcPCYjITUgHYv+5HDm/aTo7bM+ijoKYtSOuewhHlt/hy8VA8XHL5YNUaDh55ggtNC+jX2bo/ulMBJikoKbrvyWWNu7Zz/+tcjNtAj44z6dt9PVZ33CIcbCt4bhxUWWBjMRRaoNgCXXL1jG1bzUxHN5wdwClcSZXFGVdpCfoaNdGF4RQ4HEFriaTprY4kxiQj1ykJcQokJDaCmVOPUKutYP2WCWh1FTzaay7PuTZhUQbstZ4qN7M388rn8MEsMJtr0TiXY1ehxkwTcssXsu/Iy4wc+Altmg8nJX0PTo4+rLELZFXcbnwUNtxsNRwXuTXom68nPPPIPpKzBJ4f3xWwxqILDuhAcECHhz7Tp4yC01dhxVZoGQHd2li3dW0FbmpwcYKrCVaxDEAiXuOrNW1pGfMoUx7/iZc+sbp1ioYqJIIZUa4m2M9a1iDdyc08Ca7OVj9bY5nVktSs1eEln4zSJZgViz7h2wVLWP72J9g7ObL+4mEEO38CvB/a3N9FEAQ+/3kdRqMRuVz+z1XSSCONNNJII4000kgjjfxh/pRgtm3btt/MhDl9+nTmzJnzHymYhQX6kbt/I5acEsqKyzhx6AwTvl1LdmEJcgQi5FLeTFTj910/BrYI55tFH5BbUUXfDkaMCbmk2Jk4XVADdWHCDG42eHeP4MKlazSplfFqlRe5qnJybSy42MjQt4+lhQhncjQEhzXlG08vnklO4pTaB1mIL3YlldxqFkWbq5d5d/V6nh05kOMXj1FcUYynhwOdbY20PnGShf6tACPFpWZeDu/HSuWF+nOSO0gx5lcheS6GiUPGkF9axOc/rEYZ44uxvXXmV93Tm/Ufr0EURRbPnk+shx+pERYEF6t1jaJ7KKatNzCbzcilYDSDnUrG+PET2fR1Ik5CGfYqExKVG+fPn2XPnl9YPGAA87adwS//DmVGPRkmFaPMJWjkdnRJOIKdrpoaJyl1YaqQGrKxtZOBxB4R0Ao6XpG9zaffLuKFCW2xN3cmISWdjftmUiUzcarpDVqWV9KmWyZaeyPY29BH8hI3TC9Rbgzi+HkdJ6+Zaaq9zHxFMM4V7blrhSMiIjhWc9GSTNTIJJ77di+KC7YU7LjOtb5XAPBu5UNWrgUP70CO6gsJTNLSLOsVXnvjFBnOXhw8pKWy2oWqBDPV6YHcmDeLQR1uM/zCyxx33EgzJ1v8pEr8bJXM9vbhyu0s7p5sbdkpLB7duRTejdEpekYWxZC2dwNfu88mXnmQG6q9lEsL6eTRm8vdVdwIdwVLCKpbDkiM1exLOkugugkSOzlNjwbTvCIEz3RvDgdvIc58FE9NWyI9QukR3J7T4iUqJUb6Bbch504uCZkpRChUWJQqnHztuZyVg9lDrH8KHPKvJbsmFTRYxTIAs4BdmR6ZwULcwEC0Tgq0KiXECWAChUyGoU58U4lydBo9RbYV4AZUgEOlHcvGv0Bn/2iaqH1p0T6EuAvpgMDqffv4bOKzXK1K5tKU5jzbog3jJS50fNWBqloNQ9pahZB8RQ2WOlHjl6M/M+mVwUgkYLZAlL8N7d+dD0De7WSqiqxi0vWjh9m06jMen/oSPuMD8RkfCMCwllOAd5kTvpD8ZAmuSJizbD2VBTriRWuGxuqKKp5tG8GtOjEqP+kar7z+DgD9hj3OgiXF6LRK5s4Yg4PjTV59z4Zh/YMBq1WdjW0pXcaNJf3yAloMgpBYDef3glyhICAyFEEiwatsA/GT+6J3UCAHXrIx45PzDb7RmQAM6baGg2ef4Pjl1+nXuZpttba8WjmNpjI44D4fa+pSZ2AiWl0Vh05+BMDuw/Po230h8CrQFogGwFECS51hbF1cr3KZkuUyJeuDkugZHgHY8F3NWWTCMTr7DUPzpBc3t5VgtjjT3kaG/eZYVAqIeV+kyKDFQ2GDrY0zz0z4pcFzdNJw2Hvq3mdRhIxcmDY6knj7w1zf1x+51hE75Wkqq/L44Mvm2Nq48ObMG6id/Wl+1VpfnkFLuq66XjA7dmYpp8/OAmDrL8OYPmFn/XdotHAt0Rq8X/0Pxs3Lf4LMPEjPgSE9IDTAGuftLi0joVd7OHXFgL/amks2/vYeSiqgvKqukCCh5pdeRD+zmw9newGw/YgMs8UqqIUGgvLJRRhvfEZoaz+Cuxtp1WwE9rYyrp+5CEBNZRXZyUl0G+LPv0qjWNZII4000kgjjTTSSCP/N/wpwSwtLY3Q0AeDat8lNDSUtLS0f7lR/y4EQaCsrJxmr8ynqLK6frsRkZtOJq4m5zNAZ+B4fi5xuVaXxtWnz1LW1kJOrQbLfTH1KzS1/DhrOiuOnOS51RtJ1htorpGxKN6B1CESLHbW0P8jw50QAI3elivRscw+sourqtak1fXz5dgW2KjVTF2xkf5B94LrCBYLTfTV9a6c9s52rFSlotEpsLExoHJ3IsYlgCs1t+jdphN2NrY09Qti7qQXsPVUM1d3Gb1KgKQSxLokAompt+kc24aYWmf2q3OxAH1DoyhqIeLlG0KA2sytm9fp2vcRZDIZHTp0Jv3qblz0KZQVXuFcwiV0qgDaqVRMtM8mryoX0Wzh5WeeolOzZhw7f5HF8RsBsFM5Ed7am+L0UkZ7jwATYKPgxfde4oc1a3G20eDqaMTR2QZFpYy3zW+yQtgFSCiQluNu7kDro76ktCrFLdeWYTd6EezqQqJqJeYyA4KnCnVeKqWmg2SYbGgpa4aAwG7Jfjbv24528AXUYXoURqt/l0dOFLbxfVEblEy0raFJiIbIF1wRJGY23JLzy4c/siwpnpGqIHyadqRLpJnuPatwy0/G211LXpaaTQ7vMS4oiJAOsxAv5aE3iNwuLadGJSfGrynZplScIqdT6+THnI5ZhMVbo9kVyDMoUGRa1YW6MSQZv4sK2SDAFSRSDM4tKK+6yTnbLEy6XMJsAwjI8STkdihXmp4mMzQDm1o3Uk4dRZddgi02jA7uzLc5R3jpyDcMD+7Kid5VWCQio5SRbNdfwcUVKu0kmEURqSgw2T2M05RypLQUUSparcOcRFK7eJE6zOve2KuWINYJWHfFMgCT0gz38hrg6+jAqJa9KdSW0W3zbDxsnYmTpYGjAFUCIzt0oUxbxRO7F2EWLZzIvk7+81u5s3oTWoOeAkMZNzMTaJFQwxFTGWa5hMiyItY+NxO3wACGvPoyAGeuXaOypppurdsy+r23+eXrL8kUC1m6aA5hUS1o06nXP9zpWbiHQH4y2LnYEtWmA8lXEuv3dh89hGbBPiRdk2EymajIz6zfd/3SKcCNM8e2cObobr7eLHIv8aYa6yN1FaPf7UhN2QtYzPF0HhpISAyo7GxxclVT/dyTmCyQ5CQj3QK2AjRLj+NabhBFZV64OhXh7Z7Ovm9cMJi+Z+n3y/ikOyCFRBPoRTVKYVl9m1RKGU2CupKWeYrosEHAK8AMGlwMoJMSxtnAjxozokSKpKKEyswECI8AYKJ9KGB97iQ4/z/2zjs8inLt/5/Zmk3vvVcgEAKh915FUJCuoIiC2EEUCyqKnWIDRKlSpQgI0juhhBJqSEjvvW6Szdb5/TEhIYJ6PMfzvu/5nXyuK1d2Z56ZeeaZ2d2Z79z39wazRYoIbB0GT48GD1cLkwoPcjq5iGc8w/kurCu/xcsNOrWGuJvg5gRtwmBkP7C26sCyke15NewqeTdv8JhrCYnX25NT/ix2ugPkFd7EydGP571aMDPlPGZELmtL6WDnSl4xHD5b0bCN0oqMJtt85TNISJWixrZ+3tSDrE24JJi5O8M9FnsNCAIsmAWgYse+vly+XkS/7q+wdb8UeWbKO4Hx+mJk9sFkldjw8+GbTHioNYO6wv4zUrTaxy8DdK//a8qz782horScoBahdB3U+/4ONNNMM80000wzzTTTTDP/Z/lLgplcLicvLw9/f/8Hzs/Ly0Mmkz1w3n8KaXlFDWKZl5MjVNWRb67Dzihw0dFIcnomAwMCCff1IquohBO3kzBZLGAF7vZ2VNbq0JtMPNW3JzKZjAA3F9pVKGiZVodJISMhRE6lvy3OZdUAyARJIQl0VANqTg95FDdtNUq5HKPZjHePQfwUm0BBVQ1avRw7tRzBoMWpKp7MkBDeKE7gprMv7bq2JyM/HY0GLl6M4NcV4/DzsOPIxTNcvH2NloGhVGir8Hb1ADO8dacF87cvY2LvkezUZKLT1bJ670+E+wcT7ujMzPwIlnsmcej2ZQwaHSSd4uHoETzx/MKGsSovSOdWppayW+cBcJCpqbPyR6VSU1cnVdMU5DJatJFuwjtFtUFjo0JXY8BgqeTpoLkEnw2BTYALHOtSQHl1DSGOiYgWM5cOfIPPZ4+Rtieewph0enxlIcPVE5/STGZX9CQkKxjHWDlRhf7sts/DqjycRc6LWdX/CDe27yJJdKF120AczMkUXG5DCaVky3KZV/EWv+zaQ9xHb3Et7ChRyf3IcM6m9/nxAByyLwCxgq9lUtU9lZWKbt1KMLq1QZ2YQoa8Gm2ZCh+bOpzdpGqfHt7W2Gg9cHnmKVSBYeDlS9myQhwKKym0TeSOWIO3bzi2KRsIqOiGU6uOdKqUot68jaHYmZyplpcjIkWi1VVV0NHhEuWiLRnaGhycQnHw785M4FjVSka07UjogCD4Fq5aSdWF1NZ2OLh6IACiIOdWjRYBGTqzni0pR7hbnjXLQQ9FUK6BycZISkzVPOHkwnhPP4wWCy1zjuEd483plDtQAf5Zktiyz0OJzmLG5GQBewGVXoVBb6w/G0RMrUySD730ltz8ar6+sweyLeAIedWlkiAYKuKQaUNxZQV6vRFnjT3FtRW4axz5+vJOevlFsywriZXHPkduFul/6AZ9c2vxb9sGJx85R5ZLlXi9W7bAtk0kR86fBcBgMPDI2/O4XZPG7a2rGrzK7seJl7Y78OOr1hxZXciz0a0wR7jw5JPvEhwRialnTx6pgMDBk5hdl4sq+zq2Zh2VZaV4m21Z//Kz9H7+FezsHbl1tZz2nRs+EcAKQBKSbJ2dAcno3ytIavHNxCc4t/kn3IODWDNyOIfR0Ik69lw4B2hYuX0+DlYGXnjiZQCKi5bw6+mhOJdDdSd4NRjUvyl2q9MLjB91FIU8Exen+g39Riy7yzkDiDI5AANObyHm8WeazLdYwCLC4O5QWgHaGpgyEmw0kKvXcTpZiuDbVpLxQMFMEOCLOVChhVwNvFUFbxngC2tQCzK+imwP9dV3x+yrpaTGmtLaGbi5Sue9jVyBub5K66GKPJ71juCFj6CwdD5utk6Eer7PxEe+b7LNzDzpf0k5vPWVtP27vDYVRvYFb3ews+EPGT18CaOHLwHAeEaapvTpTUjLRDIqnsUiCvy4V2TCQ/DWM/Dy49K4/BFtu3Zg06WDf9yomWaaaaaZZppppplmmvk/yV9St9q1a8euXbt+d/7PP/9Mu3bt/tU+/e+gM0BaPp1Cg3huUF/aBfozxsqHvhkwLE+FVimi7+FHa2cXPOzsSFz0IftefwmTudEIv6hKi6nex6uljyfbzl/i8407Gehly63+Aicng7wjFNwpITkxn85nz6LS6xtSEwEuapyJ+mwe6QZHEqpUDO87jNSvPuGHZx7HViUdLlFhzdDEHMpqteQO6EnvCA8MV8/j6+aFRq0hpPUtXv1xFaIoEhoQTJmpjheXvMeBn2IRzSKiCDLkfPT8e0T26IROJ3l2iYgYzVLE0E+uGVhkYBreCtlTMQiv9WR70qUmQ5ahtedWgQyTXLoTDWndn1efmkXSzRsUlUkReFgr2WKfSqa6moOKHPzWP4x7ZwesHeUIjcFJ7C/No/+y44xdfZ6P1kTy2uIYbpTYsaR0Pt4Z4fRd+wQPuQbQKvsaDrUVvGvzPU+EnSOui4mvWyYytkUsD7c6xcUqHXsTbHF3GY9g2w69UsEPaV0QELDHjhmmp2gjRvJS7QsoKm3Y3/Y4/QYc4xvbioYxaFvlSdvYFoS+7EnN+ir6/nyT5EQLL3SL4VJuCJcvOXLqgDUHLrhSZ+eEiEDLO2WMS7/J9bfe4vatq/Tf8QZfhKylIKIQEZHaKi22lXYAlKhvsPODJNZbpVPnaOSU2zZ8zFEM1k/D1eRLa11fzqXlklN4g91HXmTHjmno7zTedD9q05V2Ue2wi3Agc1oCRSWp5FQWkFeay+TnX6Tv6IdQd52FmzKmQYBTaw0Nyztr7Fg/bB5uBgcuCDm0MrrgJ5Mi7QSgvX0ApxV3oJUIXUWynOFXPxv2j1qHR6o/wiU5uIsYOuhBKdavVYBapEzBJAH5JQtoBWTIsNM4Sk300NO6DTHmCCpLa/n1chxv/bqKNztPZNmAV6kxmnjx6Dd03fQSGzKuAmCWC5T52IJoYdqPq/EIDWnYD1tnJ6zU6ob3VlaSSDT7va958+PvWbbpOOGtoqXjKt7t5x1gMVY2Jdw+XoTCBPZaGdV5RcReP8prZj/6b7/FtZ07OGFRkOXXgnkfreSHHWcZGNyaeauvMHnRSswVS9l+PJneA5OAmfd8Ku45qYGrJ85y8+zFhvfxqZnc/nYdF8ZMQVOYx7O2EKVR4uIojZGbpzfJ150pLvXCbJZRmNGRUf3A/iKMOwfP/SZKqqQCJsyFx+YoORoXiqxeDPs9BtQPV4Aczj78PD0qVCzTwjfa3ZzLeZpHXqpl6Ey4fgceHwHPjW8UhbxV1jzhHoKdXMlrvr/vXC+TSf5gS6sh3gi76uBw3f3t7G2lc04pV3D5thQW9pCzL/0dvQi1suNVn0h+OSEJYQDF1S/Qo0cJgX6dmqxnzpTG1xdvNn393nK4lSpVv/wrDO0B370LqxcIfDF/HFbKLAACPRMa2vyZWNZMM80000wzzTTTTDPN/GfzlwSz559/nkWLFvHNN99gNpsbppvNZr7++muWLFnCrFmz/vZO/lXyNq7n+hPjqaiPPAFAp4eGaJgHoK0Fi0hucQHT+8Sw6b3ZLC9IYJNfHQXWItmvvEHsgnlYqepDaDQq+rSK4PWRQ2nt59OwGrNFujF/f/sv7H5rDk9d2o3CJo9yPwFBkNI+I1zUjHBRUFSuY1NCJQcSSjiRWc2BVC2n7uSSfvImWQXZ1NVWopFbKKuuYfel61TpJfFDVl2Lewk8lJlBj3PJhJ68RAuVDQM6dUen1+GsUVBUmEbsrRu4RAQTHBxKbZ0OqzA5glzqh6eHJ5VWdSxQnkA5ug1uXp6o1VZ8sfE7rt65Ravs+rwmo3ScBZlAh67RTYZMbeMEgpwSl8Gowsfz2PjFtPYMZM7EZ/nZpg+HNJ3I7zuY85py3i07wt5FK6ncHEfk8w8zbdoM1lb+wFbPjZxufYKcGEm0s6TKOHXenZvJTnwX15Z2F56m462HCMvqyJiMcY3j7FBGn36+lFzQ840irWH6tYhTPN3iJGsDjRT4C4SUlKKpd/XeJztIQb0vlSjCguVxzJj2Gt+91IEp8xypnVaJUJ8T+UNxKvO+zGLbVBXn99Vy7koNb3+/k5adGgUbV28LWp8Iwve9jE/cj2j1D+FlrOOt+adIXRGCZ7UPfi29kSlkCGoBIyYEUUCTEs6nebeZcvo8w8yncHjdDUVvaxI63cY+Kox8h2iyeIQjtW0Z6tyS6cFtcS06TWBpPD65VxmZeaahD7H7fybXUEGOtpjSsny+f/t1bpw+RoXeGrWs8Y4+JL4EVa0RwSIyNrgzWZevUKSu5I68nF3WKXyUmcrOG8m8erOUn68m0u+8ghcuWtE5TwG28FbodNYcSCW3MAvRJEKKAFU0/QaRA1kCFAuY9QrwtODtqCS0MoaQ8kC4LHD60C2y0qUoJbmXwJqcA7xyfBnv/RJHan2VWr2pDpvwh1G5tyHUbM2wygK6DfXBNcCfCZ8uZPoPy3nj0F4ienQnwNubyQ89zEO9+zKwSzfpvMzV8nBNBNEuUqrh6fUbmGrlwLyIUJK/fhN9oRsAHq0l9cmoEDEqRZx7juFCqR5RUGAyaDAf30W7e+yiIvtb4xkKMjnY+RzHwckF/+BwYCnwMbAIeLah/Ynt+/j+rY9Z/toCLh05RV2tDsuQR3GpM5A7azbXfKRzSS6X8/SjjzHsoUdZ3H44l+SDmf34czw1bhFa5fvMGAsn18BHL0kRXPdyJ0OKBBMECyrlUmAhoOP3eM8BzrrBdBuoFiFInshWXTlTbSaTecOe0kprdHVw9Pz9ywqCwLqIHlR1m8g8vza/u427uP2OdieKIinpp5j3ZA4924PBBAtXwoFYsFeoONJmEMkdH6X0ijufrpa86u5y93WVtoBVm8ayccc0FPLGarR3Tfnr9DB3MRy7AEvWw9rd/GUiQyR/Mi83JzZ8IufDmUf48q2RDfNP7DnIZy+9TXpi8l9feTN/jChCrV76Xa7VS+//zRQUFPDCCy8QHByMWq3Gz8+PESNGcPTo0YY2gYGBCIKAIAhoNBoCAwMZO3Ysx44du299Fy9epH///jg6OuLk5MSgQYO4evXq39LX9957r6Efv/eXkZHxu8vv2LGDPn364ODggK2tLVFRUSxYsICyMsnkcO3atQ3rkcvlODk50blzZxYsWEBlZeWf9sXT07NJm9/r4+eff/63jMddUlJSePLJJ/H19UWtVhMUFMSECRO4dKnxYd+927exsSEsLIypU6dy+fLlP1yvnZ0djvUPNu5y4sSJB+5XYmJiQ5t7x0cmk+Ht7c2kSZPIzs6+bzu3bt1i7NixuLm5oVarCQsL45133qG2tva+ts38c5jNZq5fucmJw2e4fuVmk3uZfwdTp05FEARmzJhx37znnnsOQRCYOnVqk+lnz55FLpczZMiQ+5bJyMhAEASuXr36L38PNNPM/zQW0UJBRR7pRSkUVORhuTdi5G/mzz4bv/3cNdPMH/GXUjJHjx7N3LlzefHFF3nrrbcIDg5GEARSU1Oprq7mtddeY8yYMf+uvv5D6PPzufXMVBBFqi7F0SMhDSqqoaTewdnHFTQqKfeouFK6A3NzxKJRkZOcwgdrvsRssRDcoi2m+ot0m2hf7NvccwHo5gD21ghGM14+nrQsL2f22IfxtbLmelY2sUkpnDtzminF0o2UzeVq8rwlUU1nsnAwU8deix0efq15rCiN6JpSjgS15IzGlaldo3h62Cj8XJz58eBuhn3yJTdyi2np7UlqoRY3azkjUqVUQVGU45d5GbDgcSgPnxdeR6lQYDSZsKrSkv7SFNLeeZ8TZyUX7jPXLtLZvz3OCmdUPtWEaRVMqQ3h++EW+gT2YPsXy9Hr69h//iTzwp8jd+NP3KnKQz69IzKZnKEd2kN+mSQ+ujowfOBQrKr1WKnUtAnya4j2sbe1p0auoVpujaZARed8E1mHk0EEIaGYZ8Z2xMZPwU2H8xx0+xWVSsVX3X4guUJLik81+07kYqgT0QSoGNh2GOJeEcEsEGAK4HHLeA46HsLX2puiEgsf+SZw4GYfdrhmc7t3OnlDjFguu3FwSC+unthF4sVz7Gx5lmNRVWQes+an3J2EisEMMvWnZ143Fs38ij6T2xNzKRpSG9WR86KU52UWBUz111N6g5nS4ARGL7pIJ2tndIGVJGUG8XjBdADy6yZy2JDMz6clQWZNtYl5X7rQeURXMtccID+7CFuLH921T6JWHEVvAo1QzO4dqTiqarGytsOvOJip6f0QM2HN0JVYZHJs7F0Y3d4XZ/VpzuRWsc2oIOTnvVwxWGFnsaFtdEfMBhMFN69hqK3mypFDdJ7SEa8Ce3qXvo6yvZn4W68ReewaDoE+yOsucrIgDoIAAVJlFaS6VuBs9iWjwg2FxUJXmRUYoXe2kppWfny26Sc+7d+Vzl3aMv9aIgU6PSSCi8aLYP+2lFbnkWZ7DSpFaaWIWDlAQZGenIrjyAQZiJLaU1xVibuDI1NHD+Gzq5sAKLKKhZrWCDIjX3XrToZBSWxFIIaCGnxfeI2+Q5+gRtTjoLKjz7QnG45TTbWWb999jsL8bNq8+Bxfph2mb4qaH0+EId9wHv2emax74VVMBgNZd3K4vS8Nub4nwXM2I2u9nay47zApYMoLbzLusTGs+TmBQrMCc+Zl3h9iS8A935DRIz7m5tUNBIfBisV5vPM5mIxGdny1Gm05jH7hcZw8GhfYl1/W8PrqlZts+2kv1rduEw4Y7B3Yf/YgZ29dZ9amtXiEhCB4eFNbCpah7ij1b9MtEGLqA7l+L9Pdx10yundxSOKh3q8Tf9NAWuYv9OqykRy7EEot0F99r9B2HD/FI0yWu2MnPMKj1p9RZXEj2xxA93a/sGX/XGrrPBjQpakyl18seXo9qMLj7TT4Yq3Ul7eeafQQs79nFcn3BN7tOjCXo6e/QK2yJSTiOtKJCPfYRgKQmNH42tEOJg6Hh/tK7w+c+IT4m9sA6K6IRhBeQBQhplXjeCnkjRUw03Pv73fC5Wts+noZluAj6Mz5TB69hpiocfc3BLzcffFy9214X5Sbz5xHp2E2m7l0/Cw/Xb9fMGnmn6Ra1/jbfBe5TPrdtf33hPVlZGTQvXt3HB0d+eyzz4iKisJoNHLw4EFmzZrVRABZsGAB06dPx2AwkJGRwYYNGxgwYAAffPBBQ8EjrVbL4MGDGTlyJMuWLcNkMvHuu+8yePBgcnJyHli4Ye3ataxdu5YTJ078aX/nzJnT5Aa8Y8eOPPPMM0yfPr1hmpub2wOXfeutt/j000955ZVX+Oijj/D29iY5OZkVK1bw448/8tJLUnENe3t7kpKSEEWRiooKzp49y8cff8yaNWuIjY3F29u7YZ2RkZEcOXKk4b1c3lQtz8/Pb/J+//79TJs2jdGjR//uPgqCQHp6OoGBgX86HgCXLl2if//+tG7dmu+++44WLVqg1WrZvXs3s2fP5uTJkw1t16xZw5AhQ6irq+POnTusXLmSzp07s3r1ap544okm6zUajUyYMIGePXty9uzZ324WgKSkJOztGyuO/Hbs746PxWIhNTWVWbNmMXbsWM6dO9fQ5vz58wwYMIABAwawb98+PDw8iIuLY/bs2Rw7dozjx4+jUql4EH91rP5biT15npVL11BSXNowzdXNhWdefpLuvR9cbfnvwM/Pjy1btrBkyRI0Guk7rK6ujs2bNz/Q4mb16tW88MIL/PDDD2RlZf2uDc6/8j3QTDP/02SWpHMx9Sy1hsaHnNYqGzqGdCPANegPlvznuPd3Z+vWrcyfP5+kpKSGaXc/i3+GwWD43e/eZv57+EuCGcDChQsZNWoUGzduJDk5GVEU6dWrFxMnTqRTp05/voJ/M3IbGxSOjpjKy1HXi1To77lbM5okwaxKB1opEmPKW5+y4Xgsj3Vqi7VFukh3tJhZ+9xTnEpK5lJSMt3eXsju118l2MNNMvmxiFw9c4WXl60BIDuviLMfvkm/1i14pe9gntOpKM24gItJj1NkWx7p/wjuTu4cvXmbrQlSuEOghxfjb0s3Wn4Fd+g4tiMvPvkUoz7/hptZ2QQojdzIq6R3qwheHtqfUxcvs+TUBTZ4hNFO54G7NgxPTQKldZd5M6g3N17/kDdGDGJC57Ys3voDrn1foFO7npw+H4vZYqG6qpYNX55AG1LG288+iVwlx9ugIaLcjoLBaxAHiCAI1Bmk/CkxqRja2CAqZJIJtymHiBpJOCxJycDkYc+Ajt1QyFUUFSeyJ+4WPdt1wTMsmBVjO7HrRg6BUyrIsQLhxa4Irx1kTJdB2NcCmHhm5ESqjHp8fINZ9dUapvTvTuTD7UgfU01RXh2dV7rCAqTIpXp8B7kh5NZQYyzGNe8GUTon+mg9CHW34qVH09m8WInZGMSP12JZaH8ZEKm1GCn0i0UcrcB2xcMojUo6iTHoFbX0dY/Df3UyFLmDKZwsh3T8g7x4Z7QvUR+r6VvjTEFgHhtMN9lTmU/F+XK2Dg7HHjlkeHDJpZjr1uVE1Tpx0LGMEZkLmSvsxSiCs5UTdSVtydn0niTQAumqCk74LGfekwIlWgfC23kh+kxFUVNObc4xzKWByBDAAi6GlhQrzmItmHBQCwgyAYUznCyw8ObhHEaUxdFjQBuUEQ6IFhFPWWtyzp/H4OpEfrx0c9CyIBrPA8OoXjqUluYaHm5bxb5VS0h3NDcUGLj7/0hmNg+3foQrqcfIMxvxFiHV0Uzq7TwGO7kwzd4C9oGoZXKmnL0CRoFSYwEjej9DmHN7Psp4nBqhEoIsyDUwOk+NgyiwBgM60YK9jzVUQFVNLb0jozjw8yWpeKkngIjCkM4zUS8TXiOybfogzrUNBVFkx6Vktly9wLFgIzPbjWTZoJcB0JaU8MPrs7l8cD96tciBK9spU5rZ7AWvO3jT1mBF0plYdFVVgIiLo4iXq4jCwR/oz8ARag7s2oyDtQ3DHnkCJ5WclMdas/V8D2yC7zCySxUwGZAuOFVqd+bN9KG4MA9nWytWV79A2KAhnNq5DwArmzgmzysHlgMtyBw1muqKGunY7ztEg/IKxBRkULhmFSXAoW9W8PiSz+mggldt4XoUvNYdWv0DxRA375eqOZZXtWTn4YnExq5FFC9wI3Myqx85hwi8Zgsv2t1dYg1QiVyo5FFr6XvIXlZMqvEbHFxP8fOXbyGKHyGTeTRs41oSvPSJFD373nOb6N95GOevO7FwJfh6gLUVJGVIf/07Q++O0nKPaOBnHSgEGHHPdUl27hUA9IZqukUlY7YEoVTCI/2b7lu/jrlcvrKEGkMMw3pOYOKwxnmxVyMaTt62LcP5ah4UlMDA+nselRK+fRsWrZVeP/3o/WM3b8JzaMUEWnlXAHDmwnIS7uynvLKcvMpvcbD35ZXHJQHw5CXJA+2uIKdQKlEolZjNZqysm3Mz/zaqdVBQfv90s0Wa7sm/RTS7G+kRFxeHjU1j/m5kZCRPPfVUk7Z2dnYNEVT+/v706tULLy8v5s+fz5gxY4iIiCApKYny8nIWLFiAn59UGfXdd98lKiqKrKwsQkJC+FewtbXF1ta24b1cLm/Sr98jLi6Ojz76iKVLlzYIYyBFzg0cOJCKioqGafdGinl5edGyZUtGjBhBZGQkc+fOZcOGDQ1tFQrFH277t/N2795N3759CQ4O/of2988QRZGpU6cSFhbG6dOnm3jpRkdHN9lXAEdHx4Y+BQYGMmjQIKZMmcLzzz/PiBEjcHJyamj79ttv06JFC/r37/+7gpm7u/t90Wf3cu/4eHt7M336dF588UWqqqqwt7dHFEWmTZtGy5Yt2blzZ0P/AwICCA8Pp127dixZsoTXX3/9nxqfZiSx7KO3vrhveklxKR+99QVvLpzzbxPN2rdvT1paGjt37mTSpEkA7Ny5Ez8/v/s+AzU1Nfz0009cvHiRgoIC1q5dy/z58x+43n/2e6CZZv6nySxJ5+Ttw/dNrzXUcPL2YXq3HPi3i2b3fg4cHBweGP38IPr06UPr1q1RqVSsX7+eyMhITp48SUJCAnPmzOHUqVPY2NgwaNAglixZgqurVCBLq9UyY8YMdu3ahb29PXPnzmX37t1ER0ezdOnSv3Xfmvmf5y+lZNbW1jJr1ixGjRrFpk2bsLe3Z/369SxduvT/hFgGoLC3p9OJ80R+t4bobXukic62YK0GO+uGi22LQkZ2UR6lVVX8eOwMoiiy49J1BvTsR1R4Kx7rN4xJvbrSwt+H6zkF3Mor5q2NWyitrpTSRDILcbbWoKlXnX1dpAssUW9gzxuprLlxmQWhD+H16QouDZvClGVrefabpXy265cGo//SWh2ivSMAQV164e/uybbt29lz+SppxaWUJRgIsVayZsaTjOzYns9nTGOw2oK7gxX5LVQYbX8lJySYn3sO5rqVFaIIP12Ix9HOgbemPM/gcVNxcXDi0+fmMabPMHxcu/P+MXuS8vKYtegdzly/hK/BhphrnihzdbQ+AX7F1jw75RnOpNwgJTcT9a0yNHoBK4scl9Q6SrVSOsbZ6xfZsWs7aanxXDu7k/OfbKa7VwyeUS3JryhlbCsXxitTEOr00jEwmWnXpj1DuvVtOFYmi5nZc97g5w0H2LvzAO++9hFmk5mgIFs6+7tCAtzWVLLZKVNqr7Tg2cmLMPtgPh75Ji/Z9mGnuS9XnRKxzpdRfcuCuT7rtsagoC4thKHGvljX2aNK8+eh5CdYX72K+fo3UKNGbbKmfZoWV9MdsF8MgH9lkBQJ55rF87oOtBFC6ZPzPH1tp1ChkAQPmbZBfaBDsStfR82iX8RL3LR+AqPTHSb33M/w6HMMCDtLeUY5CUp3rtoGk+nkh5VoIq/6IuayeCJDa8lKyGX30l9pt9abl/e/SJjSlQynOxja6en/fC/ChvamSl5HhVmG1lpDtTyTEfZZyE6p2HG1G2arxpRZhaMV66KMHAjSN/TvhmMaN1obEBEwym0plDkwcOYMWth4IYjgXCswIE1JVLGCquIS1l38AEMHLds7GaluGcSRMNAVGyiqM2Cpj7gsrKuDemN2wkTWlr/H4qwZGC0G0AngA2ZnuOxpwkmQ4ZFrwqaqlpYnrxJuLuLXDxZS4FXMddkdSBNAC2QJmBJqWbntU+qC/LHu3RuVKOBeUkF6ZTH2688TcrGIn5Mb01G/HjeZS6u34pOvRG6CwaG9AAi39iJkaA/4ZhJBHWNwD5ZC6R6a8xJBz67Fd4pUNCC6Yw8OXy1jwy/XuXLwLJeOnEIuE5jYrZpOAZV06RJK27azSLyQBHlalCoVP+w4x/Aeo7G/VcXRFd+TdrYxQkB5TiBtsheHl7zL8tnv8lRxJprnZtD+yUnI673F/PuasP6iG44jH0KhUiHIZLTo2Vhd8RU7WOPcVCzTVlRycvteCjKySc/J4eLNGxiN0onurJKelAtY8Hbv3+BhZlZYscm5P6meKvzkjRU168yjMYlKKk0u6MxvAhHAaNqp1XgrvkUQViOTzeZebqVKWp8oCtxILgFeZ/shSai7kdygBWNtBSH3PAhvqYTXr8Gko+B2T5boyCGfEhrYi56dnyOqZX9emAQzxkrC1r3EXXoaN7tFBLpMpEvrqw1eZhYLxKfMJKX4GEmFF/D3HUybUMl3THHPI6DwAMmH7Os3we8B10hW/n3RB66krtoZkJGQ7s+FK+u4k7qHjIyF7DslpYlu+hXe/loSDc9dk5Z1dndl5fHtvPTp23yxc9X9K2/mryOKUmTZH1FS+benZ5aVlXHgwAFmzZrVRCy7yx8JIXd56aWXEEWR3bslEToiIgJXV1dWrVqFwWBAp9OxatUqIiMjCQgI+Fv7/1fYuHEjtra2PPfccw+c/2f76u7uzqRJk9izZ0+TVLbk5GS8vb0JCgpi/PjxpKWl/e46CgsL2bdvH9OmTfun9uFBXL16lVu3bjF79uwHFp76R47hK6+8glar5fDhxpu6Y8eOsW3bNr799ts/XLZdu3Z4eXnRv39/jh8//odtCwoK2LlzJ3K5vCES7+rVqyQkJPDqq6/e1/+2bdsyYMAANm/e/Kf70MyDMZvNrFy65g/brPxyzb81PfPJJ59kzZrGPqxevfo+MR6kSJiIiAgiIiKYPHkya9asuceDtZlm/vOwiBYupj74YcNdLqad/bemZ/5V1q1bh0KhIDY2lu+++478/Hx69+5NdHQ0ly5d4sCBAxQWFjJ27NiGZV599VViY2PZs2cPhw8f5vTp01y5cuV/cS+a+Tv5SxFm7777LmvXrmXSpEloNBo2bdrEzJkz2bZt27+rf/8UNmHh2ISFN05QKsDJDsyNUTXfb1zFhQvn8Pb0ZnS/7uw4FsuUhwYw8bGJDU+4DUro1CEK5Y/bMJktDGnfDhdHZzCYEEURXxdnTr01mxvZeYzt2QlRFKkFNvgcQl9kJFFm5JzKgaPxlxgSYoeVQkaEs4rtiVJ6aG6Njh19++KoraLToKEMad+FGqOI08lLlNfUEqlVkGwQySgpJdDdldLqGsqNJqzsFdiVF3Ohe3tsqnMweAXgUVdNUY2Jaf16YitX4+veeIeoqLWwL/YoOqOeZ6e2oLJOhyhCXEI8PaI6UO5sIGVRG5yOFGGeFop3y3C8W4bjGdGKfs+9SeWAH+nprWKrjYLtMjk2GmuqarS0axdD3UULN96TvggzI+JZdPB7ysvLEETwuCMS8o01utW9cLaY8Ip25WZVPvt2bMfLxYM72Wk8PfPFhosBtZUaQVZ/gHzA1M/Ep9kJrHPP4KR9ISvSOhH8QSijnxqB2mgFh23xBX5RnuEt2QFkn6lo22kK1TI5yzIDGZQghZV4hHjyblEibZIfanKeVDvkYqUwoLAA5nvC1q9ZccfqBlZOAbiXBVLknsXUq32ps6ugTNAy8NehXB7zDgaVEbXBQkD2L7gbpKqn5wbq8btUhbdTGWqX7iRZ+7PDvTcAYXY6Rt6URFyTKFAperH4RxUWi8B0q/PcbD0MryxHEtomEhAfxo5XjzGx9iPkMhmB3RfQbacHQQYPvs+4SfEtSfjN2VOO98gSKmvq2HD0KoXeZnJ8SljHTRxENXqlPWaWMtz0PMbyAvpveYlaRR0bx8znZY0NXyx5n7AaGa1rlKhsykm3N1AqAy0WUq3rCLY4Eu9WxNm0UvodjsXPWsPm3GyIEqEAkB6sUGrMAwPYKBypMVSAEgKLZKQVGci5Wktr9yKuRQWir1UyZ/UnJCgqwQmoBNLA3saaKnSYzGZupyYhN+nporfjlJtIkZsT1TZWeJjMPN95PLXaahIuxiOqpTGQIfDi4s0UmwUe6jWAdqEx2LioMFvMGGtr+Pz2NcrLKjm96xDfLznAsJcjaNurC4k3r7Bt3TeIhUoKU6UUXHc/bzQO3/LSzPFcuGADZLDs9R/46pHHoIcfHjF+9OwznMQff5HOoa4ZOJ5R4iyqsM13YFFpHqQBwhVun7vI9th9CC4OpCxZQPmt5+g46RRwgBpLOXUptzAbjbj/5gnz8Tj4cCUEeMFnL+lYOO5pDHV1WLk7Yz9ICt/KKy5iZN/+uGx5nZjbJvIqbmMz5h1eeOoY6dnniWnXDmf1IAAe0iwHVMBBdpY+wrTkbzFa5LzlH8X7AXdTzaRKq+evD+bkxZkM7QkhoWAjg2E94dLNEnT6RB4b9CXwML07wIUb4GALl+p98CNaSxFnd4mNh6X1QShV1fBmfZZIgG8HXn6mMT3q91Ao7lb6lPH6EhVm4Ks3oHUYTBsNu4/1JaYVPPKSJJR9PQ9CH5y50oDeAGWV4OUGdS0XIFTKSKx4FFllHdaqi4S4bkQQLNQZI5EJ4O8Jp+6xNipuzLIlqksMUV1i/nQ/mvkH0RmapmE+CJNFamet/uN2f4GUlBREUaRFixb/9DqcnZ1xd3dv8Auys7PjxIkTjBw5kg8++ACA8PBwDh48iELxlwP7/zaSk5MJDg5+YEroP8rdVMfS0lLc3d3p3Lkz69evJzw8nMLCQj788EO6devGrVu3cHFxuW/5devWYWdnx6OPPiDs858kOTm5oW//LHeXvXsMS0tLmTp1Khs2bGiSbnkvXl5erFy5kpiYGPR6PT/++CP9+/fnxIkT9OrVq6HdjRs3sLW1xWKxoNNJTw9efPHFBoH2zp07ALRs2fKB22nZsiVnzpx54Lxm/pxb1243ScN8ECVFpdy6dpuo9r9f0OZf4fHHH2fevHkNHmSxsbFs2bLlvhTsVatWMXnyZACGDBlCdXU1R48eZcCAAf+WfjXTzL+bosqCJmmYD6JWX0NRZQGejt5/2O5/itDQUD777LOG9/Pnz6d9+/Z89NFHDdNWr16Nn58fd+7cwcvLi3Xr1rFp0yb695fSJdasWdPEuqCZ/2z+0pXbzp07WbVqFePHjwdg0qRJdO/eHbPZfJ9nxf8pdHrIrf+xdLYDZztu35Z8wPIK8lj+2VzWL5iDxkothS9Yq6FWj8oIvdw92f/56ygtAj1DIzBV6yiu0qLMrsLWx5mbqfFEh0azYPsv/BR7nsyyCuysrLCSK1FZqXlu9Y9YzCITIx0BUMlkdHXTkK03EeigxKhRU6zRsOXCJX7+6juekVVzetijyIaN4eCi9ZQaKhj1+TcMjW7N9aQ73LaoEIprudkmClEmo9TZBW2tic7eGjJrlHR1d6I0qwjH+og3g87A3vfXo/OToo58PM046HwoLC+md7suaHW1xG79kQorM9lbumF3MKth2H7cuoec+ouM5HIRdxsFZouZWr10wRcff5kBz/TF+ZcgLCYzSQ63qEqppHd5X7RyLVciLuG9rxbX9Gp0aiNpZQX8eno/JqORxMxUHOyc2b5hN7paaX2CTGDn5j2MmTSKbZt+5ujpk4ywe5Utrll0rJYuvGWiDGMq7DGV8zDOAAwQnJhoV80RvT0u4mDUNWDvtpYXjybgVKih98fwun4xHZ8IgU8tUCsjX5HH8cDVjCwUmYsavejEx0INdqI1Qhsznd+bxPKpz+Jo9MCqVQihmy6ibLsZi20BWQcD6NTtFSp2fI6qsJa09g9TfPE0IeaRtM3pxoA5n5BflUbLnn1YG1/AmtvSeLo7Kdjn2Z3OtZm0atuLncUOKGRluMo1GNRV5NmVUhRqR7Gsmp1d13AyqRSUYLZYWP/pEYaVv40jQbT0qm44RpEJvUkwfspX5ioqECEdIpCR51LGWas65K4w8WoiladPYaPoSFWnGhDh85Nn+GXiS/h1e5GU6jw8bl3ihnsJqxPlTBEtWIkKPC3WHFNlSmlQjiIn9cXSRkMAe8BeBAtSYUgFoEJKybwEeMABYx1c1oGPghonG+rqza0SyishGEgB72hn8iylVFEDSrAvtWNoTCteGbmBT7Zv5sym9cgNRsIdnRk2bgpXz6Txa/xOyrLzcOvYmb5BAYR278zJYqlv1TVV9G/TlTqDnu6vv0R8Wgrzxz/O090GsXPWdEa/Z0DFThJvLOflJ+dQUVZCiFMMjlaeksG1QkFulkjetQoUMk8sooz+ofXpf8WS8XK3xydicTKQ4HGUyivPsFB3nBqMrLPKkNrVa75mfSW1VVXYODgQ6uoN6Y03XTayMmzqU7V+y+7jkrBzJxNOn8zAUCelSJvv8QTLTc8E7VVG5/ox2h6+rriOi58vgUHR6C29eOkjHQtfjMHf6zJKYTh3ixF0d76OrecpSgtO4K26N7WtO3X6Q7z5ZV8MRgV7zkPWAhhggTU+sHiuK4mX4tn1aS9ade2LfxsLK94pIKPak48XSxER137jS62xgroAMDmDWgMVWqla5W8DQOK0xSzPT2KEsx+PujZG30x6dBVBfl2IuxXN1RwpF/LbreDqCM9PgMcfsvDyx2fQ6XuBXor++iPBrFYH096F7AKYMBR8PWWUVoKDnRyl3IaSij54+F1h4tBKqnS9sLWG8EAI9oM6gxSgPLTn76+/mX+RfzS642+OArn7wEb4bUWNf2I9d9eh0+l46qmn6N69O5s3b8ZsNvPFF18wbNgwLl68iEajISsri1atWjUsbzKZMBqNTVKsJk+ezIoVK/6lfv1eH/+VdUDjeA0dOrRhXps2bejatSshISGsW7eOV1999b7lV69ezaRJkxqqGt9l6NChnD59usm0yMjIJv2trq7mQfwdx/C365g+fToTJ05sInz9lruRQHfp2rUr2dnZfPHFF02Wi4iIYM+ePej1enbv3s22bdtYuHDhX+rbvfv2r4zVfyNlpRV/a7t/BldXV4YPH866desQRZHhw4c3pHLdJSkpibi4OHbu3AlIqbzjxo1j9erVzYJZM/+x6Az/WNGSf7Td/wQdOnRo8v7y5cscP368ye/zXVJTU9HpdBiNxibZdg4ODk1+H5r5z+YvCWbZ2dn07Nl4x9CpUycUCgV5eXkNPh3/JzHec4Fd7yM0evR4fv11D23btsPV9Z7oIpkMvF0gLR8sIqLJzM5tW6mqKiXo5XcYtfBLrqRnMaRQzRPVTli/HcPYJStJKW8MPaiqq+PbaZP59c4t9p2OBxHiE2sYLLcmMBk0A9WEW1lhslgorbWQWmEgqaSMX9Lj0SOS+82ndB8/laX6Ejq7W+hqL6ddgjc/VUqVnkTA2dGF0qpyrHQ69qYZGgoUrDy8naUvvtnQl5K0fOLFHJQ6UBigq20Y3Sf25eqdWyRkp7F83y4sdVLEm93lYmLM9a7eooitqEctFzCLIo5WSlq2jCQ4OJT09FQSEm4iCAIO/u4Mu7QQbWkOZ5e/wbiiYQwomgjAV96foTSd5cal25QXV2AxWRDq75YtgozkKwUU2Dde1JWXlLNm+QZGPjacE4fP8Jz5aaLK/Bl0wYONrvs44WhEq65hWeU2Tqo7ssjTgqPBzATZZpCJDFVX8/HpRfhYhSC+baDW3kitvRFDVDxDLuWAZhbUShcoHiYPymqus0I0s0ReCza/Ymefzyd1SZjyPLErXcbcxT/x04xjbDIOwGaELbXqGkRBpOTRmXza7hJnPPxIPXyFeSu2YBCNPOI8nys5Y3jxxAA6jfJDba3guZ6BVOl1FFRpeaW3P+bcUo7v3AcVadianNjfZRT96jzQyqqxiCoc8tKJay+ZUrYOtCW0yBZBpybU4FN/7EWCQtR0Gp3AklvP0k3jxoGwFWwseouKsjSsgREZagK6DuOV7F2468BfK4nZ1ebb2GKPTK6gl9NoLmcX8ELnfqy/dB2PAWFw7SZTW5hxviNQZGfkh+obyJVyyBXAQYTWSGKQiYaMTGRAPpKoZgFKAYsMjCJEycHWFvIFkgOtkBWKiAYBsUqAa0CASIVeEsoAHIJtSPtoPc63ikGo5J3xj9MpOJStD49DX1jE3qu3ONU5kpDo3nigREBg9HtvY+fkyPWtmymvqsTX3QMPG7ialk18WgoAW0+fYM7QUbTsq+GRd3RUVdYysvtT6GqlaJZCYxpjn32ekNaR+IQE4u7vw6e9jRj01zCpXBgwpg/UmqCzN6IosvrnHRSWGvCV+TIjYTUQhA1KclqEYKrII8zrBp0H5RPaJp9D33zII29poC4MdkWDf6nkcd/z44bz3mCEHUekbPGHupp4wiqJUr07Bj83evQOJvGXYHKS03CztaNk3wmixyro3f0k5l8XNdj7TXrlDZzbRVNkhs0HIT1Xw8TXLzL/2RoGdTcCPwDlZJoDsbL2Yl/UDYbYvg5MA94FQC4fiLWV1B+zGjDDERnMLIMFDrDho3jKC0tJOP8D2ujV2DvsITBkCOUj96IolOPZ34AUySYhD4GimVKthyNp8PMs6NgaFr/WtNrnY7dPkqWvYUNRGvmdx+KqlG6kbaydGdj7dSLCIb1Qigy7IQVioFHDqN6HqC5/G7lsPyqlQO8OTW8+fktOoSSWgSSurZgvRclFhkjppDmF0CKo7X2CnqMdvDENTKamKZ/N/M38ow/d/uaHc2FhYQiCwO3btxk1atQ/tY7S0lKKi4sJCpI8WDZt2kRGRgbnzp1rSLHbtGkTTk5O7N69m/Hjx+Pt7d2kaubOnTvZsWMHGzdubJj2e5FN/yzh4eGcOXMGo9H4T0eZ3b59G3t7+wdGjwHY2NjQpk2bhqivezl9+jRJSUls3br1vnk//PBDQ/QVSMfl119/xcfH5762vyU8PLyhb9HR0f/gnjTl9m3pydbdY3js2DH27NnDF19IvleiKGKxWFAoFKxcufKB6XQAXbp0aeLvBqBSqQgNDQUkYSs5OZmZM2fy448/Nul/QkLCA/ufmJhIWFhYw/t/Zaz+G3F2cfxb2/2zPPXUUzz//PMAD0zzXbVqFSaTqclxFEURpVJJeXl5E2+9Zpr5T0Gjsv5b2/1P8Ft7BovFwogRI/j000/va+vl5dXwe/fbhzbN6dT///CXLv/NZvN9lSIUCgUmk+l3lvg/gp2m/i7Qgs5ahbasgp49e9OzZ+/fX8bJFkq1zFq9kRVnU3GyUjAm7gZX0qUIrPNOBnqX1PCUXztMigvSMvUfDC+Nmodj2qJWyCXBTIAEs5GJNyzozSIa77Z4OGtITbnC0cxyao0iLtiToXEnRFdIlYcvg7/4lszSciId7ejXuiXT+/diHN0Yu+QbpvTtwVN9e7D364+JPRyLyUN6St01LITebQOwttLUd0fkSlkapf7SB9gig1spSez8Kpby6qZeMQqFgtAbJkZOfQSAgsICisvyGR5qh0omcKNEj52dPT169GLo0OGcPn0SPz9/vOsLK9gcj2XwuWIsbAZ5bzD70PVqIrs7lFOa3/jFI/e0w9Tek4rvpTwubVXTp6AtIsNRqpR0j+pM6wRpv+wsao5U7eEXcRPZLtaUuvoiN5p4LuQS0WVVPJTvjp1Kyy+1nbliOceV2nOMODMIWTcRmwoDneIToLwGLp2C4S3gV1tOOh7njrMDAVRDjeQH5VkXycvPrKfIsZxX1/UjJHssVw2SEFpjVd0oEpltWRT/MXHGhdASvoleTOSVYRxQS7lb69JP4pjaEW12DcP7P8wc/0jExaC6A7f7NlZtcUWkX51H/T7aQjUIFncwy0BuYa/PFZ5FyZQ0Z54Jv0DdjfFYmTRMOD+M44+e5Y2ghQz36MzjaRO4nbCcjS6/cDviDKrSAm6XFWASzRRqIFttxrdOxjH/cqoxorJYcav6JL1rW/ND5q98lbYTa6UVG4e9ycsHvyG3VotQLNDe0Z3LVYVgDQTee7IAZYAjkoDmA9wBioWGSpiY6+c5AfmST5klRkSRKcOUXb8eLdR61yEzybBgofJmDZenfM3ADDNYKTBteQZnQYG+sAgAlyItJOvJ7K1kSHQ33Hy8cHKTRJLpYx6jqLQUHw8pFTnSP5BhHTpx4sZ1XhwxCplSRpqtP8M6lfPSmyIGg3QwnVzc+frHw4S2aEPVtX2kftKLbNEVtdmAiwbMQilifz8EpZQCZjQaKCyVoi5z83xZuns3Uz3scOhSyra566hTK7ni5IKbVRkWM9SW7wTSIBR472e41gX6dgWc2b/0a7bPX4A8chAJoT+CIKPtxj20v3iDH9RKbnw6CzdXB7p99yXXYuNIekdK7ToeH0TxIzOZPPwyHkU9EeQCzq8MYakWFlWDx3BQXwU7mUCL4LtPw+KI08cxo/whbDAz2PYTBEEE3qs/eMEoFe/zxRwZsz4EqsB1M5RMhr16qKqAli0joLAYs8IBO2vphjcj9QApw3eiCPHGy2QE+jScJvuPg+tl0PaEjDpwAS7eBG0NJKbD3pNSkQBXpZosfQ22ciVqQRJDktNOciZuBW1bPUL7qLE8PRrm3OPX7O0Ozo6B2FvfpI23O/16vIq/1yL+iBB/6N9FKmLw+AiwtZa2f5dW9z84lI65CV79HK4mwvTR8MTDf7iZZv5ZNCqpGuYfpWUqZFK7vxFnZ2cGDx7Mt99+2yRN7i4VFRV/6oH15ZdfIpPJGgS32tpaZDJZk4vnu+8t9aZ/CoWiQUQByR9Mo9E0mfZ3M3HiRL766iuWLVt2nxE+/Pm+FhUVsWnTJkaNGvVArzAAvV7P7du3mzxcvcuqVauIiYmhbdu29817kNgTEBDwD1V+jI6OplWrVixatIhx48bd17d/5BguXboUe3v7hkiec+fONfG02r17N59++ilnz579Q2EqPj4eL68HlBO+h3feeYfw8HBeeeUV2rdvT3R0NC1atGDJkiWMHz++Sf+vXbvGkSNH+Pjjxocs/8pY/TcS2bYlrm4uf5iW6eruQmTbB6fE/l0MGTIEg8EAwODBg5vMM5lMrF+/nkWLFjFo0KAm80aPHs3GjRsbxLZmmvlPwt3BE2uVzR+mZVqrbXB3+L9brKJ9+/bs2LGDwMDAB9oqhISEoFQqiYuLawggqqqqIjk5md69/0BraOY/hr8kmN2tRKRWN/qH1NXVMWPGjCYXmXfDif/PIAjg6kB+SRmdxj5LXnEZX8+dyTPduyKWaqlIK8ZlWDtkynuGw9oKSrUcuHoTgPI6E3MXraeLgyPX5TV0KUuj0qGUp74zsHLWLDacPktbXQVdXOzpMuVpBJmMHr7eWCvl1BrNIMLbLbU83aMbK2c8CcCGw3asv7ELgDqMDImMZXjJZNKs7HHKzcXNIiO7ysCQmH7YudkSe/EctmI5N26eorJ9G9yuZOHTphMUSaJTD2dPAj18ySsuJNQ3kNrMNLyP78e1opgSVzfMarhoSGfq8PH8FFFMtS2Ia65AcinBwSFUaqt4+eWZtG3bjpEjR6OtLqWszkxxjYmWrlbExZ0jMfEWX3zxNYMHD6O8vIzFM+fhFuHDxKIcAGQYoG8qJh87Qge+Qev4OLh5nby8XAC8o1qQ3s4Wq7EWLD+lY29nS0FeIQBPzpjEw48Nl/YlZzCy+poUx+yvotNL+xhSJKfSIZGg6mRenPw8Tw4eB2l6UpbuIOZiK+643kQWpEIVm8oX/SezQDYFa00NRiDnhB9BRbaAQC99XyJ7xiAsMZFv9SXdzUNwiczmhKeU2vfZoBW4VvZkc4YMS8EndOn1GV3v9GTC0Teo9Izgu1HjoP6Ubyv3IkzhgZ29CW2Vgp4OLYhe1oFqmZbVSd/irrPBKiQVY40LHfPH4OhiT25KMtFlanI15fjonKRKoCLYt3ZitOk50lPyCdAo6J3qi7pOzsveB7DI6g3+RYGeFR7M7zqGoLYByMYDyBlTMQhXr2/p4ehFQFo1grsMs8zC/kANhju11HlIwqBBrOPg+S0c3C2gUMkhGmqpY1vGWTwKBHLqf9Mui4XgLUp9q69z0NHoiY/Flj32qVhk9zw5sRYkQVEQpWi0UGl/KAVkIniKYAazUL+MTASdCCZoUxfMtauSSfTy8uv0pxWyOhMPLf2Qg2m3GNguGll8Erdxw6vGjq+ffwXNPd9BABq1FTKlkldXLad9SBhT+w9m3/xGr4E9P37HreuSY/uvP7fnk+XvcP7kYUZNeJbQFm0AyP3xOYxlWTgDy5OghRP49p1CO2XjtlRKFbrT5xEC/ag6E0tFXg7xed/z+KuPYBYNgJIlJ17gKafvObOhlqTTWo4fsmJfji+9W2sZ8dbjDevatC6BoqivsE1Zg8IjFZN9GKZ6/xy13sjW84mIO6uZPKE/dtbu9FUowGQi36MFR6unkXbwGNFt+/HMGGl9B+ozZgtVsOpD6GJTgb3Nd0ihgcPppA7loCskGOGMoT+91EcoN3vgJN8EwOb97SgtfxR9feEMu2Qoqe/rKQMkv/Aaywf2pEAfxo7jAdjKV9C+02Q2ykxUaFMoqgpixtEaHutsQ9tw2LtR0lodC2H4AFgblkFaj/MMT3VA9d0A9NVKTl6GJ0cPYGxEJkE6T1ZvUTKsF6zZOp4qbQHxN7cRETqA1GznhnHr0hamPAyC0II3no+ntDydlmFD+DPkMnj/wV7nDew4AofPwqj+MKS+FkN2AcTXp1X/crJZMPu3IQjg5vDgKpl3cXVoGp74N7Fs2TK6detGp06dWLBgAVFRUZhMJg4fPszy5csboo9AqoRVUFCA0WgkPT2dDRs28MMPP/Dxxx83iF0DBw7ktddeY9asWbzwwgtYLBY++eQTFAoFffv2/b1u/Nvp3Lkzc+fOZfbs2eTm5vLII4/g7e1NSkoKK1asoEePHg1CmiiKFBQUIIoiFRUVnDt3jo8++ggHBwc++eSThnXOmTOHESNG4O/vT1FRER9++CFVVVVMmTKlybarqqrYtm0bixb9sbD9zyAIAmvWrGHAgAH06tWLN998kxYtWlBdXc0vv/zCoUOHOHmy0TexoqKCgoIC9Ho9d+7c4bvvvmPXrl2sX7++QVj7rZ/YpUuXkMlktG7d6HG1dOlSAgMDiYyMxGAwsGHDBnbs2MGOHTv+sL/BwcGMHDmS+fPns3fvXgRB4IcffmDQoEGMHj2aefPm4enpyYULF5g9ezZdu3bl5Zdf/tvG678NuVzOMy8/+cAqmXd55qUn/+3WMnK5vOG75Lfb2rt3L+Xl5UybNg0HB4cm88aMGcOqVauaBbNm/iORCTI6hnR7YJXMu3QM7oZM+Et1CP9HmTVrFt9//z0TJkzgtddew9XVlZSUFLZs2cL333+PnZ0dU6ZM4bXXXmvwNH333Xfve3DWzH8uf0kw++0FENBgTvmfQNzNJHKLpCdMe06eZ0ZUNDKNCrdIH6ouJGPv6QCOthjsrajT12HrakeHkADyyssxmMzcsbMwIldHpwCBVwokIU1zI5ZHFonU6A0smzaJE9padmzczlujhrFs3wbsVQK1Rhp8jRTWjU/H3R28eaF7TxLiyuivisBFLWd4tyi0agUxrWI4ejmJoPh8Vu5Yi04wEl+oJ76ghutFOrr9upvTUe4sfX4+gTcSKKmoJPHAAbboEvB0ceejZ1/DJjCE0MeeoOuM8fwyWPIZcbF3Qt3enxqvOgxVemQDQpAnl3LnTlJDv65di+fGjWuMGzcJhULBiRNHyc6WIutqa3VkZWXi4uLK4SlfYn8qi8q5thyytWOIrz+Cvx/M6YxCrcYJe8ZHhHPpUhzfffcNtja2ZG1PpOSrIvqO6Muc/e+Rm53Ph6uWUzPWl33Z2fSMr8Kjiysq18ZxKoxx5JHyEezPicXkVEM/gxXaChPxG3YSiYYzcedQFul40WkvfXtbUW2vgpZlyLboKDA5MN5owQR0NKfybv2BkNfKKd8hw8tiRZWxigGmcAxpbrhU2lFhq+N587N8WJhPhV4Pej9yMrvxzJ7P8C4Jg0yI9w/laOfTTN25mN6XJhHvdZ7ez57BoaIFL37em3xlCm0NvVnfZgo1NmV4FEUQc3kKB2/+TE7CBewclUT1qCKt9EsMF0bh9mQwNndsEXbIcBZscBEb0y8AAopC2d9hG/554eR6pqJEicdiZwR3AVOMEcVlJesCDqEXzBzX5PCZ36u8kbcHvaWaCUMeZnvRcvTx5Vz0NBLrb4b6wD6TwUyUfTAKezlbE4/Xn6eSVGlxF8GDhsg6mSgwyBiIv8WektI6ygvzwRvKrC0UGQTM1LdVAQYLFAhQJ0jvUwQwiogWUfowWIAaAfcUJ1r18yfbUERZopafncpYXJPDq5Me4/Ap6eL2sLcNXpZu5OeXMUhdjUWng98IZgDTv1nMwXgpbblNQBAxoY2FP2K/WoPcBGY5tG//CD37j6Jn/1FNlq8s02INZNgE0+edj7Ez1jF45KQmbUrNkH7wOIqy0obUMBc/X7oOXEqsqw1ZZqjJ9mfuoyUUuBmRWWDjF7OQO/Zi+d4DbP5qIA/7elKrg8w2X2NBgc5nEHaGeCpdfdiZe5EBcg8yZDX01r5LZcJkfE6dwODggPDuu5h3bsZga4u/LIXuIb+SkNivoW/P2MC7VVKFzXQ1BKkWYM+S+i+fy0A7/BTgIoMJZft5vzKVb5xW4iRfjEUUOBHnza1UGNwdMnLg6TGgdoFxpVAHFIsyWvXuxumNcCdvIbbWC3m7Owy10RF0aQeyfe25WW1DwhWRzZ8JONlLlTRbe8LsEfCucyy1FhNnqoroHp4LVwKxWGDLTxr8PVtwsFQKBD59BToGe1OlLcBa44xSqSEhtfEYDOzSqJl4urfE0/3viQqorYOlP0qBwncyGwUzP0+IbiFFpo1oflD478VWI6V3F1c2jTRTyCSxzFbzu4v+KwQFBXHlyhUWLlzI7Nmzyc/Px83NjZiYGJYvX96k7fz585k/fz4qlQpPT0+6dOnC0aNHmwhhLVq04JdffuH999+na9euyGQy2rVrx4EDB/40+ujfzaeffkpMTAzffvstK1aswGKxEBISwpgxY5pc41VVVeHl5YUgCNjb2xMREcGUKVN46aWXmqSK5uTkMGHCBEpKSnBzc6NLly6cP3/+vmqgW7ZsQRRFJkyY8G/Zr06dOnHp0iUWLlzI9OnTKSkpwcvLi27durF06dImbZ98UnpoaWVlhY+PDz169CAuLo727dv/pW0aDAbmzJlDbm4uGo2GyMhI9u3bx7Bhw/502dmzZ9O9e3cuXLhA586d6d69O+fPn+f9999n2LBhVFVV4e/vz5QpU5g3b16TB9XN/HW69+7CmwvnsHLpmiaRZq7uLjzz0pN0793lf6Qfv5dmvWrVKgYMGHCfWAZShNlHH33ElStXcHZ2fsDSzTTzf5sA1yB6txzIxdSzTSLNrNU2dAzuRoBr0P9i7/4cb29vYmNjef311xk8eDB6vZ6AgACGDBnSEBG8ePFiZsyYwUMPPYS9vT1z584lOzv7Pr/OZv4zEcT/hQTbqqoqHBwcqKys/Ns9Ov6I6lodI15+j8TMHFa98zLdjRoc/JwpuJCKZ+cQAMqqKvjgx2+pqqrEJySGD3c2KuKCCK/4R7Eq/SJrUk5iYzHzo08kGxwkp+lof1+uZkmRVi8OHYCsMpkjyQXcLNbXR9+AXCZjzkOD6RIaxMhO7YlLuMqKXZJnSVBhDekeUthSca2J45nVPNbS8a7WRkmtib0pWhQyeLMknfxurflo/FxcWkjh+UcunWHTod3Y29jxxcx5KFRKik8d5cgX73G4Sxd6R3chPDSMwI5tmHzuR04sPI2VWs6IABuslfcr+76+/rzzzgLkcjnXr1/l0qU4ZDIZZ86cxM/Tm6grGi7XplJQn0HyzKhJdHm48UJRl5HOhmkTmNutHc6OzqzrP5aPn5fSyjy83Fm9bRkAz91Yi6GNFMLU/wtX+kzvhJeNhqpJRuzTlIgyEcEi8EzUMkyiVM3PWGfBIcObdFkmKlHFFNMYRildiRu4lTKPOixm+HmHjCq9gWqh8cv5W8NiAkQ/BAQMKjPp3heJ99tKYXI+Y0tm4EYIeisHbN61Z+tXuUzwP4FMYaB73w/5evOHRCVJF/sfT3uUC213EXF+Jl0LB/DzgOeptMmnU8VEar+rAGCQOIXFb4wDwKbGhd6nZqNQKsi6eZ7glg64e0LXHQtIdE9GblbgXxeCe27jzVSdwogcOUqTjGLHSjY+mkTp8UVUaKyYYprGjuC9nK5NotrBkSHXatkRXkmKk4ko0R0rlYanysMRELDydOLG8b2ojSIikDGoBVczM6nOMqG2k3N6yUpCvptMjUkyl6cA/GTWZLvfY8BZBp7FtkxxjCTYxoFv064yVKtFIQiIiHxmqcMkQzrPfaRoMhAkpaUcKUJNJUJp/XkmE8EWqBLAQ4QwEXKBNIEB3dpyeN5iBr/7Oofi7ylRCDiXa9k1/QV6PjGZm4kFnE8SaBXmSteWch779H12nD2NXCbjxtff09Kv8YZtQc9+3I6NRVAp+Tr5Ni73ei5W6TB8uI7EkplcaPEQH0zahUyQsdZJoIdaule/y3UjTNgXi+fmtWgefoSt3r5YfN2wC2s8bh/0HsDJhBNU21kIVbUiu8NVzDIFOnMWVvM1xEa4YTDC6FckQUmtz6RFzvPkuDxNG8WXlBdKPg6PPluC7uso9qukNF6lxgqjTjpGLR53xS8sgPat3sP/N/ffPYrMZJrlOAlVXPRwQy0YgAtApybtVmjhcm4hFemb0Wg7k7a3KzIBXJ2gqAyeGwcTh8OxOtiqgxFW8JAGZn4AN+rtib56w0T7VgpC4rZhu7UvdsWuqFU69nytoboWbqdBp9ZgrQHrE5vQyY0gwqnQEZTcdubLDZKtpIsj6Ook0SrAC9595jjnL6+hb49X8PNux7ebYfN+KUrs+/ckM/7fYrFAeq5UAdP6n7g+sVjgiTchIw9ah0oeZ/fyZx5mN1Ng/W5JXJs4/K9v/z+F/5Hfb1Gsr5pploRpjerfElnWTDPN/HdhNpu5de02ZaUVOLs4Etm25f/tomXNNPP/ERbRQlFlATpDLRqVNe4Onv+nI8v+FWpqavDx8WHRokVMmzbtf7s7zfyL/FdZGNtaazi+UjLsqyup4siAjxDMFqJebPQLSCsroLKyAoCCkka/qWkjBvL88IEEqTRsfy2Hl8zdeNLXhSXvzOfgGx9RXFtDUl5BQ3sHaw0a21Y4FFp4t0drvv71OGX6OswWC5/u2U/cwrekfuj1DctU15ZgNFujlAtU6S14OzaKZaIoiWj2ahnVBguVddXEpJaTceYGpuyr2Ia1wNfDn/efeR1bKw27vtpCUGUx+Sc3YZw0gdeHPYqbgxO1DlZkxd0g7ZsLiGYRXa2JroNGUXbzFNnFFchlMpRKJXV6PTk5Wcx5cR1OHp2ZN68t0dHt+frrxXRsGcWzoyYhToG6r9dTUHsLQRBwCw9uMt4F27aw29GGCis1FXU1nNOVMGzUIK7EXePxp8c3tItS+3OJcoQaM0uNWia+u4tX+0TwgpsPu8bl4p1ux4DtYbyWO4GF/rcQTBUEVYfQ0tKWdFkmBsHAOsV2OuuX0O7EQ8R138fmVkfJsw3EzeiPp9mDFFkaClHBLNWrDDL350XTTNY6f8uvL70Kcgu9bnriurknMm1vTthlMby3Pb7FPqy85cLx9rOocUrnhN1GomzLoGYCr274nj21rmjbfExVhy105xUMVWYe/u5FbAsq2em0hPZl/Zn68+dca3GETtceJdu+FJPRRM2QKqyzB6GpTOeG71US/G4AcKokm6f146ipyeZai4uUOhQy7uQzgAwnrQMyj06YlLbU6FVsDDlCZt51+pQqMMhKuNXCmwnJJsqDPFnhnIzJaMFGVDJU5sOq6lj6mC2AgEKtYpyiBZ2V9ujCLRSqdByKP0Otsa4hChJPyLbUSlFoSqSUzNsCBWIti8svE97SkVs1JbTDCl8EikUREwLcjR7LAUJE8KrX4q8hZQWKSG30QJAIt+p/JIuAsPr5bUQCoqUyzHMeHcux61cx3eMjY7RS4de2Ldu+38ShDG8iO/UhLhn2vT6DRzv60mPaTKICg5uIZQAvbN3AidXriOjRralYBmx6bDo3Tp/ELkLF1sgeiDI5ZuBENXhX6HAwluHu583cK8VcyC0nYu8vyIOD+KzSFpvPf6ZOpWD9D9N5IsodgL7Tn+Lqc2epsdMzUdWFRYiYAScbBwLcpKfHKiV8MCuPTRviqTi9FYugwmixw6R1QVIZIS2xO7YDPeGk9D10VywTgV+OvYHuXBA/f9m4H2YLrNxmprJXJeBMrajCLL4GQgt+K5ZdNMD7SYUUDpiIWKnFfrqS8G5dedkXlv8ktTl1WRJ++llJf3d5bjws26zDWujHmo1xVA1fyjr3SN7xfwoHQonyziU7fyuL1oO/J3RvJy3X+tfBpEfcwiXTn8BwZ2K6S+LWmSswvJekh8TdgM5tSvhq1dNoa4Mpq3qTJ8ftp2NrSSTz84Si20fZ9ME+Hp46lvY9G6MCFn4PB2OlNms/BPXvWF2VV8GXG6Qqni9NAiu1lIq5chu0awEvTYbWYfcv92eG/5+vgdRsOHtNShsN9v3j9s38AYIgVatupplmmvkbkcvlRLVv/ecNm2mmmb8dmSDD09H7f7sb/xbi4+NJTEykU6dOVFZWsmDBAgBGjhz5v9yzZv4O/qsEswbKtOT/dJ6Ka1nY+rvg27s+pUelILJ7F0LjTlNUVMjTT03G3mEvol7krRFDcfR0pSCniPceG8FzqzaxVrShw7fHMFTUgAp0JhMdgwN5un8vRnWIxnvmHMwWC7fyihlsVnDeKCesTkMfZ2/SFh0mZ0wb0m8nUGywoqq0mJqsUi7W2OKqsKJ3rjUPLX0cR4MK+10+6DXQPm8uyOCh0kxemfcO3n0GUpF+h7y1y7j59stkvr2Yp0aMAMClXwRnko1kOQ2nvLSAI2u/ZfaEl3C313A79Q6RTlYUVhrw9XBl8oih1HaMpjQ9G1cHZz5c+1XDUO09VE5a2k3s7BS88EII7dp1QFamlZ4IyCF8cHtsDKG069CRgICmIbXWPXqjSLyO3CLiqFQxxacl7tM6wezpTaIFZoT340p+FiuP7ydZLokj+87epHJsHPSSKpi6j3Xk9CVnohRfkey8nevfHCRLU4qjxYEKcyUGwUCZUIZX9VAybN4kJzCJcTGjGHPwTVRGDdeFW7yjkqLbrsiuYsHMHttdKORS2k+llZLn/Ko5YL0Ho8xMgSWA6J90dM8YwpSDibz0emsOu2bQ305OZLUzaj20vzIaz07WXLBrR6Y2Bf/4QfjnagAND9eOAqsjjDo+m5HHXyXdM4nsdrsAsK/xIq6zhbmLFpDmfK5hHIwaG+xLZNgTQEVxOVmeKVwPiMOnMoJrHQRczqezyK4jWVYOeFXUMFh/UTptLQJRfkNRZe2ktNYGk6u0T6YaDaWGUO4oL1PUQk+bYjktS0Tift1FuZMGm4BgYslmz9l1DV79DciQPNqSgRCQyQUsJjAqzdxyKMG6rYJNCTq8dAoKBJGGEEpHURLL7l2fizQLORAoQqKALE9GoFJNukGPWiVQlw5CgcA7r07mhXaj2HLqOJ9c34SpnZEY1zDscm3JzM+nY1g43x07gjyhkDJBQVlhHtfPH0dxNZ59iUdwrhtJm8Agth06QH5xEUN79CIsIBAnb28eeXteQ5cSK/WsSa2kvTaHfYe2AyDekqHcvhxV6x60bNOZftoqvuzblYqsTKIWfcMyL8nE2tUlkA5LXkQzTvqcWBlMJN0pgSh3MquNZHcfzsqiKmwFE4qtV/BfsZ5LTqE4vNOGIfVFrmqr8vFxb89nCws5dHAg+17X8mjroWRek+MX8TTaSi19HpuKV5A/Bo0cuVLJub2HQBQxCxrMMhtEUcXhcyKFpQKPDYK0bPj5aA2rRz7EDv0UehrOUKf9EWsHWLwe9p2C4T0hOQvS80EZmIFYqQWgdcINTq+QDO4vJcCdDBjbzwTv7IWKWpg3jMQ6R77eDEE+EOxbyp4Tx3C03sq5S0uYO+sSk92Wk2X4mUeGfM3bX0NBqRRh1rsj9IqBx6Nd+OlgLyJDYPI8EUFpZuKLRcyZ2njx1CII0rO13Mw5i8niQc31w8QmQH4JdImCD56rZUrLaRj0ek7sOsCJ0oSGZe/6jGUXQHE5+HrwQDbshSPnpdfBvvDYINjyK9To4Ew89IiBD18DTxf4fDbY/04xgN/i6yEJZrbW4PSAwKtaHdxOh5ZBUsRdM80000wzzTTTTDP/f/DFF1+QlJSESqUiJiaG06dP4+r6xxXcm/nP4L9PMKvVQ5kW9za+WHs6UltQSXF6Me7tAsHBBo1ayZtvvtvQXPXjWj6aPgeAX05fZPTiZYiiBbNFJKukjJ9vxxGkkHNVJQk9DjYaHvUI5uwza3FUKim16FHLRDStlPQVFfQ/7YB4vggDRfg4OVJQWUKdpwOni/PBKQgskGEw0G2QN5baCtomPQQp0h2bduoacjvkkvLqOvyHPgSAa6s2OC1YzLFOocTHnaG0T1+s1SouJcZzOyMFlaK+dLwAG15ageJRZwoLC/CxVxG/YiER7aIB2Lj+BxxlKhxsbDFbpH0RBSXer/vhaZJhbSXjg8/eJzctg5CQMKKCwskrLmTDwZ3o6nT4/bILz48XoVbbgrYWHGzQ+3jjLMqYlFHKgmkv424ASrUgk4GDDQnXE7FYLARGh/CD6yVME115FDi/pY7e+XIqtFo0uIFFRFAb8cm5TGJbB8qSEzFmV1EM9AmPQX9bTiB+RIotybVK5XpCBG9f/oIOmf0BSFTmEfZISwZX9efC8cv0M/fiDGexL/NC+3NbVOGljNu1le5+59A55NLb6EnOpiy8sqVUV6VJyZxVv/CCfjbLe+3h48NjUZrU2Oa3xOYVBfbRxex+ahLd27xGnwPvo65VU9K5lPnmahKrfsWktPCLXw+sBEcKFbfJCrpFiGEBxyZm4FYXxu3sEtJrKwkzVDScd775YShcLnKrVSlnPROxzr2CZ1UAOWrpTrxAoaHKzgqj0oC7XQBBOoE2I0cgnL7Dc8kjSbfN57H8h+hs04Pkojvs9D1NjQKiiuvPB6OZ76yuoRUMPHxHRf8aKw75GMiosEiVLd2kcwZ3QA6WKAtUIIlfQG2hCepkZN018b+rkPmJcFcMMEvLcm+kTTmgE7DooNBiRJSB3gI4iohlImeO3uLO+Ry2nD4htW8P8TWpGD44yNhPP+Cnc2cAkeGtgyjK2MmhOd9RrdWixIxxeADcvEZWSRGPt5PKH566fJGwgMD7vgYmx+Zxu9KAug4m+vlRnp2Ne1gIaYUJdFz0DN/tuMjV+OtUZGVK471vF7bTu6EvL8Lz51fJ9TaxVhPLiLYDuOXuiH//CGpNFnofyqRYb6aTixXHBwWQ3MYO7dNOTBjYijXLvmfsV8PRWQXhmbceX2UbXltZRdsOSYSu0hAcYyAnxY6171cT0qYlAS3D2PLFcuIOHMczwLfeS05AIdahLP0Rp6gBLNvSUfLcyoDZU0pZ9nY//OVJ6FKCeG/ZekQRFr4IO49I+73zaOMYdKuK4Xjow9SWpxDReSYymRSVtWRufYMd1+AXqVACbqdZrhrBtSTJy0su80FEoLx2KgorA3K5kmkTtwFw4qIkloH0UV+zCz78Dt54Gk6MlyKxbqYIYFbw3plsugZpaGPj1NAvQRaEqd6+SpT1pKC+8kByplRZ0MbeFkOxHntnxybH9NnHYPVOM96mA1Rm+eDrEX3fcQfwcb//dd9OsOlXKYrtzGUorZD+zl+HQd0euJr7mD8Dzl+DUP8HC2azFkpiZai/FAHXTDPNNNNMM80008x/Pu3atePy5ct/3rCZ/0j++wSzekMiGy9HHjk7H8FsATsNuDs2aZaTk8XOndsY0284FqOB5CUL2ZZa0JAeJreAk0zJiTAF6RXStAHBIXzWaxAVKQVUJ+Qz3VdFTi8/rLWVGDAhswi0eLQztz8/BICDrwtbVGkkpKcyNLoN+69KqXlKQUZ4izA2Hd+HSuZGdyThZ8yPX7F7bRxTOneiVU4Rnr7S3V5hejqr3MOpNNbR4eW5tAn2x01WBkDHdu1Yv/80FcVG3rD24Xq9g7sgl+EX0WiKHhXVlvXrV6NUKpky9Wmsraw5ducK8omSwGJnqib32QwAUlOTOfbtHk5r0tHagqxLINv3X0Hx6Ye0fV5KNbUUlaOUV9KnTz/MWh0B7veE4AoCsSfO89Hbkqn7tHEzMLzQaKXXwTMHeWwKs7pMJzY2k36tY2gz/13aZGeRf9GLs4bGVfUpiKOV7YfEPvw1Z7S3SaaUCPd+xLj1g/qbUm+zG1yHAaP7cvDYUULEYHrQFW1wAptbXaBr8RAqVRX0euRNsNHT6ch0hEMdSG+XQuilCAAq7QtxN9qQG3qMJ3t5IxNlzF+xH48qf/yzWgGQ4f4LO+dFYF1hpK4qkZy0UG7ZVCJDpDxGT7XxEfaeMdPy2qOMyfBFJ5g4OUBNWx4iNuNlPGvCMAgmVKICG7OG780ZTAwZgjJ7PyZZLTnut5l5x5sdTlVEVafxmOPTlPT0w+QYjkmmwmjax1uL3iGudyLJwSZKxrTiYiWMONqZnb6nKba1cDDIgH+VjGsqKwSlLf5lFbQukb4GeqUpyTAZaeEQQaE6hyp9DWaHeuVCA1iDolSGuUpEzIUGkcxKBEegDKgQpCqZIk2jzO5i3fiyRpDWLZpFsAfC4NiVK00qyliXqXGudsDv23HU5dSXb/SEfY5pEA22+6V1yFRWONvYUaarpnVAEHY2Nmhragj29X9AJ8BKLm1DZmPL3LizGDLTCe4QQ2lJIY5OrihVKroN6ErcsCGkX47H5FSD7yf9MNu4INR7vZ24eJCZR7+kpYMzMgESU7Iw5eeCsydZtUbSbyXx5QtvIYoiN1OTOBenpdynNZigxGkEEweuIjvdn/N+21nj607n8kNErV2C1x0ThjvXie96lvjjkmdfQWYOSrUKo96AUq1g5dePoXAJZeJcyQPMSg0hfkeA6wAkZYzAYJR8Wa7fgZ4xcPoydI+WRJvicujZWkFO1tsAOHvBU++AhwvMnwkaNRDsBnIBzCKEuhMhg8v1AV1my91jZCGv4pkmY1tWKXmNmS3QLVpKuQT4+Sj06wQP94F9V+qoVtZSGpiJQHiT5QN94KlHpG1NHWlFUgbExsP4IaBUqVhzZjfnDp2k98NSKn1VtaTRD+4Oib98wtrF33DqGxnrz+8jsmP0fcf+0QFSewHo2laa9tx4mDAM7Gzg8Dk4exUc7KDNA1Izfw+1Soqmyy2EafNBqYAPngc3Z+kYpUn2lqTn/LkfWjPNNNNMM80000wzzTTzv89/3yW7Sgm+rmAwIRRVSNO0OrBSgVLe4Ba9efMGbt++xZN9Hqbg111kbfiB3iob4lr1wVwmMCvNGneFFVNbN1bbeeSYlpvb1qHt6k2bp7ti3d4K3+JCbl4uIzROxKEIrHe0wGyqprd/EJruwSS+sY8aIxy9eRt7jRU6g5HpQa1wsLaRSqWb13Ah4DJ7Mos5Zb7FcDryXNwE1l64RuXI4xgrK0g7eIDLdh5EKWRk1hh4o1MXhreNIPPQL6gvX+LtTr2oLbQw8M0p9EVH5ZHj2AtyrGWNh79Pn/5ERUVjZaVBLpexe/dOtLoqQAoltVKoEMa2QTyTiZPRmqpPLzP552fZ0qeUUgeRosFh3Fl6kxaWOtQyK9LuxHL81HKmf3YSDCbE7CIEEUpMKpwsIrkpmQ3brs7NYNiRTpzol44+Pxfnn5ZjW2tDt67f080UA+n5iDnZCIC6pABzlRRxp0Kko1BLxchsLAoj1c65RPm3IWbYM5J4U4+9RQmJoPpZhT129LB0BWDglScILo2kVXoPauXV2CjU1Mr0XPTbx8t7F1PZOZXYgcfQ5Ms5NW41tR+qMR4NwzLyGmNz5tLKtgdiC5FrA/czMmcUDmIwSadP0LaVEisBXvWMY0V+NI/JzVw/tZ6TBRWcKrrAsCoXQmvkgJxKRwNWloPEnvwSpagkyT0LJ2sProSKjDKNwTanllqHYGRFZTjUODGv9jEGdT+N4NqCVOsBRF2GVse07FIeZUWb4/S+OIhOYgvapcOVVDhY8QM31dtpUSIn0dXMJSszl8rNWGkNBFnCcbfyokZ1DhtDHZmeFqZGzaetX0teuTWuoTomADfAWqaij9oPUwgc8k4FdxFKAB8kr7Na4IoMSsBJsKJSrMMSKcK9BuxOQBuLpFYkIaXmBokICIgpksrWWIZEJCQhmfJ+XcnXFYEv+F4tQ4GJjFBJLA55MZiO+SE8NqY/LdsFk5CQRJ900Ae5YGzjjYuj4wO/Brb08GFzRhW9Pazxd9WAp5T66+bRKOwq1Wpm/7KT4soqxj0xBGVVkfSn1GA06qgoL+HnjV8ydVYdiRcFvp19m5EWkZoJ05g6egCZp4/TUFNFNOHtXEy2MQ+D0pv+Xbcz7CnJOX91dh4FujDSvimjx5Foxuolka80X2TApNEc27KLmP49GTlzComx55FjQeYUiijC0tchIQ2G9QToBfgDuQzvpeFsvGSi3zsGWgRLwpKDnVSJ8sh5SUibMVYSc67mQGKCVB3y9GWwiwHH1v603DoDqnTQPoCZItxKlSLMbDTgYAs1OhljBzeO657jUvonwOMjYOxgSSDKK4b+UtAfrUJg5xJYlp/FAtuutL4nuuwuTz0i/QF0bC0Z6WfnS30PCA8hIFwq0pJTCE+/C9W1MHsK5GVkA2CxWCjIzn2gYHY8Dr6XsnCxUtPQ/7tRYUN7SOmfGrU0/6/y8zFIypBe/3oGpjwMCrnUv32nJL+2ZrGsmWaaaaaZZppppplm/u/z33nZbqWS/mrqpD+lQipjD+BiDwYjN9ILSS6pY9+ZY/Rz8QRBwN9Qw0sjnOlaN4S8X24S8cIgZuZf5/s9h2nv4oXd5WoAquKz8fpkIj28PQH4NPdLMs+lMeTzJ9BWm3nq1K/EBAeSsbuEEm11Q7c6BPkyOqodnx45yup1N+ka5MXg1uHkFmWQUl4MlbBYmE4YvnQUIuh7/DU6Vp1hWtolnlIoOBr6CN2dvXh+zSZOtwphyk9fUQukt7rF+aiWKK4E01WuImvG4yCKvPlJDOnd+rFn8XvY21rjrHKBPXC66AQHru4DwC4tj8gce25Ns+G6lRUdW7ckerxkAOStsOHjkjDuVFfxuWM80VOfptZOxqr3h5GffYt2/R+Xdkyl4FyNO4VFJhzUJvopKhneqQNFGfno6nSMGt8b+58D6N85iDdnBqM0lWCUyamrq0NttCAIMr41WNNLqOOgQUmmawgd9JU8ZuqMuXUgjiP7ElpooLo0n8itUzAsNJDnl0sgkqeaiIggA++ubszSvUBuej4+eHFQOE6HdMmR3MpsjW1qCDW+txFOhWHBQuDVAIpb36D9zUm0SewMYSs4fLuG3qbRTLz1CoIoQHdwcNBizncCynGxViNazJgVGop9XmKUTSnyrJNYgAilpBylyRuLQ/gVHCQgXQRRiuQLdvfmpFMGs25+QJqQS299FPOdHiNWmYa1uRvXB1zh4RcGcfZ8FqmF0OmEBVu9HTP0w1mYuhFFkbQeJdBhu5ndvrsJFxWEVMjJi+mBm48TqbaZBIb74C2fjlKuJskpjp3x79Oh1QRaeLVGXxuLyiLDkFsvbHmAzFPGfEUXsjRVHBDTIQhpni1QH4TW8G2iEyhHj7utA0WXKyGqXjTT17e3r1+2A3ARSBUQzYD5bqUcSWQKySyg1fVcbhTfQehmi+gu0ioxB0dtLeWhNlR62nDNJoORT/RkYPfOCIKAuPBb1EUyFALcXjQEl36dm3z0S/IKuHLyLJ7+PrzWvem8B7F5/z5SsjJpMXomZUpfvDxaUbZrBckaHYhQmbKHp1qWYPYOxNbsCMDDYgmFG9ej2nKZrkp3LN2CefiV41jbHaes+ARqh0oyrjVu46EdxyjWl+B87DB25kbBrjotn+CHIzE9OpzuIwaRdfUqSx4aSY33UEr6DkQmk/H5bJjYUJjWC0jFZKzGymzA11MSh976GjZ8Ag52kiBZXQufrpIiwHw9YPibsFMHwkAIWglXAuDbMimbdoe/OzH15vmCAItfkyKwth2S/Lqc7CUx6y4Fjc8PQJTmb/wU6vSQWwRfb5L8zNpGWPFuQPQDxzy/GN5fLolK7z0HlVqY9aHU38Nnb/PK43X4eUuf29tpklgGcPEmvPTpWwiCgHegL31HDW2yXqNJ+qovrWicdvgcnLwEz4yBthGN0++KZ/tPw+pdUiTaq09I21rxkySAzRj7YEGtXQvYdlBKR217T/Dcw32lv2aaaaaZZppppplmmmnmP4P/TsEMoLJGEssAVHLpbgqgtIojNxLYECdFf2zeHse4Fe+TsG8RpdWF5A3vQPesFuzOSiBt10+cLMjCZLbQvXd7KoqSqL2ZxzafOh7XNIbV7M/Xcsq9hk/at2LM4mWIwKW0DAZFRXLo+i06hQbx46xpGOu0fLhpLclLPyT4xTc5npzH1bwKbn32Dv2Sb7N01w4KyzMIq/IlVywhviqdkziR5NGC6XkVtN8tI1qsRRsqY9PNZB5RqLE1G7gYKd0J7tmzkzbtOnA3hCcCA+uu3GT3xl95fPqj8L4MTkB3WS9+Df2FQnUB2vwi5Df1fHbuKLUmI4Y7eu5a+jgHS1E+4XX2zKhtR5iTB2jUPPb6RoriL9CiVX+oqgV7azQ2CjJrFHS2lkzGbaw1zJryGBaLhYo7Oq52z2TMl4mkBn/F6MqLjPQ08Nxz02gZ3oLZE58l1TOI/WmZIEJgcRorLZtRmRSIx0TEYyKWJ1oRrXkYpKxWPLLdGsa/Tp4M4R9jfceJNiNnYb/UkxvCZXzslyE3tie3bhzp7Qvpm/oNlasTcbe4UiVU4+3mQVSKlA6rNFnxeNkQQgd60LtzV4T50roN1ZX4bu6Iq6YNSa0PEP5cW/KzIsjLqUKuDEdw0CKT3UBZV8vE9JHY6yKIkLejRmaivI+FGmMSJDwvnZLWZaQNSCJ4tTtpNrkAxCtTiHBpw7tXR9IhWsXiF6TRbx/lxrXVh0h3bEMbnRfxihREawVFNlV41jhSYV1GlmM6jkZ3qhSF6FVqWoozWVbwMn6aapZbwtmiku72na09uJi4EZfrdrwXswI/dy3eJjsyMrXQxQIKsLhZkFcLbFbfplzWWNkVHZAJhAMWsPaxRpdbh4gFD+9wipIvQqIAaiC0PtrqbjafAKiAagHueqHZW6BKEs7sq3XkYE+SvQqxGDAInBkcRtvbhfRQ+LGvPoxwwdkf0ZuNTPHrT3lZBf44IxchPSWNPJNIREQAAQFeAJz+5SDFuflk3L6DnVcgupw0Us6eocfjE3H28WnyFSGKIqnZWdJ4Z5XzVEYUijQRPGZxSH+dH7L2c3xDDjYlWkgspm7yVKKcXHCNacXJI6cY5xVMeJYRfaYjardrgAVPvxTOnZvPc1MO8d7rjhgzXRn2qxI/62t8K8BhZQE2KKjDzL5jl7GckmExm7kddwUbtRzr8DZU2PdCRIbZAkeOZKGLP4W9iwvthg/FqLfwxbPvkpOcRnbUKsCdojIoLh9NgNde4HuUiidQq6Tos4IS+HQX0BcsdjDtDbiqkI6rGUgx0SCYAdxMgUXrGr8uK7WSGKapF44mDIVbKVI65eb90DlKEqJSFfDmF1BZBXtOwFtPS35qvTvA6IFNhp2tB6TtAOw9KaVFmutF2cTUFBavGMv82ck4OfjSPRo6tZaKAkwYBt4BfnyyeTm/5aeDkljXIggWzZGEvbwiqRIowDeb4fv37luMldul9NWdR2DcYNh/BnYdk+a5O0tVRH9L93aw9QtJVHO9P3iumWaaaaaZZppppplmmvkP4b9XMNPdY4SlUUt3Nwo5VNRQXdcoCFi39EKQyegRMYANHum00lmz74v9fH/jSpPVfbv7ACO6RtO5tZ4FeWncORvLDpmajIQsTqVlAPD5ngOEeLhz5MZt1AoFMwb05vD1W7wyfBBhXp6cT66hUK9k76X4Bk1BKViIvXEJFycPZj82mRRFAb/sWUlKYClV+6TQigrbALKcg7HPBzkCYdUKSv3ktPnkS0xZmegLslAgolKp8Hr8SbSx5zBVVPDyvA+4tm4PffxbUX4yAadqqdS2zCIjMrQl1cWV6Gp19FswkTG6VNYnxeM2MJKoMB+qkwuorinGQeWFKIpEa+2oLcxH7aBBZe9McHgf5HIlVOvA3pp2IeDqAGqFDdToQWdAEAROXbjCFyt/pNeTj5NaUkufCnc23f4C+S0RpfsWDov7yRZrWPjNBywZ/C1n5RcQEakz6VBhh1A/UjWbaigbUIYzzgDkuSVxQ5+Ce1kAZttF9CytgtI8HFrHsufJQIbUlqM6BlS+CBZX3K9EYhsNh/xz+SV3HeuFTSwJf56KnGocKz0QEKhyKKDbpfaoB8lgThmmdAHdtWy8U6WwEXVOCHPzXqS4KJLjTtGM7bgfS+Ar+AhBvL9kK8VeRVS4BjAiSTJGqjldx9Kh3Vkekoc8NZi93bZQk1SFqrOaJWefZb31UYKcPHjkZCxu2TY8U9mOujFmNB8rqIj7iYCju9isrmNVVDvcHBS8bdOS7T5fonZujWhKRmFS8vi5dyg2Z/JN0A3MpQeYVxkBMgsa9yr6K45xDg9KEi/gbngKgPC8EOaYviVSdCFT0CLWAA6AAc4U5eIXYE+5rLjRo0wAnJGqalpBbWA1Y9vPwYtAEo1x3LhzSYos0wPJIkTRKJgZgBrpZbdWoYS1C+LHm0ewJIi45VUSnpGPHJFkcx1FUUpp/UYN56ODeNK+M4qLhzHZmsAHLhXcIetUDufdU5ldVUdJWSanfs7n2IElODjYkpCwFW9vN+wcHSjOzUeQK9lxrIZrzw3BYtRzZc8+3jt7oslnWhAE+nTsxKVbN+mKEwpLY1jYIHUUjgHWvGV9CZsSLTr/QAI/+YLpLnI+/WElKYkneE9Wy3diN6xCPIHvuL1+LbZZUTj2Gs3N7EOMmuFIWcwgrBEIqZMxl5bUYsbezo6FpsvIFQrEes9EWXY5IRVWnGzryYG2e3A3pxN1awoZPy8mx1SGpU7HE9U1hHTtSk5yGr5hlYx/ejrr9rxNsG8Cz875mHHdRCY+9T12Nk+w7G3JZ8tkBofjYB8L4hPwUA/oY4GsW2BngpG9pP3NygdnB0kIuyuWBfoYmDhM1cTg3s4GQv2kdiazJHzt8oZVNeAnSKeJQg6fr4XKaohPhH6dGyO6KrRw6Kz0WiZIYllMK5g5DvYe3Yut4kWMpjryi2qw1kjVJhfP5U/Zd0p6TnA7DVKyYcZjsHY3XLgBegOEBTx4uQ6RkkgW6C2JX/cKYG7Ov789z+aiSM0000wzzTTTTDPNNPMfz3+vYOZoIxniyOVgby3lzwDYahg1rA9LzHpySsuZN34k6MzEmL2IESPBqGO1+eZ9q6vVG/jldCxPJB9DYbFQejGWl4J7AjC2Uwy5xaV8tmc/RrMFF1sb5jw0kNLMXIaE2JKenYy5c3se+uRLympqicvcxOG3XmX7hcvIqjPYd/YYZovI9sRKHprSG/u1Icy80BJVWR0VRxMZniygEWRUuIPWaEbVRUV/RxkfXzzJKUFBF4sZhUxGTU0N5TU1BMx9H1uN5L6+1v5l1Js0pETux9BLhkdgK+hdxWTXYYys7UVSVio2vi7EHD+PMb2Etko3Ulp50GvGGIR8KQpKEARuf3+Cq5/upbK9DfHt6lCrVLw55QV8vBrztfxcAWRg6wR5pVRXaPm13tS8W4gno2VGuh5yRWWRjsX4wkm0so7E29sXpVLJ0+FTcEvPJEBeho2+0T0+3u4yywK+xDHbifnOH2JXZkdIbgy2Sm9eVMyjo9lAdwCFklSHMAL6ypF9vgVRVCFYpDtgpQmiL8EGzwwAjKKRm+c30ko9k0q7Qk6234zBOQ+h2hnTOT2P7J5LjaYcs6nxrvmmEEtQqoIgkqiWaygw30RfXcipKgVW3b7mwxNvMaGVDQlORbQqd2ebSxbfl2awxLUjyU+XUx1rQjCDQa5H9f/YO+/oKsr963/m9PTeC+kkBAKE3nuXIk1FmgqCghQVEQsCitKLBRBFUFBAekd67yV0AiG99376mfePCQkBLPeq9/3da/ZaZ+Vk5pmZZ+qZ2bP3/rYv4o4FHNy8eMEllTfOjUQhyiEZVs86zKjitVgjUrvPAzQZTgzXRQGgslcjmiR1pElhpNS+FN+Mhpg9CjDnn0OOI1jk7LwWh67oMmYvH7bb3uUVp5ZYmVWMbrYIvdJEUa6OOnJvUsx5FKMFNewwx0mMB0iklxapGIAGyZYpk4ZfKN2HvdqF24lnwcECtgJkASZBUqP5i1JbFeArQgrcT8qiSZ0ILJkiCJDj6sjxpnXoeO4WtRz8yVYVSMtVSBbbNfsPYLGIkCNjVVI4rUN7MD1+AwkKHW843qd3YR6xd6XOFhWVkpSUgU3WGZrUdyGgTh8mfriFK0tepYPJiAAYtNqnXibaNmpC20ZNEI1GSi+dpfSGFo1Owy1zGo2VQXg0MGCZMgeDe0P6aRSolEry4q7x4OwvAExoZ8fqWcPY8uVlTp1wRe1jpP+aXzhx4mtu3YpH06wRhbsv8e6m+dSSu9Pf6IfzB/0ZVNiIlHsPOLdXKmv5Ur4PbmY17wSlYZaLZMiv07L4fZRmOQgy5FY23Dx7mRaDB9CsR0cyE4/TqsFu2jTayYF9HUhJ2smlRCPG1HBe/Uyq1PhQZSYAggGGpIOTDK5egoyvIQPYrZfarNwsEWafToBz17QgxPLJG8/j7fYl0LnaNuvfBa7dM6JWQc82SoZXvJvIGAUv3YMXmsLSdRATC25Okj00Ox/eeQkMJiiuIFEDfCSyDODFXtCxcSCHTrYjJW8Dr35cG09XiVDLL4JJwyCwukCwGnq3gyXrpO8LVksFAtbsqBp/P0kiztSq6tO9N1pSkXm5SuP6dQRXR8ku2jzq15dXgxrUoAY1qEENalCDGtTgvx+y32/yPwqNCvzdwceliiwDKeTGzpqJ/Xow/5meOJcZwdUefF0xGUykn4tj0Lsv0srGHVtBqkJnrVahUSoxCwImhZQhpbCXJBPOtjaE+njy0ZD+CIK0HAGBaRu2M3rLDjLumZi+7SjdZ36CWinxl1YqJY2CavF2aDRqC9VgvFHEm7G1eeWdpaRdvsGzD+Q4mmQoEBBfr8ONvmrMtgIJhQYMMjmTX+uDWiEj2KcWHaJbcGXtalLuXEdfYkTcY436pANlGYVcmbOL3Ds3YWwZ+EoKOztrW0oEC0p/T2KuX0VjEYm9e5vdu7ezfPkX2IXXxaCyYHbQkHr8LgBp1mVYLBa0Oh33ynPBRsMTUMjB350LOYnIk1Q8Lw6g2e2GbH6pNW8tCqciegyAKEUDZKKM3Ct5eNyV8aptPN2s87A4TQCXEWSo9nHF/hJmwUxqaRbJBamV03oYvZhbtx3t3/wIWeh3yEzfEzqnBWFHcjlR28SR7vYU+H8OTnmYBTPn6+1jkNCa+g71CJXVYoU5m/fLFmIokROYE41Ja8263u/jdDMIdbk1znk+mDBRblWMUWGiXGWsXLanawB13f25FFuH9Fx35rgcJU9VxHmHb3lPP54hqpeZb7eRXvneKPNNlNjKKXmoehRArS9DV9yOZhnltMwPQi5Kx45BrifH7QIL6rYjxMGd+GQXzsqzmK+5QLHlEaskoC/Xsr/gZ75peZAFcf0oLFNTIOhINeYRez+BpOx8Mu/cY5QlgqW99rFqlBa9UpIP2TqpGNSgCWHOVVIZIURW/YrxaBVMGZLqrBwSc29xvfQEJicj1AUCRWgoSuRYiQilVBUUqAX4QX55OSsf7AeLCHppxlluDmQM6MgzLy5DkaXGTqchSOFOJ1UkzUMkIraNzp6XE90I+/QsffzC6Z8DA5LL8XlhJN0HNqFWqDsNGoaxZs6n3FnUn6T57ShMus7ew0fJ69aNK00H0erV12j96Tou3njAup9WkZGW/MQhW3LnEPHiPLLrfsHt2scJVPpyR1HC6y+/y24xnKOZWl4+k45CLqd3p66V07VvsgdU67l9/jYObRtgFebHoSgVwWE+jBrVD3WkD6uSzyK3ciFVZea70BxiNeU0a9QRt1NVeWbXK6rePpcoWY39LHaMGDISlboqRCuifRsEQWD4B5N559vtrHy3K+vn12PPAg0yUTq2CnOr5GArpkOjSCm8v5YXPCu5j9n7y63KNrmFcLHi3/wiSTD63cdf8t2shni7xQKPsE4VKC0+jK3FFpXenoKCU0y1g9oCOKaJnNyWyIWYcuxs02nX+DDD++zk1FWp2MD3uyAyBLq1BD9PKSPsUXh5RDJs4BqSs6TsucxcKYPs8m1YtfWJblTDwK7gIznISc6syj17iDvxkJBWsa3vwbzVUiaaIEhE3KNZZa2ja8iyGtSgBjWoQQ1qUIMa/GsICAhgyZIlv9lmxowZNGjQ4D/Sn0fRvn17Jk2a9B9f7n8D/rmE2UOIoqQ0E0Xpk5oL8RmQXSj9bxEhtxiA4/0WcqT7XJZ0nMbpsmxKRTP13DxIX76QM9On8rJ/fVZ0eIFDrfrgHPkKVz98Fx8nR2Zv20P/hV+xceIYpvXrSds6VUnQMXIdJlHkcGwKhz58m1mD+rDz7dfZPu5bZk34HKd1WaAXuZWrI8zHixkD+mBfLOBhMmMnk3Eiwohd52BaLx9BcFAgLaIbcDiunJMp5ezO1hHTRGDIi0N4b/g4hnXvT5OQekREN0dtpyRVncoO560cYQ1ebSOwfyGSzMJMSXWnUoCtFR169sTJyYkOHTqj0WgQhCqWJK+ogG92bWbjwT2Ev9UTjbs99R1DcHVxIzAwiEaNmvzmpr9+7gpzSj5hmOEFFGsrxI5ewM/AUKAe0BRoDYVjiygUS3h4yCqVcSDPxBz4EwFRITipnbC3dWS1Yh0PSGCx4gtmq97BLmkjjVfOggsFkO0CQNHFRAxqOUa1nPj6d6GWE8vnvspno3uxZGpX3jS8gp3JEYASoZR4WSLWlnbIBSsATmuvokdPAYWkFudjbbFHaVLwbNaryFS1KHL2pG2bUZizB+FqDgHAHjtu1z3H9trfYjRbKBKK6WPIwWn4QIaPdmfX7T4IJVVkn6pcIjZMokCDBy0QECiUZ7PbcxUOtmCjUPKMR23cPJyxCCJxikLSTO441O+L0bUBxeUK4q/GcMvxErsSvuGDxts45pXBaUUarjJbZBXErtrGnmRZMdbOjXmgvYGL0htrmR15ci35Kck8VxqETJT2uSg8xt5qkKqRmiv+zwB0SHllIKXGPzxcFEgFV+tRFfr/EEqwOFrQGg2QLQONCGoRMQyONtWx+JfXCCtzpY7KB3fRnlZWYWyZOp1fZs5hh1yqeIqNioFvjWHwhElcGjGDH7V+rP/+HKJBIObqPVbujOen2x4ginhaleI27lWUffuQMvE9brR7l7taL/aeOsiDIi1zF3yGaJJWyqDXc+3SaUy2XggqSdV4M1LO2IZxHB4VxI30OFoapIqvLmqJQO/W+3kWfDOHGYuUDBtrhX57fZoLgSgM0jyNajkrt/zM8Q0/s+r1ScRdrrJ6imVyVr47m0vjT2AsqCJAN5tusF+Rhm28jtH7bbn52g/0fnEw8/avxzdUYpg3LljBpqXfYDGbObN+I1cPlHJqey1MOqlfPiEBvPjuG5XzDPKFpVNhzzIpmN/LDbZuPcqiGWNIu/0THlbXebEXDO8tFQdo1xiiIwAGAqGAJzCCx3En7gAmswGjSUfsg8O0UsK7iRD2xdeEJb3BiSVvcPqiI8cvdcJs/gVrjXRcNagNchl8OBYWTpFslEvXSdbOR/F8D3C0g7qh0vsNgLBHLJVXbsPHK+DU1erTvfSslDvWsw2MHgiThkrrJCDlrAX5Su2mLpaqfb67RFKd1eA/D4vZTPz1Y1w7tp7468ewmM2/P9GfRGZmJm+88QZBQUGo1Wr8/Pzo3bs3hw8frmwTEBCAIAgIgoCVlRUBAQEMHjyYI0eOPDG/ixcv0qlTJxwdHXFycqJr167ExMT8JX2dMWNGZT9+7ZOYmPir02/ZsoX27dvj4OCAra0tUVFRzJo1i/x8iZhfs2ZN5XzkcjlOTk40a9aMWbNmUVRU9MT80tLSGDp0KC4uLlhbW9OgQQMuX75cOT4rK4uRI0fi7e2NtbU13bt35/79+3/JtngUcXFxvPTSS/j6+qJWqwkMDOSFF17g0qVLlW0e3UY2NjaEhoYycuTIav192nzt7OxwfKzq8rFjx5667e/evVvZ5tF9JZPJ8Pb25sUXXyQlJeWpy6pduzYqlYq0tLQ/tzFq8HSYLXAxEfbdkP6aLb83xZ/CyJEjEQSBsWPHPjHu9ddfRxAERo4cWa19v379qrXbvHkzGo2GefPmVRs+Y8YMnn/+eaD6tenRz5w5c/7ydapBDf5dmM1mLh07w77127h07Azmv/G3/fd+Ix897/6TuHjxIq+++mq1fm7fvr1am7fffrvavcf/FTx6byAIAra2tjRq1IitW3/nrfX/AP65lsyHyCyAMh0WuYwFR4+Tn5rFe/16YW9tVdkkLT8bdx8nCq5JyhOH5FKcvK0oKNfSoX4dsndfJ6x9BBfJ51JKFvuARt6xeN2JRmuUVEd6o4mWtUNoVTuEtLwCLscnkZSbhwzJzdYzMJRwby8mD+iJxteDZz5YSH6QmRDBmbtxP1DmV8Li+huoV8sXAYE27i7czS3E4K4huKMzuzfP53qdNtTODaHEKN0AlOfrUBihU60GlVlfBQ6OaMpKsLGx44bNNXZ47qV/zwE4dKzLLCcpMf+NjHCi3EKqkryBYcNeYtiwl7h16waxsXdo27YDK5ev5PLZa2hsZYS8PZGBWSsAeO6PbPbMDBy8HLljc4uIskhMrUyoeMQPNRE4BMalJpSighCCmKn4jAElPRGtdhEgt2Ang7LaEaw8s5ao6EhmTH2d7dN38ePFjZwXpBtkZ4OK1+Ra0BwGY10QwLVlJLbWwZgy8wm49ApkyEjpfBRRY0vJz42YJy5isGkoeYp8fEUfAu0b8PnwZRQ7/0iTu72RY8VzqpEoNHI+HzZfshnuBrNgIULXmvONlRx+cJPdyTdQCh34JMiBF+TNkBfkI4/IwlInHZt8X+512o/GRiormOwYg6OhHnYWEbmopHtSD6aFaolX5pDtkIttoYrP3V/DiB7bDB+cvAPxCO9DV2UU94q/BKDV3QgGXn8bc/B7pGcPZadQxIeco0AUuXDhaxp17UqR7BoauRqPkPrkZWeT33w4uwpnImZ/TrFZ6osMOUIuFJVpiXRx4XVdA77X30IrFxHtRMxIKrQRtv4k3c7j2l0t5QrQG0SpPKevCO5I30FSk1XYNatBRLJqJkkB+/gAthaoX9FWhNFRvfjm1D5aNPBnn/k6WKCBTzgerq54lBaTP68vTneKoGkgmQZb8OtFU+t8Nr/3JpacfNIQUWLBiALfyEa4dg3Fq90InrXKZl2SVKFWgYBoLoeK9dIobIjvMI1lUe6sWrsZZ/UDmjZ057vvr3Lt/knGnF0HEQXUM5sozcmiBVl0qefHsMZVnsDWnd4BxsLeu6hn7KMLYJ8JBzvaYHbQUJ6Sxjez30QURTRunmhC61GvdVNunpGO25jC04wyTUVHOXkh2dxIuMAuMvAJKWHsyFrYOzgAoFQJqK0rCE1R5NjPOwmICCX11m3K7sRgHRaF0kGyHbcb8Aw+wQG/eV5aLBZEi4HEy0vo324IdjZRNKkLG+ZXtVm1NZCN++/RuYVko3wcLRq9zM27u5HLFMTET+KzHyRiytkkEYMKQzYqYyZGK3/qhiayfp6OolLrSsIKYNH3cO669L1emFRt0sFOEqe2byJ9AFKzpKqXj1a4fO9zSUF25ALsW16lDuveSvo8xMCu0sdskYi6h7C1gpIy6fIn/5tfKZktkJgmEZKP20H/qbh1eiu7v55IcW7VCwR7V1+eGbOUyFb9/5ZlJiYm0qpVKxwdHZk3bx5RUVEYjUZ++eUXxo0bV40AmTVrFqNHj8ZgMJCYmMi6devo3LkzH3/8Me+//z4AJSUldOvWjb59+7Js2TJMJhMfffQR3bp1IzU1FaVS+UQf1qxZw5o1azh27Njv9vftt9+u9gDepEkTXn31VUaPHl05zM3N7WmT8v777zN37lwmT57Mp59+ire3N/fv32fFihWsXbuWiRMnAmBvb09sbCyiKFJYWMiZM2f47LPPWL16NadPn8bbW1LAFhQU0KpVKzp06MC+fftwd3fnwYMHleSSKIr069cPpVLJjh07sLe3Z9GiRXTu3Jnbt29jY2Pz1H4KgkBCQgIBAQG/uz0ALl26RKdOnahbty5ff/014eHhlJSUsGPHDt566y2OHz9e2Xb16tV0794dnU7HvXv3WLlyJc2aNeO7775j+PDh1eZrNBp54YUXaNOmDWfOnHnqsmNjY7G3r1LvPr7tIyMjOXToEBaLhQcPHjBu3DgGDx7M2bNnq7U7deoUOp2OQYMGsWbNmsrj6dcQEBDAmjVraN++/R/ZRDU4fAfm7Yes4qphHvbwTnfoFPG3LdbPz48NGzawePFirKykZwudTsf69evx9/f/zWm//fZbxo0bx1dffcWoUaOqjdu5cydTpkyp/P/htelR2NnZ/UVrIcFoND71+lWDGvweDm/dw/yJH5KVmlE5zMPXiylLP6ZT/6dUUPqTyMioWs7GjRuZPn06sbGxlcMenosP8Z86tn/tt/lR2NraYmtr+7f35d/Bw3sDkO51Vq9ezeDBg7l16xa1a9f+nan/e1FDmFVUyvzp2GneXfY9AAaTmUXDnyOtrJB129ZzLzmBXs/0pdnXr3Bn0V6iO9dlcI8IEnNyaRYShCAIWExmvNTS5lRbTBTkZtHhyCZKtDoGNIumn28ID7Ky6fTxQoxmMyFekj/IAky7a0PE5RxuBxzFZDTjPa4zRQoLiJAplpGefxUvU32aNA4jp6iElM938nx2M9w/i8bRzhYx5j4xSRmszjlHHpMJJoC1HMZriD39TOGIgoAgQklZKd/s3IDOoMPF3onEjBTkRnAtUBLvZKBCSES8poQo2dOfFCMj6xEZWQ+Ayyduo9Na0JVYsLN1eKLtiRPHuHXrOl279iQ4OKRyeGFhATNnfoBer+NMx12I0dcIDWnKVDZh0JaQcP0ALvfq4Pp5BEoUWLCQKCRzQ3mXN+102GGh1OjB0T5d+WbPEUpLSjlz/DwXTl/G1ejESLk7F6TNh4+gkL60aQ21QddHxw/fbSBvuZpppgXS+qpLGXigGV8KyeQmuXCLZLKFHJYZFwOgR+Su9STMBhMpQbf4LmwVe/Omc0EVR0u707w5fiDsBrkoo2f2AIZnbqW9fTYARlFNbbERQau9AW+mfr2RU/X3Ye8ZQEFGCDl1LuFJfbQlGpRNhlBmZUfXw65o1Rp8msLgI4EU+cOx8LkYEyXFkVFbhjH0JUz2HrTV29Lz/AxcStxoWgI4OCI/1wo/oI9mPNNszoIIQZ5RDPaaiMFDT8zx6dRWanBsNRbR0YeiQj2Yq9RMIQYneibosDImcK60GE2RDcENWxBjVfXAMcTal+fknkzMT6cApAB/gACRjlolD8rMJDlaqooDPESFbRObiuFGwFzBjgHWHraUG0qlfLM8eLPeIDKbFHDp7h3wlqa7tjsBj/UDySkpQqlQsP3dj0g7eIo5i3bQsG1PXpswiHQvB07dFjAjUM9Wx0drF9GvX/vKbixs4oVz6h5iT15DkZoNbfuRdP4OGZlZuMVdIUXRhkWnjgFQVuaLe9w1DGpnwpoMxPfWAVJLcrDk5oGHF4bcPOrfPo1768dvuO3BWMWCZNw4TfydONotmYudkxvxdvbc+H4rlpBQPlVo6Vfbn317jrDrp72E3sthtvINEGRYy6seKFunBhL9jRLz1E9YGNoHPjtO/2mb2TIjiOS7jgDYOjrQfeJ4zu89jM5KIssad2lHy95d+T0MHGjDwYOtOX8+nEmThiGKki1RwiW+3gRrdzUCBHYelapi+nlWn4eHW20+mCT5ONu9JAl1j12EuW+NYMOSNeTK6tKmnT/P97xO7YAfAGtcHKumPxNTRZYJAnz0lTSPEH/4enp1YsnXQ/o8Ckc7iTCzWGD4e/DZJAj2+/V1fpwUWzoNTl2RbJeKx34hT12FmcvB2w0+f1ci8f4Mpn8Jxy9J6/btTIkQ/Cfj1umt/DR7IFWebQnFuWn8NHsgQ97f/LeQZg+VHhcuXKhG4ERGRvLyyy9Xa2tnZ4enp3TQ+/v707ZtW7y8vJg+fToDBw6kdu3axMbGUlBQwKxZs/Dzkw6+jz76iKioKJKTkwkODv5T/X38Zloul1fr16/hwoULfPrppyxZsqSSGAOJeOnSpQuFhYWVwwRBqJyfl5cXERER9O7dm8jISN555x3WrZNCAefOnYufnx+rV6+uNr+HuH//PufOnePmzZtERkYCsGzZMtzd3Vm/fv0TJMC/A1EUGTlyJKGhoZw8eRLZI/cvDRo0qLauAI6OjpXrFhAQQNeuXRkxYgTjx4+nd+/eODlVVff44IMPCA8Pp1OnTr9KmLm7uz+hPnsUCoWicnne3t6MHj2aCRMmUFxcXI1oW7VqFUOGDKFdu3aMGzeO9957r5qqvwZ/AofvwNs/P35pgexiafiCwX8baRYdHU18fDxbt27lxRdfBGDr1q34+fkRFBT0q9PNmzeP6dOn89NPPzFgwIBq41JSUrh58yY9evSoHPZHrgGPIiAggFdeeYU7d+6wc+dO7O3tmTZtGm+8UaVEFwSB5cuXs2/fPg4dOsTbb7/NzJkzWb58OQsWLCAlJYXAwEA++OADhg0bVjnd3bt3GTVqFJcuXSIoKIjPP/+cLl26sG3bticUdDX438fhrXuYMnC09HL8EWSnZTJl4Gjmb/7mLyfNHj0XHBwcqv2mJSYm4uXlxcaNG1m2bBnnzp1j+fLl9OnTh/Hjx3Py5Eny8/MJDg7mvffe44UXXqicV/v27YmKikKj0fDtt9+iUqkYO3YsM2bMqGwzY8YMvvvuO7KysnBxcWHgwIF8/vnngHTeTZo0iUmTJlX+Vj777LMA1KpVi8TERGbMmMH27dsrVekWi4VPPvmElStXkpOTQ0REBHPmzKF79+6V6xMYGMiWLVv44osvOH/+PKGhoaxYsYIWLSQnTl5e3u+u2x/Bo9vR09OTTz75hAULFnD9+vX/acLsH2nJTMnMoevr79HvzVnkm6QnfVtNVdZW6s8Xub/5Apm6YmKT4xERARG/vo0JfLEVgd3r4enoQPNQ6ab30uUrrN50gAKFmq5Wcla5y8nq2Ze0/AKKtVq8nZx4cVBXDl+9hdZgwGQ206iWP12a1yekVE5EmcRo5ydms/PIOWIPXOWHt16jd1RdXkuy5ljcQs7kfEWsPBl7pYr43XGok1yptT0Ch+Oe5C1/QKmXJ4IIQ02f0FIMY6vnB3z16kS6FHgiq7g+7cyKoVhfTrleR2JmKpgF6sc7UO+ZVrQXgokwOBFR7kD7Is+qUni/AVd3Kd/K1s6GkJDQauNyc3NYs+YbLl48z6pVK6qNKy0tQa+XiEp9qYFclxRulUhkzO1TP5JwdS/pMVU3plusfuEN1dtoLWVY2YtQMh7bgh9osqsv2gIdnc3tCbWEYDKZyBRysKhjWKxoyAfmIfQp3gQ5m2FvI1gMswe+z46f93BBdolytKSqymnQcB8jVW1onSoljCtFJaFicMV+B3WhQPgDSZrikVKH2wfSOam5h15m4du9e1lfPJMHvlLV1CPOaZgsIqHNbtPR151RYcH0LauSzsiKVNiapQcoJ4UD9YQBuMtC8QsIQuMcQdsYX+rc0pBbWkL5tvs0uATu8emU21mwdfFCbWOPo1ct2u3PZZR2NQM3W9MjuS1OKj1b/edyRV6MUSWlpt+xLaAkPIAIlR0DAtoiyOSoFdaEObhhZWOLOmkfglGLI46VN5GthUBeyfDExmhBhoC6SEtmUH1ibp9AEKsuFyd0ufTLu4CzTLqZl57zBSgVsCsSUN8T0OQgWTYfvszVVfxvDRWnlJRnZl9RBKAUdEk6uCiD6wJCgow2cybyy9VLZGQV4XzXgUXXX+P4lcU4FUhMhdFk4qutm3jttTnE373F1m8W4OmkxWwwAiIyLLhrs/lKE0BciXSuJySkEe7XlUXPzaDky8W4ZRylS0dffth8mf3Hk8kpqkWLZi2IjJCsjj6ecl6f8imOzq64WDlw++XV3H1lDYOatiFz+XeUrttERNcuJJZK87dYLOzbvo7DezdB7/rwdjcMLzXHdmo/pm5Yx4gBg+j//HM03bOP4matKHVxZ697LQRBoEH3urTwu8EudToFsjwKhBxKsvKobeOOm0VNrXxXuO2D3GBmTPw+Gs52JuT1AUzpVcrwD67i3u1DIpo2xN7Nja7vfEiO/TOUqWvj6ObyBx68LgGt6Nx5Me+/f5cD56xoOxK6j4WLN3MpKO7Pps0uOJSeBtGEWgkvvCPlff0aerSW/rZtBAHRzbnqvoIU1/FcuaugdkA04PLENPcSq77b20hkGUBcMqTn/M4qAF9Mg9YNJfVWeg7sPfmktTI7H8Z/ChM+g9yC6uO83WBwN/D3enLeu46BVgcPUuDSrSfHA5RppQIDK37+/cvo5dtV61Zc+vvr9r8Mi9nM7q8n8uQTLZXD9nw96S+3Z+bn57N//37GjRv3VLXTbxEhDzFx4kREUWTHDinTr3bt2ri6urJq1SoMBgNarZZVq1YRGRlJrVq/UpL1P4Aff/wRW1tbXn/99aeO/711dXd358UXX2Tnzp2VVpqdO3fSuHFjBg0ahLu7Ow0bNuSbb76pnEavl17GaB65x5LL5ahUKk6dOvUn10hCTEwMt27d4q233qpGlj3EH9mHkydPpqSkhIMHD1YOO3LkCJs2beKrr776zWkbNmyIl5cXnTp14ujRo7/ZNjMzk61btyKXy5HLqxjykpISNm3axNChQ+nSpQtlZWV/SG1Ygz8As0VSlv36pUUa/zfaM1966aVqpPJ33333BBn/KN59910+/vhjdu/e/QRZBtJ517Zt2z90bP8W5s+fT1RUFFeuXGHatGlMnjy52jkAEtnft29fbty4wcsvv8y2bduYOHEib731Fjdv3mTMmDG89NJLlce+xWKhX79+WFtbc/78eVauXPm7aska/O/CbDYzf+KHT5BlQOWw+ZOm/632zF/D1KlTmTBhAnfu3KFbt27odDoaNWrE7t27uXnzJq+++irDhg3j/Pnz1ab7/vvvsbGx4fz588ybN49Zs2ZVnjebN29m8eLFfP3119y/f5/t27dTr169py7/4sWLgKR6zsjIqPz/cSxdupSFCxdWElPdunWjT58+T0QbvP/++7z99tvExMQQFhbGCy+8gMkk3Yj+0XX7V2A2m/n+e0lsFB0d/W/P578B/0iF2eKftnHoQgwAq6IimNK1I/3aNecHi8iRSatpmysSs2g/A6cuZ1h5KeXl5XTt2p3MI7eQFZZi5STdVG89d4k952MY+0wnxm1dhqHi3ucs1mxt3AiXw2fRGYwMaNaIovJyUh/J/mgSEkgzo4YJEdkcyC+koa0LX989x2l1KYs2rubUrHf5PDaDQbnSxeRy6WW8ol4icddhdIWl7Pq5FOs9WhxilDi+1xH52nuIRQnsU9zgZcMkvh88mcud9tB5/TiJzBAEXuzQnxe7Dubu3dscO3aYK1cucyW8GOt9m3n55Vd5q6gRFJX9+oarLjdh9pLpXDh9iQaNo1CqqstYNRorrKys0WrLcXJyrjbO3tWLXs++QHriPWSNU7ljlcKz3pKsXCaXDsn04LMUpPthKFDg+IqasAMhWHJEdmnc6aZvijVgm2NHA8d6TCx8nbOyC8wTlmAjMxKlHYaTfiChiBBk5Kwij/RcI/3z/UgpKQMBDIKRzf67qNWuNROP1+b1jGc46Nid8IFj8C4OIPOCkbecTvJOWgStS9z4aPk+FgZ+RZfU7ugFkU76hhxRxfBK9x4cSJzG1slz8MkMp89Pa4i72o0f6r9CYfQsvDMHs1/WlJa1RBSKQtK7piPTRCLGJWGycsW6vBSLDZjNzoBIVLiAYAerNbGYb1fd+AuCgLNPMAqTEo9CH8IfhKIsugwJEhl32ryFOH0uV5RwanAafiUeXPRx51XxY2LyvkUZfwIxuAM2thqKlQKYRMoEA3NSxjJaG46tqKLQXI5zbCrFhixkCiUWEQLqdWd92g6CHRrQy38kn6dIb+pTLTpQwL2GJgJvy0jTilKUWQ7sVZswGoDYiv4LolQZM0lAaCRWKhnRI9kw7UXJDWkBS0LFDWuJgAjkJpVUboNCbSmvxPdEiYIO1vXR2utJzc0hNisDDz8n0hPzCHRXkZ+eytmTlwEBaxtrGi2/iYvOje8uF/NpexXzlv1IWlYxICcBR+qk5pGSmoO54ma5rEkDdr4xlpcvq4jLScNJbqJn3wqbTkYRdqkF1Hawgp7d+bJrZwwItD+Yws3CBEaFONDy5kYWfzwZgPw5qxk0dAQWvZ6sfSV88cFLmLSlzP58AwObt+H7PCiwQKeKZ0lvxTHu3hVRizKMiISb7Gie48J3mgSQwRrbFPrauOKRZYuXFrqcjwNckH3RBbeFt5h+7zp0Pw2fDeBAchfS3WTIBDMNeul+/byuRIa0E6Q9zM+/SKd8aTksWGPHonHFhKW9iSCayLXvTprbOACOnH+6NRMguUIRX1AMHi7QIBxi7krB/r+Gvh3hTgKYzVAnGL7bJokRG0dKJNajl6FTVyTLZePIqundnGFEX7h8R5pHSiZ0GiWRdp9WCE22HZb6AbDjKLzyB0VLnZrBuWvg6gT1qwoAc+wi7D0hVd+8nwybD0jD3Z2hf+enzwukwgbr90oWU+cnRbr/KCTeOlnNhvkkRIpyU0i8dZKgqPZ/2XLj4uIQRZHw8PDfb/wrcHZ2xt3dvTI3zM7OjmPHjtG3b18+/vhjAMLCwvjll19QPC5b/A/i/v37BAUF/SnbyUOrY15eHu7u7sTHx7N8+XLefPNN3nvvPS5cuMCECRNQq9UMHz6c8PBwatWqxbRp0/j666+xsbFh0aJFZGZmVrPM/Nn1eti3P7NeQOU+zMvLY+TIkaxbt66aCuxReHl5sXLlSho1aoRer2ft2rV06tSJY8eO0bZt28p2N27cwNbWViqIVFGRecKECdUI2g0bNhAaGlqpwnv++edZtWoVHTp0+LfXqQYVuJJc3Yb5OESk8VeSoUnA39KFYcOGMW3aNBITExEEgdOnT7Nhw4ankqL79u1jx44dHD58mI4dOz51fjt27KBv377Vhk2dOpUPPvig2rDdu3f/pmW3VatWvPvuu4B0jTp9+jSLFy+mS5culW2GDBlSjdwbMmQII0eOrCTe33zzTc6dO8eCBQvo0KEDBw4c4MGDBxw7dqxSiTJ79uxq86zBPwdXT56vZsN8HKIokpWSztWT52nc/jduDv8GTJo0if79q98Avv3225Xf33jjDfbv38+mTZto1qxZ5fCoqCg++ugjAEJDQ/nyyy85fPgwXbp0ITk5GU9PTzp37oxSqcTf35+mTZs+dfkP7ZmPqp6fhgULFjB16tTKzMK5c+dy9OhRlixZUu2Fzttvv02vXpJSb+bMmURGRhIXF0d4eDg+Pj5/aN1+D0VFRZUKd61Wi1KpZOXKlX9aOf9/Hf9IwqxxHUkNJZfLiA4JAFsN2FrxwqDuOM47RWFuMl5d6yEIAh06VD3t2LrY4NlfCs/JKS7huaVfYxZFDt+6g5VFwCCXyK0SrRa53kT68gVYRBGVUkHbj+ZyOjaucl6piZmIiQU0cdfgb6fCtlhLmrsFTFBUruWLXbs5r8/Dw1tNWKmCHV5lDEu9h7jgFDZjG/JOgw7kNS5kvv01opw3c6JFlYTCPqsMxwbOFN9KJfn4XQL7N5G8PhV+n/DwOigUCi5cOAdAVlamNKGLneRPksu48vF2En86Te0J3Yh8sxek5YLBBO6OYC+Fn7u6udCzXzdp2sJS6WOtAXdHbG1t+eCDmcTHP6Bhw0YA5OXlMnvup2TkF3HCrinrXn+RDqHV/VR1Wr+IrZMP9+KymZeyEoD2t9vQx6UnHWLaQhrslf9CUxpz1+4e475+lfIhWlqZmzPL+AFf+X+JoTREImMQ4LkSGtUxU+d9V8R8mGh8nW2KnaSTSXbfZnTtYKTZxiA0RiuG5wTxkb2Ma+G7aH7sUz4t8eID/+u0uOeK3FpBaHITGuulm9kdYhDfdl9P78wQ0u82o6jZDvxuN6djWn0Axq1fjHtBADeDj3NwkBbnQCusU3UkXbqFsverGOr3A+DUjcO4lV+jvcqdUMcdKF/rhyiKRG8ykRvWhO31wclagVKnxahqgG9WN5rGW6NsX0pJdiApXTLwPedGuVW5RDghcNGQQ5ZNGc6OdXGXORPQZQKy0x8ztifINRYcbx5BtJjxMtvwTmkDXEQNahR46uTkIXFXhSozBbX9cCq7Q5FnKQ7FOmpZ1cFPU5sUXax0g1kGBaJIgc5MZZnMWiLGfBHKHnnLLwoMSWiDVg/WtVT8mH1IGq6Gytg6OdLVyEOELFBYyTF5S29F7NOtKdbqsCDySt15bOz9Ec836sC3b+5DBB7k5eBtb8WKr9+ludV5Rp+ehlMdVwpu5xLVqi3u9pL92VtvTfmFOFb/vLuyaynuYXyRV8aKAVMZNaovOoOZgFavkJYHZRoFHj6SNef2pcuE3DmB93rJty8CwpdDkLcOJbXYwM1CSUWxP72MukVVkqW3T96jOLqQ2iUPOHZgO1lJ0oPdlnXL+bhpG864QZkI7pVCgw680GA9dXbUp1gwsVB9B5NZRGZnj6WkmCR7Fd8UJiG3FphaHoG7wg6l0czVci2XxzqTJt9PkWCk6/wCysJnAWAR5QjKp+cEVcczwEfAA2A2XVtWVZ8M9lNTVjAdQZTeIPvaZRHeDE5fhee6P31ud+KlipMAN+OkjfbFNEmhZW31ZPviUrC1Bid7mDu5ani9ECmI//JtmDRHmufALuDpJhUFAPhsIrRpVDVNRBBsXyoJBvpWuEtOXIbiMkm1VjcEZAIgSEUF4pIlW+TvoWtLaTlKRZV90mKBWSuk2jEXbkoFBR4i6Xf4gH4dpU8NoCT/j5Enf7TdH8XDN9x/1vomimLlPLRaLS+//DKtWrVi/fr1mM1mFixYQM+ePbl48SJWVlYkJydTp06dyulNJhNGo7Ga1XLo0KGsWLHiiWX9FX38M/OAqu1lsVho3Lgxn376KSCprW7dusXy5csZPnw4SqWSLVu28Morr+Ds7IxcLqdz587VrGQAPXr04OTJk9WGRUZGVutvaenTZZh/xT58fB6jR49myJAh1Yivx1G7du1qFpQWLVqQkpLCggULqk1Xu3Ztdu7ciV6vZ8eOHWzatInZs2dXm9eqVasYOnRo5f9Dhw6lbdu2FBYWVqqIxo4dW2mFBSgvL6dHjx7VlGq3b9/+3VysfxxyS36/zb/S7t+Aq6srvXr14vvvv0cURXr16oWrq+tT20ZFRZGbm8v06dNp0qTJEzlkxcXFHD9+vJqSE2DKlClPBJn7+PjwW3ho13r0/8cr+DVu3Lja/3fu3KkWWg4S8bZ06VJAyvTz8/OrRgD8GmFQg/995GRk/aXt/ko8fmybzWbmzJnDxo0bSUtLQ6/Xo9frn1CfR0VVL5Xu5eVFdrYUxTNo0CCWLFlCUFAQ3bt3p2fPnvTu3fvffllWXFxMeno6rVq1qja8VatWXLt2rdqwR/vl5SXZJLKzswkPD//D6/Z7sLOz48oVyVVVXl7OoUOHGDNmDC4uLvTu3fvfWcX/CvwjCbMh3TtQNzgANQK1BRVkF0G5AbmnE93PzaIsKQf7sCf9OLYBbpAjqcQ+nvkN5oobLEtuOWMTrFkUWoZZgN7RDWgVFISpQEt8aQYX7t3jblrVTX49J1dOXr/JxaI8ZEki72fa4l0uMMLJgY2CHounDNPFO0R4e/KLMofkkXWo2zkQ+w8eYCo006ZhfZSiDE+jFd0PykkHSnV6kIFMhHEDexC//QogYuVmx9GBS7Gp5UqtpQNYpbiMHBljQprSp09/EhPj6d9/kNQxmQyc7TAUlXN73i4Arn24mcjXu0hkGUBxeSVhVg0VlUQpLgcHG1Ar8fLyxsvLu7LJpUsXKMzNwgqoVZ7EvjvpTxBmCpUVQQ17ILNPQibbg8ViITkhhcFWVW8AiihmhHoMtmpbvrCeT8z465xfdokHHvHM+foznEUnWAIYyiBKjwoZKpVUsrGhGEWQMYCJXp/hazlIzJ6zaPo60nrbbJJtb3Ftr8AAu3doVSKx/pNzwpGPFrjrcoFDX22lwBTPK5aB2AiXmbC3HkJ2FK9bzWD9nVqElDkjIiIg4F4QAEDdB+3IvgKtjgF4IfebwF2FgvQ8A0lpmVzOEpgrV9PU9jp3POpguX2Lo19uINXGFbvWzUkMgRLNceTWPsjJwWFPMbENT9P0UBd+fqMNJQ4gi8pHdcMJMTeETfJgIhSZOAf2RW/RohAV2Gedxejly934OMae2YNWNIAABTI93qL0cKZDRGNlg0dYQx7cv8gRnzIEZQ4j5JGQDslhd3j3zjM0cupMpi4BY4YBEgRULiLPosZWENjloyfbC6l44gMRSkGlNuAdU4iiZR7TsodQ3syKncvPUGIqByfgcVVNoAieoNDJMFXkYmoMCoorCooJwU5caRZPp5/exuIpQooABWbSb2axZMVGth6ch+nnH/hw9gcsmDyUyydO0qJ7LL5BYbS5cAnLz3vRJ1eprQzZUqEDA6BWq1i+Ygo/HJEOY0e7cHIzj6MoKKLxsJHEfjoVZ8EFjSiXYtnuZ0HrUELslAwLtOdgZhlTI114ocsUbucUsiPDQF7T59meUsL8ACecfINRWtlg1uto01n6UbGRSXFuVXClXmkUIMNJVBEi2pHQ0oO33pvOsjPXYdESAMyIXGnjjEOIEzuXLqPEaIOtozu6isIFu5KuIuRPpG2HD2jZ1AEXdTFSmdLfggDMqPzvpX7Qubmk0GpSF5SKN+n1ihfp8Uk8M/pFPJ/iLEtMg2OXwM9DIpFAUoC93K8qD+xpZNnnP8LPv0C9UIlUe/S+4l5y1eXnaoUqbMshGPRIJFt2/pPztKlYTr+OsPmgpA6zr9jYrRrCT/Pg2y2wdhf8tFfKPqsdAC6OkhpueG/pkvg4HqmFAkiknLcbJKZL073QQyL3LtyALQelLLQW9Z+cTw2qw875KR7YP9HujyI0NBRBELhz586/na2Tl5dHTk4OgYGSjfunn34iMTGRs2fPVloEf/rpJ5ycnNixYwfPP/883t7e1apmbt26lS1btvDjjz9WDvs1ZdO/i7CwME6dOvWnwo3v3LmDvb09Li6SndrLy6sa8QcQERHBli1bKv9v1KgRMTExFBUVYTAYcHNzo1mzZtUeVr799ttK9RVI+2Xv3r2/+8D/cL0e9q1Bgwb/9noBlfvwyJEj7Ny5kwULpKxTURSxWCwoFApWrlz5q3a65s2bVyO1AFQqFSEhUo5rZGQk9+/f57XXXmPt2rWARHKdP3+eixcvMnXq1MrpzGYz69ev57XXXgOkUPdHFQLt27dn7ty51dQBD4sx1OARuP7BsMk/2u7fxMsvv8z48eMBftPm6+Pjw5YtW+jQoQPdu3dn//791Uizffv2ERER8YS929XVtfI4+zN4nHh+2gP1420eJeP/CmK+Bv87cPPy+P1G/0K7vxKPH9sLFy5k8eLFLFmyhHr16mFjY8OkSZMwGKrnejz++ykIAhaL5NDw8/MjNjaWgwcPcujQIV5//XXmz5/P8ePH/5S6+7fOuaf169GXWv/Kuv0eZDJZtetMVFQUBw4cYO7cuTWE2f8iokIDQWeA1FxpQIV3WmGlwiH8V27Q7K1BayD72G3O3rwvPfADvQVXIku1fHPdiVbrxnHh5ZVcyNtCcmkOB32lJ313jZmoWrV5pmEU7/+wGV1FsJgFuO1oIrhcQbcm9dl76SgXy/RkG0wsvGGD7NJECjwFGhQ5onEViCMJU+49oC4AAcUiyUp4t0FjrrspebZza1rXjkDUGQge2ISC2AwKryaStucq1yd6Ex8mvaE9RRL9+j2ZiwCgtNPg1jKMnDP3KA5Q8NV3y3mtzxBkRvPTyTKorGoIQKkWMvOltk5VP/KRkfXQWFlTrtNhcA5gRJPqYac3EkWu3U5ErbtO9y4dK0/y+LhEfPReWLCgF/TcEKTgn9KSUg7sOcLQV55D1dKBhrTG2cUJdgEHwOKtRBajpqTACEkCD3uyw+4O5YUZOBebsKhAZ1/Iu1OaEO9+l7p322P41gUTJuTIaZfnDt8fYpXsK1LMclIUqQQGxhBZlIvZtz5mzySCrofwwf0ZGDwmIQplCBUklIhIWkQK4XccAenBR+Flj4foRK2LAv0z/Jmf5I9xbUc2b19I7A9Sud6dZgMpCiXjfRsRae1MkMWTDFEg0ekB5bbHyC5Jp5G8C2W2YBZNXNKfx861mMIiN0a3ewWZQolcUGAtt8NSnIAyNwYlcOZYGqEOTbhQJCm8FBbprbRMocBOY4uxtBC5TM6hKDVJCgMvan3YoL0LYdL+Ncr1nCveg9oEGlGOrr6Z8BI5IfnSfFpolexAIuMIkQ4Gk0lBbXM0FlFko/oYC6dWqMuQQZ4FfIESIKjiGFIAZtDJqy7gbn6OtPKIwE7lSmjAEPqvfAeLjQVqAWY57CkGCwSH+hLu7E8P3+4IFgEnN0/SE++z/IPRxMZuwe3jg6jlCjrbunKoNLfquHV2xk4hY8jwXijk8HxbyCoEX5emKBXSW9FXTybh6JGGSkiidb477d0aoLFWQcUP1orm1R/iZ81YxI1jqZiKDbwW5kS4jy1n+6nNAAEAAElEQVTjR75KSLmZ3PvxLE70YdeMgwx9uQnN/B0B6eHIcn0zyot6REFDnkpPsotIfv45vG9FMaNLO977SoWxIpBr79nDFH95UuqDtTPyBs7V6ivISuJxjpvDL19uZ0NaOn1nzSS7oJyQ+pF0Gy6R5PEmuGCArhrQlJVy8cBx/MNDCIyUVBN+ntJHFEXi49PpPHQgqkfs11fuQFYedGkukVwT50BekUQ0VZy++HvCkKdkuT5IkS67YQFw+FzFNeA+ZBdIBNRD9GgNZ6+BTi8p0C7dkqyPw3pDSbmkTLsWK9kk2zV+cjkTh8IbQ54kv3w9JMWZtO2laptnYqrGB3hXVeN8GkwmmDwfrt6Bob3g5f7QMFxazqP9/xtjcSpx/rqkcHtUZfffhoDINti7+lKcm8bTw4YEHFx9CYhs85cu19nZmW7duvHVV189YZMDqil8fg1Lly5FJpNVEm7l5eXIZLJqN7MP/3/4u6ZQKKrddLq7u2NlZfWXPPD+GoYMGcLnn3/OsmXLngjCh99f1+zsbH766Sf69etXSQS2atWqWuUxgHv37j01q82horrv/fv3uXTpUqVdFZ6uhKlVq9YfqpLZoEED6tSpw8KFC3nuueeeyDH7I/twyZIl2Nvb07mz5Co4e/ZstUydHTt2MHfuXM6cOfObJN7Vq1cr3+z/Gj788EPCwsKYPHky0dHRrFq1irZt2z5Boqxdu5ZVq1ZVEmbu7u64u7tXjlcoFPj4+Pytx8z/BKL9pWqY2cW/dmkBd3up3d+I7t27Vz6cduvW7Tfb+vv7c/z4cTp06EDXrl355ZdfKgn0HTt20KdPn7+kT+fOnXvi/9+zNkdERHDq1KlqFWXPnDlDRIRUNCE8PJzk5GSysrLw8JBIkF/LZqrB/z4atmmGh68X2WmZT80xEwQBd18vGrb547bAvwsnT56kb9++lWpfi8XC/fv3K4/tPworKyv69OlDnz59GDduHOHh4dy4ceOpOV9KpfI389vs7e3x9vbm1KlT1ZTLZ86c+ZeUm3/Vuj0Ncrm82guv/0X8YwkzADQqcHWQEqGd/sCbJUEAazXOdbwZFRBJXsEdXA0yxr/1IhTq8GgWgp2DhosygYRtl8nxhxI3C3laM05qgc9eGIifixPv/Li5MvS8Y1E6w+T5eLzQjf1eZlL9NFCop1Alkqctx1Scy9tiaxTIML7tTXjfxmTvWMXGwwdYffoCkfYqope0ZlijNng5OSGzVoPOiCATEPRyUDkQ/ko7rs7ZRW2FB+cpRYZA6FPCtitXUyaj89EPWDVnMRfir8LVS5xpGE3rVm2rZZhVg6+bZMm01UBGhSUtrwQcbSun8fX1Y8nirzCbTVhZPUK8GUykFQocviYHAinMyMCwcyvPPt+b/TsP0d2uM4pk6VC1Eq3wFb25xg0A9u04iFfjABZNXAhmC9c+GsTko89hFI2saDEe//MR7Gn7Bc8tmYn7nO7EFqSy07iScaZniLh8jrhGSlT+ATzwWIOIiFKmIMQSzHDlqygEBX3NvRhg9iFIrMdtblPi6EMPp6Y0tQ6gR2sV/n6HaLK1JbVOBTFeZiHfehSfuL1PQGEA5waeJCs0kXbf96I4wB5RDvb2zty6YyCtowrBAkNWgvNRSEyRFHqiKFKAhQKTjh/Pr+AbYQR141qzIWwKBcoCCusU4mrSEBN4kqjjvsyrs5V9RXsAaOvRk2YqabsWa/MpkxVxOmEmzwsRqEQR+2IbWrm1w+hhICfjGv0NTkARiCItOrXkxI69ALwk78hXDhf4iThKrCsYhUIgRUBtJ2dShor1dXQk20KGYMEgiKhEgWRHc1VVTCOgBEumwC+aVJCLCOV3qCyZKRMlzlcN1s4ayst0YAfkAncFyeFZXwQbuCVL5pYmmQBNHRpauZOjzKs8dBxajOZF3wzKLt1kzMu9ePf4NyQYcuh+xIs6DYdws1sTuj7XBF9fNw638sJ5/x2irey50E5GcVkpyOU4D/sYncqerwy2tASs1RD42IuuS7Hx9BQkmdNFLx3dYwvgs32SN6//kz+AxvJiFviVUTswECu1FFCWduI0x2cvwBzckPWJp3DUGzl1KxE2jSYnP5/VO7YiFJXzotIOb9GM1cgi9s1fhwhcv36IIzcMjFvUlvVzw8hKzkCQyxHkCkSTEbPKEZPcGaU5H0EQKm9K5Dbu5JTbopArOP3LSYwWuH3uMpcOHse1li/LRk8mX6Xmp3LoMW8RN09fRKFSMn39Clw8qx7MRoyYwdq1+2jSpA5nznyLQqHg+j2JIBNFiE+B15+vCrl/eE8kAOOfUoDnTAy8s0j6/lw3ydb53TZo0QA8H7s0OTvAl+9V/a/VQ7kWSsrg3VekogSl5ZLlct8KaZfM+w6S0mHSMMme+ejzc2k5DJsmEWT9O0su8sISKdPMWgPlFQLE36uAmZolkWUAh87D2Oeqxr32nGQtdXOSChD8GZy6CjuPSmq/rk+J9zh6AT78Uvo+eTgM+I3MtP/LkMnlPDNmaUWVzEffwMDD60avMUuQPWI/+6uwbNkyWrZsSdOmTZk1axZRUVGYTCYOHjzI8uXLK9VHIIWzZ2ZmYjQaSUhIYN26dXz77bd89tlnlcRFly5dmDJlCuPGjeONN97AYrEwZ84cFArF/9dMqmbNmvHOO+/w1ltvkZaWxrPPPou3tzdxcXGsWLGC1q1bVxJpoiiSmSk94BQWFnL27Fk+/fRTHBwcmDNnTuU8J0+eTMuWLfn0008ZPHgwFy5cYOXKlaxcubKyzaZNm3Bzc8Pf358bN24wceJE+vXrR9euv1+5949AEARWr15N586dadu2Le+99x7h4eGUlpaya9cuDhw4wPHjVVWeCwsLyczMRK/Xc+/ePb7++mu2b9/ODz/8UEmsPf4QcenSJWQyGXXr1q0ctmTJEgICAoiMjMRgMLBu3Tq2bNlSTV33NAQFBdG3b1+mT5/Otm3bWLt2LbNmzao2b4BRo0Yxb948rl27Rv36NTLVfxtyGbzTXaqG+fRLizT+8ZLJf3U35PLKa4n8D1zHfH19OXbsWDXSzMbGprJi5eN4eG16FNbW1r+pVD19+jTz5s2jX79+HDx4kE2bNrFnz57f7NeUKVMYPHgw0dHRdOrUiV27drF169bKPnXp0oXg4GBGjBjBvHnzKCkpqQz9r1Ge/fMgl8uZsvRjpgwcXe3+FKqOhylLZv2hc+LvRkhICFu2bOHMmTM4OTlV5m3+K6TSmjVrMJvNNGvWDGtra9auXYuVldWvFvwJCAjg8OHDtGrVCrVaXa1K80NMmTKFjz76iODgYBo0aMDq1auJiYmppkj/T6wbVN0bgBQ/cfDgQX755RemT5/+L83nvw3/bMIMwNGGx01Rvwk7KxQ2GsZ8PZ4xwJbWs8jYdJGOe6dKOV9aA903v0Hq0TscURSz9ZddiIC7XE19Nw/UDtZsnDyW8d/+SGZxMa9n3kZtMVK4/VsWhXWkVGVFfX8/6mdCh6GNMHlGIJYDIihkCuL3Xsc+ujtjvl1Osd7MYQEapGYz7LvdNAsJ4tTH05BXXICWfLuGm9rbhJkDeH3/POyveBFpEwYe4GjRsOOTnZgPQvdanbFeZv1QBAWAXKUgrG0jziXGoFarCQgI+nWyDECtBI+Kk1xTBjoDpWYTpzfswSSKdB3UHaVSiUqloiq4Colkyy3GC+jnr6bEKGdbimQXeXH8EEaNHwHbIXteFs5GF8opJ0Z2o3JyHzsrbtyOBZP01v7Goasw6DmWXF7GCfEY8v7fgijwhXkEw2p/StThrqxWFRFidR7P3Bt4/gIMasMUh295cOE+vQ68wQX7WxTpJAIrXcgEY1/GEE1LxT6+93Hlhdwfea0olqItGva/2pm0sGukuq3D4XYRWfkmVuWvpdEz+fQ+UYrDT30RDcVgsiAgwzrRjGKwtP62xXDbNoZWhxpg++wYsNpMidqB9AId1nI5P9W3UOeqL8WKIgqUEgmZlZRD3a5NuSI/hUw0kXb/BFTwGpaUXPL8U7HW55B6dTVOOjUfKp8hySMOi7UXL2xvi1kJg216YjC2ZmfHTZIXEYGAiFDO3nuG0/Fr2clJOjr3Ya92FxjB0aJGvC9QpDegL7JQJFiwNkrHQo6VyHKFDrVGIM+rQkqTAFgEyAREAfxE8APRSoRUUZJV2iBlmAHlSh0qQYkBI+RXBEtZgBwRGTIs1hYQIEuXzI2kMxjKbEBVho+dFzee606L54cQb9Jyau1nPIiS3tKkeaXS1SUSlUVJYLA3BqMB9chozjV0pImtMx0C7Vi6axuN6zVhkUE68JPKjL96eLeMDCXpYhg+OfH4uNRHKvkJaB+RMt9MA5mAPsSVb7duRqvTodxvIgA1Qya9hpOPN4IgYC1T4aiXluWXVYhx9BrmeeZj661izM5iPPPNWBBZ+3M6crMMk9yCk4OJr+uE0NrbDk+rTJyaNMDVx5PjRiPmkkKUYZ154PI23Wsdo3vPWuw5dQPF0TgSLj/AObwWWPxx8PIlNy0VZHLS45NIj0/Cun4L8lu3I8sM5RVlGk0GI/ry6m+Kdu8+DcDFi7fJzi7A29uNguIqYiy/WLo8LJwCh85BsK+kFmtaD6Kru7UAiHlEkLLjGBz65kkVmtEkkV+PIzUTXvsY9EZ4bzS4OkokmIMdKOWSFXJvRRTSN1tg0ZTq089fDTkVnP7Ww3BijfQ9LVuybJ66IhUOaBgO8alSFlv7JlUWz4fw9YBGdSSVXZ/21cfZWP12IQFRlMg2N2dJwfdbmLlcyn07fx1aR0uk3qPIyX/69/9GRLbqz5D3N7P764nVCgA4uPrSa8wSIlv9weoM/yICAwO5cuUKs2fP5q233iIjIwM3NzcaNWrE8uXLq7WdPn0606dPR6VS4enpSfPmzTl8+HA1Iiw8PJxdu3Yxc+ZMWrRogUwmo2HDhuzfv/931Ud/N+bOnUujRo346quvWLFiBRaLheDgYAYOHMiIESMq2xUXF+Pl5YUgCNjb21O7dm1GjBjBxIkTqz2AN2nShG3btjFt2jRmzZpFYGAgS5Ys4cUXX6xsk5GRwZtvvklWVhZeXl4MHz6cDz/88C9dr6ZNm3Lp0iVmz57N6NGjyc3NxcvLi5YtWz6RyfTSS1KVEo1Gg4+PD61bt+bChQv/cpUvg8HA22+/TVpaGlZWVkRGRrJnzx569uz5u9O+9dZbtGrVikWLFpGXl8ezzz77RJvQ0FDq1avHqlWr+Pzzz/+lvtXgMXSKgAWDpWqYjxYAcLeXyLJOf15l8Ufwr9qsfXx8KpVmXbp0YerUqdja2tKo0ZNy4ofXpkcxZsyY38xBfOutt7h8+TIzZ87Ezs6OhQsX/q76rV+/fixdupT58+czYcIEAgMDWb16dWVxAblczvbt2xk1ahRNmjQhKCiI+fPn07t372rVcmvwz0Gn/r2Yv/kb5k/8sFoBAHdfL6YsmUWn/k+xIfx/wIcffkhCQgLdunXD2tqaV199lX79+lH0SNG+34OjoyNz5szhzTffxGw2U69ePXbt2lUZY/A4Fi5cyJtvvsk333yDj49PZeGZRzFhwgSKi4t56623yM7Opk6dOuzcuZPQ0ND/6LpB1b0BgFqtplatWsyaNatanMD/IgTxafrIvxnFxcU4ODhQVFT0l2d0/GUwW6BcD1aqqnRnwGg0Mu3TpXx/9DxdvGrRc0M6Tb4YQe1xXSG7EEqqHjTrvf0htyouDC4mGQcnvUqD1o3JKS6h3pSPyCsu4ZOkC0SX5pKqsmZMcBtMgow2dWozv1lH8r87S/0JXbEJ9sC+ji/lJTpWTpiDd5MgPjp/idiMLKyUChBNaCuUHTtnTaF7ZB3EfJExX7xV2Zdv0n5Ani8Hf2ALrFr5Ddt++AURaG9uzZS3RkELnaS0U8ggPR+zxcL55LsEhdfG0/NfyMUQRQqvJhKXGE/jqAgsFgvnEhJo2e0pVpqMfCirXsHvZnYatZvUR6mUiCXjQQOT1o1DRMRgMpKRJKmeuqsMvKzRs7dBC9acuQUmEblCzo87V/Hhmx9z/+4DhLb3UPS+CUCrK4N5e80aVik3Eq6MpbXtZURRhtb2Y6ydDXDNAUyRGFVGVlrWUEwxo0wjcHsk+ylOU4LJ+TXCTTkA7BnRAWN5IO4XTOSEH+HbTSWMpy8NPH/Go6AOFH328IAi3vc6ctEXp2JX9nS5zaAd4SjMcixtzBxuWEq6wZ6TsTGsMkhBTZO8tCz2NpF04nnOlO/kgfkeXcp64PmxK6tnv4PJaKRUKXLSz0ib+u2ZeWUC682rkTmXodabef74m6jNVlwNOsOFiPP0PT0Gz0JrltSaz3X7GPwcm+AZFk2X9gGEhPvTZ/UcduUcoLF9F7q5jOCzhOFYsBCEB/Y3IKYoB5VCTkQtDa3zbPg+MIfS+xYoFcDFAhFAPgixCkSzGZQSUWbtpMBVsCL5WikYBfAWwU2UVGQVXLVKa4VBo4Ui4FYFMWuLpDJ7BLKC7qjrdEekhDmNg6mjT6Pr9IqLtK2IrAFYEOlmDqWFYz0sFpHevbtw9uI1pq3/AZ3JyOrxb7G99Bzb7p/Gyr4bdf37k6k1MyPKlZdCHKst72q+jsVHE2hZVMLZIE9SjCJfRrlSZ+tFUMi408yH1ev2MNziSN1DCdKeruvNMZtCTjWwwlyqJW/7CaIHdeGVSRO4uGsv6ddi8brnhG16AV4lWg5lJfNqSSwvvdGFBTuMyEQpo2xsznpET0/KxTJccuNY6DgelUxJCQY21TOiup9DvEc63nVzuX3BnYCgcM6vXI7G3oGP60/Cu9jAt+o4rioKAbBEjCEl1wqPgp/RmNJRqlU0XraE8x5+jLABv4xUDm/YTmDdcFr0qi5TWrp0A3Pn/kC/fu1Ytmzqw9Oc73dIlsxXBkjEVXUUIckGn3xrn50PL7wjiXsb14El71Yfv2yDlCvWor5UAOBRhdj2I7BgjfS9Zxt4dZBUubJRHfByk4ivlz6QlGIj+lQP4QeY/iUcuSB916glsu5pyC+C56ZIZFXzKFjw9tPbmczVfiJ+E5m5YGcjVcZcswNUSvh2JgT5/vo0Iz+QihJ4uMDGBU8uS2+ArzdJf8cOlub/d+I/8fttMZtJvHWSkvwM7Jy9CIhs87coy2pQgxr8w2C2SNUwc0ukzLJo/79dWfZXYsKECZhMJpYtW/an5xUQEMCkSZOYNGnSn+/Y7+D06dO0bt2auLi4//lqejX4dZjNZq6ePE9ORhZuXh40bNPs/4SyrAY1+D3UKMx+DQ+rQirkUMu9Ul119OghvthzFKNFZMP928zYN4Ow7k2lYgAl2srQdxGRzvUiuZWagUyEL18bQYPWjbkSG8uo7zZQptOz5c1xOGsmMvOzeZw3CpgE6Uf75O1YPrOyYpTWwLHXVtP38mxEREZv+4FTgaX072rL3o6T2HDmIk3sXNl8/wrfn7qKva0NfabPp3YtX65/v4xemr4cLT9MotaEqcCCHDkUSHLKoqLiSlW6VqUF/1LQWsBYCHZWYDIjB/KSUjhy6igffDDrD2+6pC0XODloKRFLB0GUlN3i4vR4unsFnGyrfFwVyd51G0SBskqFZmkjYt5oxmDRVxZaGNUgkGcTrgNw4uQ1EKULrkqpRC6XMfaNV1g25xsctHUxGXyQJ+p5fv90BDSMsuoHxQ5guIV5ng3W7zpDgj0IZSBkojR6Mk4c/dTuhujsIHcyJseviIvWkOfphEuKipYXn+NodCF+nTzQZl3lq9ZnEIzpzPhqJgIqfuj3Els7rkNpdmHUzh24PshEYZYqbsaWnuZH/xmElizDw+yC4paFZ/Nq8bpORbH3ffa0zqLXz4N4IVuSZO07GYPJKCmU/F29+apzX5wbt2W6Zg/17umwGEGvlqNX6lGbrbDTOqL3asGqoQVEHL7FdUUMAKmFlxjeeSLBIQK3chPYlXMAAC91IAZRhwVJMVYug0m16nGnJJcDjolcsykkPuplbIq2U+qdBHpRyiID/BThpJjvAQLUFsERyjHRTxvKLcd8DuckQx4QCKQCGkAP4YYmJGbcpTgru0KVZoHsCqVZRQFOdZIMfeoBzEmXaPrCTLan6DmcfRcaS/10S3FgTKYbVlezGCH35XyUnuUB95m1YRtuuQ6UGaRKlpvOnmCX+iwAmuwTrPy8N20TJjDGSqTJ8WXUrRuMRRTp8/In5J86z1bbaDxFOf3ah+O5pMJ391p7APrVHsi9e8k4e9amrodkx5LfTKcTcF9Rxt20BwBcOXWKhPvn0MVZaFhgRVNDAAB6Jbi0CyHk2D2OfnOA9Y3a0Sq1jIPJp8izkaFy98aluBSz3IDeYkIlUyKqlQy9rURlDsDkZkEx+wCxl134aqJ0OdcXF+FcLB0fHY2eXJUXIsqUWPtFo8k4hMaUDkC7Ac/wbLgflXXZavkyZOr4px73Eyc+z8SJz5OVBxv3S0UAgnxhZL+nNgc+AGYDzYFjVMoJK+DuDFsXw4NUqWLl49hV4Z46ew1yC6X26/fB/lNSplmTulBYLFk5XR3hmXYSUbb9iESyrZsjqcgin3Jf/tKzUvVKuQymj60+7sZ9qTJovVDo0kIiy0Dqw6/hj5Jl2w7Dwu+l4gKhFVE5BqNUVOG3CLOlU+HSbahf++nLUqtgwotPDv9vhkwuJyiq/f/vbtSgBjX4X4NcBk0C/n/34t9G3bp1n6hs+X8R27Ztw9bWltDQUOLi4pg4cSKtWrWqIcv+4ZDL5TRu/5RsiRrU4P84/lmEmSj+tq3wUZjMVX8fmc7WxpYID3uuZxQRpLYip7yEgc+OJsDNlR8mjCLXwUiI3h4BAfuKV/0WAVLKJbtTw7AwDgx7GccIb+QVIcD7161h9+VrvLT8OworrFCaAj0FdzLw71Efa6WMw8cvsn7dYQB+yDxA216OvNykKUK+ls6dxrJiLDi9/AYAsUmpFJnK6PRpFz4bvoUr6SUM4BNmBQ9Ff+8oCVan6bF8BMVtS7CUwLgX+4FzhZ1OKQdrDWJhKXq9HhDoWLcpJGWBnTU4/3awT/mDOPLOShkNCZ/sw9HfDetAd2o3qff0CTQq8K/wFJbr2bf3CFs/2Eur9s0ZOVZ6ClRr1Lz5zjv89MNPXK2Yd5pvIDSry7n8cuI3Ha6cXaNmDTAajMTNfsCD9ARIAS7a8H7E+/iV+ID1RrDbwAOPOXwQXEidIpEPK8gLRGugXPpaQXwasHDAIZ1nih4+0RrA5IuicDSYDmJ1x4WWe9qSqypiyr0y6ubepl/WJfr9FM38Z6/z7TMzGXJ4CLcD7gNglOfhka4luKgnycEluGXL8bwfRqPLgdxoOJu+BQs4E9OZJuVSiFbmTV/S3caiLPkBUJOr0HHcx0K73v0oTSik3ZjBOHr6M3NXCnVyQggoDOOB7SEE0cyB+hsxp4UxNWolTYQBtLdqTk7APrwsoaRk3Mfe4kvREoEfnoXocCec1HYU6EvIv3+C+s5dCDKEEV94j8ysLGYGF2PjDslKLaDASelOpF1HfnH/gTqa5tzUSZa9THkCaETJsfiIw1Etygm0t4d8EfTARRlWXgq0Z42AwHVOgVqU7KUZQIYAJgHVNQ1u1iZCUqw4oyoDmYihNJ/E1DTyHf0wlKRJpBtQGqqlcf0eJP08F1cXPX1vWjHMJwmAHNsiPBycKdfrmdhnAEmHErhuzuTF5M5syD9IsTYftLBp02Hq1g3m/VX72bNGqhQ73y2Whd51cEp50u+mqGAwlucl8aZ7EAazHluFFQaLEVWpFmNOIQhw794JjNe1RLq1JVlmwSiIIBP4ZpgHeUoTnd2bU3zmBrkBJmZe2EZOkD83Nh6nbnIerF/Okh+XcX/fGZJ/OEKqQsd4vVQwQ5voRMFdBy4f8sJKpkQfOZpSm7p84N6S4eU7OFOagUHpTprzSzQ7NwmbDEulqs/d2/2J9fk9vDVfqgZpaw3bl0oKLZDC85dvlE7nsYNBrXqYq3AOeAA86ct0sIPox1ww5Tr48IuqF/6tGkqEmFYPX62Xhq34GY5+V/1SbjLD6x9LBQd83CUllrvz09dh0Q9SwQFba6ki5qNYvBbuJUqFBVpHwzsvSZbLIT2lIgYb9kt5Z307wJ4TUmGAp+WKPQ3nJH6fwhJoFgUIUl9b/U7GmYOdVOGzBjWoQQ1q8M/Gq6+++v+7C38IJSUlvPPOO6SkpODq6krnzp1ZuHDh/+9u1aAGNajBv4V/BmEmipL1r1wvhdC7/gEbiYcTFJVJaqtH/EAtAyK4umgBt+KTCHZ3Z/g333MzJY2bKWnsuXSNyK5SeXMREa9HykArEgsxVyio7APdMVnMWCxmVEoVcpmMvk0acrPhZ/w0YTXFVjD1vVFscdjIltm1OG97ix7ZzmhUSnQGI4VxBQxY+jUKuZzSTavAYEIEvnhpCEv3HWJg59a4Ojpw/34sLmoRAfhFuMSz7q6of5aUNWk/nmXGoRlS54rLJVukRgkONiCTIQR6kn39Nr1bdZLaGM2QXxHiL5OeVHXZRZx9RQr2bbHqVfL2bub266PAygmvLhNR2jvg0zoKzR/Z3gDWalZ/u56y0nI2rdtG38G9cHJ2BCAsLJxez/Tj4jGpQmZSUhq8O5vTn3xRbRbRBxtScLyQXEt+VZgrcNz2PC1tjgEnwQiTI26yK88Ah6C5gwtdih7myrhBm3IMnrEMic3likLLooSGoNSBUQPq02C1H0pHEJ7ZmfKLbqx1O04tZRFCkStBxruVywxJ86P18dfQK2QM3T2Hb56bRFBiA8KS2mGtU2AtaJCLYIU1z/3yIc5l2+mxywPZIy5EK8EehxaT8dwkKfQczSr61Hah5Rej4DLk5cHanuAm90Pr50eqLBchUyJ7Uz1KmewvVSGrI9dC9hEEcnGQCywJy6FcyKBDcT75pc4cuuTA+FrzUKpSGLAilDoZLnwRqCBeJx37pdlG5ugtyAU7Yt3rcUPYwj4xBhELN8tPgxmwQHSeM3V93TiankK8oQCZKNBZ7w8lsDctoWKtBDCAVjCAA1BUsaPsqcgwA0zSX0OZnowyOSZBh9HaLLHP9iCTpwB+qKzrYio9KtmSMTBoxwqOHvgWdXgkU6csxvaQFmMTOWNa9eWL6RMqt+tBh89Y/sk+xqe8Spzjbb7M34RMI3DzZhyzZ3+Hg3eVBTlOpaesoR82b3SqdqxZLBYWfD6eI1vP0i9bxvnUOPa1tMVGbqTkhy10a/sObSe/zP24GGa+I4XoBjcPR2lQk3peh4PGhjyldE1QejhR1+RA4zwb4t38SGjYhHnL9vPcwRjy3JzYsngVCQkJFMvywQI/22kILFdzuDSLzNdbYNQrEDGT2XAxCApSXHRc9Qnk+o5LaLyccXZXk30yC1sbe0SzmdK7McQe2E+rZ/+13IjSCsd5uU4kt0DAtyJ/a91u2HVM+u7tDoO6TgCmAV2Qyqz+MSxdB+crIgqd7OGzidLlV6OSVFn3kyVF2uPvPcxmqWImQFHpby8ju6JmRJlWIugetTAGekuEma21FNhfOwD6dJDaHT4vWUUBTlySQv9BsoHW+wMxEs/3kDLRfNylzLPne0BCGmw/LFX3dPsVgq8GNahBDWpQg78aT8tK+qswfPjwalU0a1CDGtTgvxn/DMLMZJbIMpCeqp5C4CRuPMvtBXvw79+EutP6go1G+jwKUUQs0yHIZEQGByAA7SNrs+XCZeysNDQOCiD+0B3udPHg+bIQxnZpj5eTA1sXbGHvtuOUf3eeaVcWIldJm71cp8Ns0VFk1rPs1EXmrv6ZprlyxiTakNPhLlkz61PmruOOqZDLD67z9qiBlL+1k43e5aRZiQT5eCL3cKI8LoOc43cY2rUFzzdpjOglPXmFhIQxrG9PGp6/id/aLOyv3aF20MvoStM55JFMZUqRvbX0eRQyGf4+fhJp+BBqZSVZBhD71UHSdl9FFGDHvFVY5V/GCkBbQPgQX3xGvvLU3aHLLeby5HXINUoaLR6G0rZqO0dF1+XsiQsEBtfCzt622nTeohcKFJgw4eLkQnlZOWdPnK8c38bckm6WTqCDAZEufF5wDY2ugDK1DcMYKoUS2aeC2Q1PjReQhBywUVY8aSNAQx28XogaDzafuIHhqgx1Dz9IPQY3fwB5OkZDNHJFOLLgzUQnnSA6LQjUV6hX0JvjDkrS1YnYuvrRd89MZKK0DjYGb9o/uIpGARn+EHwP5CJIOU8OqExyXtw5qdImW2oDeo3I/n62KL06cK2RGb/7xdxrmkhTt3pwWWpnex1Kuj+yiyyulLk3Rl6chGNwSz5VjqFYe4sQ/R0KLXeQC+AoqvGw2KAyOJHU2FFKmBIFnMXa6NWFZLhqqZ1hZkb6MJ5x+QBBEBgnhGMvFDE4I5Nw37PEimJVRUyZ9LG3qBjpVBeZIBBUy4H31SexCCIHVEkcSE4GJSg8BcQkUMsFylMEMD/CfFiJYA0kIf3VSZZMC2ZMLvbI65gwqyQlZH7JLjpauXBEVRsr7zmIhgx0yfMw5pjYffkisSpffvSNom6pjqBfTvNMVBi5ycm4+kteuLOZPjj0HstaEVzlEeR2PUCvXpPZuvUYW7ceo379UJQqJfVaRLFq06fYuD1Ztebg2dNcuHcNu3o2BA4YxK17saivX8MEhHw4nnYvjSA7P5/23j1p02gx8iI9smHPkWunxGfkWijW0fy6ltMeZcjP3uE1fR24ZSS87UhiX2mM57uSRdYlp4TsC7colulQqJSYDEaOW9I5rgFBBJVOBYKlYmdI29OBZK79sgPBYsaSkkCjzjfJifelqKAYQS5HNOjxiYigvKQUazvbJ9btaTAYQeWpQ2sEq1INwz+ysGmuDBdHcH9k80jfJ1d8/jXYPnIZKiiGaUulDDNBgGUfSoRTiN+T06lVMHsCHDkvWTZ/Cx+MgZ9/gWb1pFywRzFtFHRuAYE+UnVOi0Wq5nnuumT1fIhHIzcevk/R6asUd09Dw3DY9MgLdq0eXv9Eqva56zh8P/u3+12DGtSgBjWoQQ1qUIMa1OA/i38GYaaQg7VaIs0eJ4YqcHH8GvS5JeRfiif4pXZYeTpWb2CxcHbIFzz4+Tx+3aJou/Y10BoY16MTnZs2oPhILKHuboR6uDNp6Xo+jv2B9/r0oFej+gwSMzG5Q4yDibeKtagdrLmdcJ8lP38HiIx9bQKLf9qOUbRw2sVCu1wTEXnFNPVsSiwxxKyKIeabqwDMCGvI+5cfkB7txoTvPuHMiOUkbTyHoJRzq7YXhlIdPS5/CkjleocOHUl2YCwHvpxJ/ZDhhDk2B2dYmPFp1bqZzFIGmyhK28dGIz2hPrRfygWpNJtKWW2TODesBYJAYhQk5EsMTrcWrQi1scX92ceSth/Brbm7SFh3Svoe6I6lQyTDmwSiVsiZNustkhJS8PbzQqGofnj6HPJirmEWCUIS7eu1xmA0YtBX+f4USissJguJ6nJ6eB6jwLc51ko5QxsH4qv1gFMekL8CS0gCjWJXkVYri+lHZ9Os5BFr2iPZr4JKhfqlMDi7Ee5+h7l0BnJ5KkpdN8q9RmB9Yxxoo0ERD4KJoPJggpQboHAJYqo1p+r9QpvrAwDQaUBvBWjBIw2MCihzeIBjnmT1tDIXQns/ijqBZTnY5IHoLGBbAjlekOMtx9uphJaz6kqlAzuVYjmm4nILKetNZoaWdeG2CoyGzhgBsxyszDBYdoNgOy1ZVrA020i9/FqsfTCLM412cdOqG+6WF/HSjaTRSTMzm27l3fCL+PhaMzHGnwWRbZEJAmqZnDuZej4Orc0Dq1vSBhKRlGUVu8kgmNEKJmxQUmjWURGBBjmAXgA9mGxFfOurCM2x4qhNoZRnlldBmqULECZCy4pKmvcBE+AgUlhQirnIDG5SWy9jMLsPLUPdYQIyVQDkXoVMAXwhzyWAry5lYfb047y7D4Fnf+HHIYNZZzEzedvPRPfuRUJqPKLcH0GmoZQc5v30C4fvSueYlY0aj2B7NE7BlGTn4/oUsgyguEwik0VRpKSsjEA/f85evw6ItG/TiYNnT3Pu+jVstSIDcrXo9SLPdhnLndw8po0ZxKcN2tH1Zhopvxwk7XYMBEq2xdW6eObP20lzo8gSIYxYeQlZKiOYoOUzXTixdS8ATY0udDd6YgZiFAWItipy877DoHBnwDO2ZLm25Pzewyg9nfFyc6b+8MHsXvkjeq2WhsNGcvnyHXZufIHerw6j+4jBT13HR3HrAdwo0qNRSMecQSsjJVOyNQ7sKpFPGrWUL/Z70Onhu23S9yA/adqG4fDaYOnwXrdbGncmRiKtZDKwUj89k+zsNcmuGR4I00Y/md98876UH9ayoWRtrBf664owhULKCisqkf4vLKmyUl6/B5+8AaeuwoEzkgJu3PNSn+asgt3HJaJtxfQnK2o+DUZTVUZa8e+o4mpQgxrUoAY1qEENalCDGvzn8c8gzAQBvF1+M8PMpUkQ6fuuYRvsgcrpsTJjecWI+SUk7boKIqTsv45eFNAVFnN+0NvIHPxo8/07yBQy4rNy+PLQUQCmbdpO30HdUYoCJkFEaRHRZhejdrDm+v07mMySHSs1MYEhrZryzeET+Do68mntQtYc3MztKb3JzfbnxqmzlV3xD2/HM1+8hGM9fxRKOSqFDLWzLfr8Um7oU1G090btXF0x4tYyDIehDdFflp7KLFiobSxnW+BEOuyegqO7XVWlykdtq3IZuD0W1l+iBb0RHG3w69eEXtc+Y8fh3fgeU6KT6fCZ+SrRrdtBKXAAqAd4VU2enp7G3suHCQTueTnxcXY5bLzIjfQiPh/QCLlCTlBowNP3Y30I3xlGuCwMasGlGxdo3CGcRJ0DttTm9cMdkSFDaYF7OumJ991OEXzSK0qaPvsnSL6NmHyfMRmFjMi2wmKQ1G0PM8s+KrhHrcsFvJR5A+HYAUgYAgXxUDoUi7ERm+y9mVRvH7vTzcSJ6ylxeYPRpclk6BqyUv4VH+rbILN4IwCxGVHc8blFiwIf3D3teX61DIsgIhOlY7DQ2YBjniRJSdOKOB8rwlHpAF8CA0F9H3olwt06EH4Dyh3LYcoOWDIQHJYgczmJm641vinDiL4RQEY45JfrQCGtk6pARJ9+i1PJpzkjwrPNI0kqziXKyg25Wy6XO89DZ1VMvniEwZs7sdv2KOcypIqiabbl3G3oR23rAGzy75KXn8KKkiwyc0qQO4OgAbEIuAXu/n44e9ozzEPBHPE8IQ+ciMnNATm4NbAjQO3GZSEJiyiikoOjTs5Zv2Lp6uMmwjkRzDKQgcIix2Q0QxxQUHGuuouYrU2QJEA+UA7Bdepz3/4y+nNzYb0ObGQwWgM2AucTj+Fm9zypyRdwtXLFxjMc7Q1JiXj72Amie/eiUagDR89vQq5woklDP7r9sAkaWIGbkWcaNyMyuhYAP39znLi4FEIekzXlpaQQrFAjDw3D2cGBsFoBCHlljN9UhGA0ozp9im1d5ZyIi8XHwZHtgZBTqCX2bC4gsOPkJT5dMYWTWeWs+TEIQRyNtUHHm2oTb55YiNliYbMtuBhuoRJlvNp1MG5D2+FZy4+GHVpjSsqhzuzTiKIZAQFvoxW7StNwM+ykcdf2dBv8FtCJ7q+8wLWbt9mzeCXGwipWJjsti5ICqZT05UMnqhFmZgs8SAZfT4knf4hgX4gw2XHDsRBrUU7HenKiwqqkVm2erHL/VCzbCBv2guWx+syfvwvRdaQMNIsIe09Av47VK2Q+Dau2SrlqienQu71kkZyyEErLYfYb8NEyqZLnoXNSZprTbzjE84vg5emQWwD9O8HpGEn1Vq6FZztB+yaw+aBE4hUUS/liYkVfQbJYLlkL7/+BmBl7G/hkApy6IvW7BjWoQQ1qUIMa1KAGNajB/y38Mwizh/iNwP92294k78IDHOv5IVdXV1JRWIYgCAQPbErsD6dwaxKE2tWOc63aIEu9jkVUEL8qijrjnsHLyYEwLw/uZWTRLroedrY2DAmK5LuEm2RoRF78+HPilAZ61Q3Hw9kNhUxG83qN6BPVirlDBtLig9lQCOkmLcf3neCFRcsxmc142Tryltif4R3bI4swgVoByTk0m9GfOi+344uJnxHXRMDevvyJdRMEgfbLxrLw08+4cieRLFUWOcRTdgpurz7KMnkKWVl5LB81lBBPj6qqlY9Db4SsAum7wQjeLjjV8+eF06+gTpOIH0tZhazoTeAq4AxsByoUF9evx5AQoMfrzQj6d+tGzO1CdiXmkf/QMvtbaAUoASOYVppYI/+GC6pwbqq98DHoWYykfLExg8oiwyQz012jk5RQ8Q+w7F5HX7exfFl2m1qA0mxmR6vPibrfHe/sUF4OvMlGl2Re3xLCkIzhyMXRJGYmUOtmU1RaX5SiiudzazE+6BKrHYJJVthx3fUCoy93Yq96MReEdFabNbyMBQGBFI2WWf63sPa/RfE5SWl2O/gEOU4JNLsxlLOtI7hhWYeX0pnvIxcxdesa7A85IPMGXIFsyHOFQ71EXLONeGaEw+lwWAcEBJJ19Rr3lGXUir1G0AsBmG1BkX0Vk1dT7IpkDF0pclp9gyP2OQBsvpJAC3sfimWFXA86j7XeGZ1VMWq9HYRlMEP4HtEosRi1rEKpHfomKlRoNnxOfOkDMuWl4ARmjdTG3kaJTqEkOzmNgrRcYnqNIVt2jeyycinj3R7aW0VQx9kHKzsVGQn3GZiu4r6LhZsulqr9WkEgEiBicq0otmF4ZL8nCOAiQiSQJNA2pD93HM6BGmQ/mrAUi1BshjsmaKykSLAi99gXGHLuka+ywbn/ArTx16E0A+9nO9Nxw5uEOPrwyaCR6PUGHG3sUV0yUJZZilDHipKiqnPIVieSfOJWNcJs+8bdfDBjOYXxKcx8rQf9l8yVRpjMOBSakFtEruWUszEmlstxschEeObwRfy1epxrt+F+nsA77wwDoO7FOE79IFkvf3ytK/IxLWiRvY9Tt2/iq7SivcGVLiYvnDc/QBgp5Y2FRdeDaCA8gsLrD9i6aCXWopzT8hxAQG1VxXJlFhdy5v4tHHu2oPDwZVysrJHJ5Kis1JQUFCEIAj1ergN4IJ0oB5i1ogGHz0lZW8N6Q/MocHUCe1tY/6mMxBJnvleAm4xqOYF/FJsPPEmWQfVKlK8/J33+CKIj4G6CpHSr5Q0HTkuh/gA7j0vWyqw8sLaSrJu/hbhkiSwDySb58FLYr6NE5AH0aitV06zlVZWn1qohnLwijf+jVTMBWjeUPjWoQQ1qUIMa1KAGNahBDf7v4Z9BmIkVT2e/QZjJ1Urc24Q/OZ3RJAX/F5fT5MN+RL/TC7ycESwiMrOkYpIJJmw9rcHFASuNmjMz3+NmcgatercCYF9ZRiUnsE+fDQZYcv4cxd8vQyjWUxxfSkp6IjmuSt579hk+3rqLthFhuNrZYjJLBEJGaSFdZociC86FLChSgJ1RRCYI2NVypfkXr6A/c5ZBffo8df3s7OyYNuMjZsx4j6ysTGSFSsy2AlvEBH46fA6AT3fv57sJr4LLb1fCfHxbqk1VwT0ybYUcJK1iQAFQRiVh1rBhIw4fPsDwl4ejUirZGujD5GsZvN818veXaUSyAAKyIhl2vnb0yWhNG7kNX3s+4D2n7+hUEky4KYScKw0xOk/BZeYEeN8CA5xI10Sw26mMB9ZdeLkoibcTRmB1uoRPNUcZISrx7GqF3TkFXyQ0RlbBBPje9ufnMfEEbdbRMkXFMacstCo9bfNzuWvW46JQgOtYfL2ikd2VUWj0QkAGWBhfcoY6N49zSO1Kmqolpd73mDJqIPfuPkNAdBYfNpvKmoYfUEgyAKYzBRgzvThg0NGkoQ03ZXA/EpAJmJRVp6rhMljef5H9D4rRG4pI4w5Jt3Jx2O2P3L6UyCvHKFHnE+8RindOkERICSKFFivUVq6gz8epxI0Ox97gQa0L1CpsgG+/unge9iRDmwEIZOhS2JPzDa+fac5z8RMpEUrY4DYKawWkWfLQyix0do5mn/wOmMBsMeJcpkBmAUsEUHFIhCo8uWpM4oT8LoTAJbmMhpmKSqLFU3CgW207vr+TXq2qJkHAjYqQNJMAWpFwnTWCO1yJ/YUyRRlYgSVQhuymDGdne4bKPCjcFse+vuGUl0kWYZ2hHFPSAVR+fogGV74+t4s7985gLHDhkHNjhjRtx5YtRyhILJSO5TsmDl2/THFBOdF2LpxW10P+xXnizRZK2gZRNySUs4l3GTShB0lxWfzyy2lyb+ZxLlfLRF85h4a2x/N2Gt80DEGWEAdIm1+sOF9eqBfOpnwd+46eone/NqQfPMzp7HO0darHEIuWByUGercciN+VFLzV1vTwr08yWr5ua0vppqOkZPVgtN0OlEYtxeHOxJ69xF0hB0GhQLBI26tw5wXE4UMRPB1Iz86WTleZDM+6obw06iU8/H2Y0P5ZqW+iiKPrfSCbojw1xXk/EHOngXQKZ0tWQy9X+HmhdMqrVfCNHDZWcIrBCuj1FPvh+n1w9AIM7QVtG1cf162VVCDA2w3SJS4XXw/o1PzXT/3fwuvPS/N0c5ZUW40iJVWYTg+tGsDoAXDyMjQIr66Yexrq14aWDSTCTSmHVGnzEVqrqk2P1tClRXVi7LNJsPekRMwN7vbvrUcNalCDGtSgBjWoQQ1qUIP/W/jfJ8xMZkjNBbOFUoOZmE+2YxfsQdSMAQi/5/VJz8dcpmXIl99y7E4s814dyoienaSML4tIg8XLuP/FYhyjm+Hftz2olSTsvsrpIV/iFOFNlsoO754N6dYimtU7DyITBHxEFSnoaRDgx/1VJ7i1eD+CTGB9F3v25iYRYG3PzeWfYa2WGIe6tXy5mZSKlUqJc60qL1H39z/Dz9GRUZ3b4eHpwCtzvyMpp4AcmRPL6kY9dXXUajXPjZtAl28XkBskwzy4Hj6zFqCwCsAkyKgX7C9ZV38NaiV4OUtKM4dHsuBeRhKn2ALPVAybAWwA2iKppSrg4eHJ/PlLEROzwGRGoVQwoa4jWXEP8IyuKyVhF5Vh0ig5lHSUwvICWoa2xd81EDyBEOAemFJNtMjrwnPa9gC0D3an8wZHVGsU2K63AY5KQWH6isqGu5zRzhpAh+/zOOoEF2SR7LWxYYDVW+gEA9vsTxPTdRuzL0YhQ6i0aCbWTSDFYCbrRQ0jTu2jo68zWSfWY2uSJFBdwnvzILMPHW4F0dCUR7mdAkuJiKA5gJtqG88BFl0pu+1O0EzjyPWYYaSnNCceGN84Ex/xeQqFebhpwym2CaBjq19ISC6ii2ttRrhGo9dI2/Z4Jxl9N5vJ9c8go1U2TXs1xKe+P/GeUknB/KwcshWppF+5SOOC8bQ09GZ9++V0denH22kzyJVZccUjlgfBzVie8SG+nnIGeI7HqaQPXNvK4aO5jHd4jwSnYrZmf0GROQ+TaKRhfggAdqIdrW0bkhWupK5bAKcLtnPPImKONOKR50+0Qx3czv1EtKeCSypTJWF2yvAAFVXMglYOt300gFRu0SKINPB3x2wq46fcAiw+FQ2NFjiuQ2hriyiAp0FNiyzJHiyjhFtxQIEBYZ8RhVLOs139yf5pnXTOFM3ncKhkSxbsPVF7OyEatMgdHbHVRdNx1bdgsXAux5N2Gxtz+3Y8Tk52FBSUoNNK+zU6IIBJzn4o4iWpUt7R6+w1xWMwGrG2k1gXLz9nbCe+yM2zBzluXZcLp+/RZ8Nckr/azCh3G/o4v89Xe3bQtFCFcAFk9gLWcSpOxkj20DAfOx588QmOcmv8W/sT5XyT2P257D/8gIgyA9oyA1+4XMetewuMgh416XTL2UDbfRLB+q3PJWILk7GYTAgyOYJMonlvifnsHjeHgobuuPr7EODlzYOrN0k9eZVdooJRH79L024dOLv7IAB7Vll44R13PhsZja7sPp26rOec1QukZUv2zMxcST3VtsJy6fzIZdP5KZfQzFwpUwzgwy9h34oqoio2EcrKYfwL0LQevDJdeifRttGT2WP/CoL9qn/fugRMJkkVB1Klyz8CtQrmvSl9Ly6FH3ZDkA/0bFO93dNUZD1aw7zVMOQdGNlPsnDWoAY1qEENalCDGtSgBjX478WfeET5L0G5XiLNRJGr724g8acz3Ph4G6m7pYDv1N1XiPnwZ8ozCqpPJ4qg1XM9KZVNZy6QU1DE3I07qypnygTsoxvRaPlqgkePlYbp9BTdTCH0hRb03DGZ+JWH2eQ+hnecIri6fC6bNdF8dFXDR3ds+blrfwK7S8SWaBGJMUl5QonlxSSWloKtBvzcOLvuc76fPpnz3y3Cp3aAFMRvZ0Vsagabz1+m56eL+WDpApJypP7vPnme30KR2UiuUg6CQLZJT4PiHL5+cJIlCWcZ1eLpRFs12GikPjxaJs4aeAN4iSoKtgmwEOj79NkIvq7g7sjN3Gwmj57GexNmsHvLPsgqhFId8txiiksLMJj03Em/+cT0KlTI9FUqt8FRtXB2dsD2JRvoBLRpDa5TQVMIQGZLuK6MxrPkMB6FeWxyTaNP5CnsrCXiz1lvi9+wKcjjcqX+IVDiVMyXOTs49e3HXFw3jTSxmM4HvSiwSInhZzVuxCXnE5wWgsokwx03Akqc+GpUGoL1z1WdFeW0zWtA9J0ehGTVqZg/nLihxC1nDi1zMgiKW8SKpjEkiNJxEJuZhns6tDXD820hqCNs/eg0J17Zy32PS6TUi6djTA+sharSfSaDREKlqO6iMqlRmJUUeJtwzGlESFYd6sb3Jc6UQIoxgRYufZDLrRAdg0kil4SLH+Eat4sogy0DvV5nXMAsBnlOJqaLIznuoFfDV5qp9A2bTDunAdjIHbhZfgGDtZYsv0Sus48sIZ9MtRlNsoJIaqESNJww3OKQ4TpCtgx/gwstIrqiCAnCXyWlt2eLxXxWeJsHJRasfSrC9S1AtoyPF7/O9z364mg044QCkygSqyun3GKGIgH7WA2iRcSgN5GWr0emkvx2Gi8XlG16gp8NokxBu+f60XnFlxxu8gw2R89IAVSAqayE18bMZvr0lRQWliI8oprMvXqJZce3s13IZZ2mmM679/Hdov1cvhjLkV0xpCXm4ubojMGkJcSUS11jBrYZiRTfvMZH/jKKjBauG6yZ99KrDHzlOQb0fJFno5/htJ/EJCplMjw0auzlVsypPYr697wR9pXTkyxKwupilksn0m3k3DBL6yUUabn2YC/X5AVoMRFTKBFncrUGrdlCCXJEQGlRcSTjLuf3HWHP12vJP3iBvEMXEQ0m7l2WEuzbDeiJoqKIh5tvbTIStqMrk5Yp5t/kp3kwaVjF4UsVAQYwxQ4WOsA6Z2jxSFXIL9dDv4mw/1RVMV2zRcoFe4g538KRC1JbuQxWzZIIqrFVEWp/Caw1VWTZ0/DzfnhmnERw/RrsbWH880+SZb+GzFxJOZdXBGu2/3q7wpL/x955h0dRtX34nq3Z9N57h1ACoRN6b1JFmooooiKgoigqqKg0GxaqoogCKoJ06YTeIZQAaZDee90+3x8TApEgiPh+b8l9XXtlM/vMmTN9zm+eAi8vhOfmQEbu/bXdwD9PTk4OU6ZMITAwELVajY+PD4MGDWLfvn21Nv7+/giCgCAIaDQa/P39GTlyJPv377+jvdOnT9OjRw/s7e1xcHCgd+/exMbGPpS+vvvuu7X9uNsnJSXlrvNv2LCBrl27Ymdnh7W1Nc2aNWPOnDkUFRUBsGrVqtp25HI5Dg4OtG3bljlz5lBaWnpHe5mZmYwbNw4nJycsLS2JjIzk7Nmztb/n5uYyfvx4PD09sbS0pG/fviQmJj6UbXE7SUlJPPXUU3h7e6NWqwkICGD06NGcOXOm1ub2bWRlZUVISAjjx4+v09/62rWxscHe3r7O9JiYmHq3/bVr12ptbt9XMpkMT09Pxo4dS3p6+h3LiYuLY+TIkbi4uKBWqwkJCWHWrFlUVd2ZaqOB/wzGjx+PIAjMnz+/zvRNmzbVPnPcPI5KSkpqf8/KyqJJkyZER0fXmd5AAw08HP7KvUAURVasWEHbtm2xtrbG3t6eVq1asWjRotrr89dff02nTp1wcHDAwcGBnj17curUqX/1ajXwD/HfL5hZqiV3AAEs/V0AEGQCll4OlMZncXDwJ1z+YBPHnlhadz5BACcbQrw9aOQrub0M6ty2ro2nE9jXFAiQCaBSEv5SP/wGtyTufCLvnzvCPlMhcfO30NzBCf+m/qhEgXC5Ne5hXliFetDolf60Xf40C6ZPJNTXi6mjB9O4bVNwdwS1EiuNBY8/0osmYYHSchxtwMGG755/it7NGrP4mXG4WCoIdlBhY6HirQmj/nRzdPEL5qMej/BE09Z8MeAxWiz/Dp9mTej9yjRsmjT925u7XozAa8AA4Oa4QiEHW0tSUjMQa0JmM9KzQFFzSMpkWCilWC8/58Bbbb0LFZ0rWWazkl+sfyN7WA5MA24W5XSAlGfT2F6yH661Aa095d3gp46QXmTB4ClzcQv0BECUydjaaSGLS1/kYOG7yKp7I5O/j1ktxX3aFNuSl3EBgPL8VC5e1/BooS/uOQtZoH6NwvL5LEtuU2dVRUTEdBNahbROZrMV/cqX0kRsjIDAd/FP80V1FDPDu9BElLz5FKID10LeR261lxbyalz1ambfaEy3GAjrD1fS4UoqyIVb8WQyvYI8d4HS0K6g9sceRypFAa1dCFUuffgk+gKxjbqQ4BaAiNQXnUrGY2cicBc9iS0/iE0pCPkZmIpuYNBKF3x/uxwOV66kRCdVgMzyhTx3UOvgfOlFdCapOIROrKyz3mU2VqxspiXDUUTXyESyLAu9qK393cffmzRVISurYtikP0uaPhmAQS7P8nzI96h9+1ApK6tZOXB2tsHNQUNM/FVKlXKuVlexqSifYxXl3NDraNRsEB+++yWuXn74hTahWZ++TNz6K4N+WMOBCfNRevVFZTkS1a8JpMYcwNlCTpMFz1O4fzVa5CTghMuAUWirpLBqURRrj0OAn87msuRsLkNjTzLxwknKyqtJS8pj7/YzHNp5kYunr3MtPo3KSi0mk5nSr79HueRLVI1aMjNVZN7lQkYfzuJisRZsNRR/PITTS8cwY1g/1vhGcjKoA5NdWtGq2wBsFDXemjlGLl3Pp1VZJj0sW4JMwe9DX+A753YUpFiRu+0wVXotBywLqRraHEsbSRHyCg7g7e8+p0SmJBUVBXIlnmZJyZIjkJmYUrtelaXlTBn8Pm937InZYMDGwY6ujw7CJzQUWY0Irq/WUZidS892ZpxrNMzwgFv7WinASEtoWVWCySidK2WV8NPvUv6vH7bB9PFSyOXoflK45U1caxxYNRZgYwWB3lII5L2cfR82qzZLwtWWA5Bf9HDadHaAEF/pe/vIu9vtOgqnL8PlJPhl1/21nV8Ey36Bg2fubfvfgMlkJiYml3XrUoiJycVkMt97pr9BSkoKUVFR7N+/n4ULF3Lp0iV27txJt27dmDx5ch3bOXPmkJ2dTXx8PKtXr8be3p6ePXvy4Ycf1tqUl5fTp08ffH19OXnyJEeOHMHW1pY+ffpgMBj+uHhAEqm6du16X/199dVXyc7Orv14e3vX9uvmx8fHp95533rrLR577DFat27N77//zuXLl/nkk0+4cOECP/zwQ62dra0t2dnZZGRkcOzYMZ599llWr15NZGQkWVlZtXbFxcV07NgRpVLJ77//zpUrV/jkk09qxSVRFBkyZAjXr19n8+bNnD9/Hj8/P3r27EllZeUfu1fLvUS/P3LmzBmioqJISEhg+fLlXLlyhd9++43w8HCmT59ex/a7774jOzubuLg4Fi9eTEVFBW3btmX16tV3tGswGBg9ejSdOt1dOY+Pj6+z7UNC6pbhjYiIqN2WP//8M5cuXWLkyLpvCU6cOEHbtm3R6/Vs376dhIQE5s6dy/fff0+vXr3Q6/Xcjb+6rf6XMZvNXLt2hRMnjnHt2hXM5n/22gJgYWHBggULKC4uvrcxkJycTHR0NL6+vuzevfsOobaBBv5TMZlFDuVW8UtKGYdyqzDVl9D2X8j93gsef/xxXnrpJQYPHsyBAweIjY1l1qxZbN68md27pTzEMTExjB49mgMHDnD8+HF8fX3p3bs3mZmZ9S26gf8w/vtDMhVy8HMFoMUn43DuGIaVizVOPo6U5ZXXmt3uXQJIXmkIWAd4cO6nJeQXl+Lt5lzXRiYDR1soq5KyWGcVYuHnhvvQtjw+6Q32ueoBPdGBPuhKq/DsEo7XwBZYeTpgGeKBWa2k4FQyVz/dQfi0vlzb+DUA5Uk5XJj9K3aNvWj69lDQGyGzAJ1ooMDDAk8LJ6JCfAg9XMbFC/sYM+YJRuj1dO7cFWtrKf/YtS92Ijea8BvaCpW3s5SQp4YXIjuQnJGNv60D8gGPEDSg/rxn98RokoTCe412LwMxNd9XAd1v/dRzQHeSE1OorKhk5Lhh4GAHlVoEjYoB/sMxmAxYKG9LPBQC1p9Y8YzxSSaYHkdVTxbvRXMXo76iZgBSMiGZl9RNswhuzpZsebEPS48m0tnTlbZmN9psX4pgvRRMrmg1IteCjLQ5Km2vJ+xC+a0sjmilkeAWTSAblCgYm9EYb1ES3oqUehwMSgQEUIu06O0HiVqoAJmsEnuZAlE0YVSaCMhSMsgilKzMnwm8cZ2jIZ782n0e1YoEXH0jmFrqh21mJX1KXSm3hO9vG1CXa1vhaDDQY+9qvDJziY3wYk7uPvKVOXzedzI+Zc9yurCQpYYCLLBisoUfqY4Krk4vISnNjui9Ai2K7UmVfU+OmxnfbKhQ2rHY0wnBVsDF05XKILi6O5V0+WK81EF4WfiQEiwQdlFkvetedqQvJtgyko6u0aSXB3OmJAYTJsp1FVCzm0QLEa257qAwvUp6m14kVkouSwJYyKzo7igJvP0iniIm8Rfpt1wIlLuQlZPL4YpSSe4TBCpuE7RcHH1Q2Fkzc/F6AFoHZtHIVcmudVvBteZ4NJnRt4Zpq79iduFALAQRI2BExhm8mOStojRQ4LqiFCcPZ2JzQa+/1W+tUVqeVisNVARBwNvbheZRwfR7VBJKU5Ny2bjqCKVFlYALjz85ibN/uJZc3ref+QOHMzD6Mazkfoxx8OJsaSJvLpzGwcjOVPqF0TcljV1lF7i2pYw2vWw4pbsIZiNNYw9ytl0/9jdrwbDD2ylGR6sqW5wcHHh3+ESu+MkIb9sSaztbvt2wgg8/T6cq154psas4b8wHQWBLR2us/dypupJCZWwiyYqe+IbFYhb1FBWU0LbdBD5dNB1zTb7EzOQbzB7xDFE9OvHd+zNIyYKmdcd/bPxqJfvWbcInLIjpSxdirVHRNERKht++OQzuJn3+yDvPw6GzEOYvJeP//yK6pZRzzN9T8vbydIH3XgSN+t7z3g2lApa/A/nFUnt/xGiUKmzmFkm3JZMZmoXeX9tzv5FENkGA1XMhwOve8/ynsnFjOtOmnSUjo7p2mre3hs8/j2LYsPpFoL/LCy+8gCAInDp1CiurW1WyIyIimDBhQh1bGxsb3N3dAfD19aVz5854eHgwe/ZsRowYQVhYGPHx8RQXFzNnzpxa4eqdd96hWbNmpKWlERQU9Lf6a21tjbX1LRdKuVxep19349SpU8ydO5dFixYxbdq02un+/v706tWrjieLIAi17Xl4eNCoUSMGDRpEREQEM2bM4McfpRD4BQsW4OPjw3fffVenvZskJiZy4sQJLl++TESElKt0yZIluLq6sm7dOp555pkH3g43EUWR8ePHExISwuHDh5Hd9kwSGRlZZ10B7O3ta9fN39+f3r178+STT/Liiy8yaNAgHBwcam3ffvttwsPD6dGjB8eOHat3+a6urn8qaigUitrleXp6MnHiRKZOnUpZWRm2traIosjTTz9No0aN2LhxY23//fz8CA0NpUWLFnz22We8/vrrD7R9GpA4e/Y0a9euprj41lsSBwdHxox5gqio1v/Ycnv27ElSUhLz5s1j4cKFf2p78eJF+vTpQ9euXVm9ejVKpfJP7Rto4D+FzenlvHY2j8zqW4XlvDQKPopyZbDPfeTOfgDMZjMfffQRX3/9Nenp6bi5uTFp0iTeeust4P7uBb/88gtr1qxh06ZNDB58K2zK39+fRx55hLIy6WX/mjVr6iz766+/5tdff2Xfvn088cQT/8j6NfCv47/fwwykUYYgIFPI8RschbOPI5RVYWuvocuWV2k6exjtv3/ulr0oQlo+FJZBRgFqmexOseyW8a2Sb2YRSipApcDGSRoNymUyWswewe/DP2f3qMVc+ToGy6Z+YGWBNr0QB18nVPaWpPx0XGrCbGbBpI/ZtP0gF2atJ3vfZajSojMbmON9kXc0h1gtnOdcZhIV1ZVUa6spLCygf/9BtWJZ7sGrJH65i+CBzVGZTJB3662W3mCg3ZMv03zUZMa+vZAbmTn0fuFNRsz4gEtJKRhrPEbuSUU1pORKH339b8xrCQA8a75H1/3JwkLNtDee580PXsXR2UGK07K1BKUCuUxeVyy7jZiYfSxY+D6HD8dIHmy/ABsBM9g52HFZdoW3LedQ9no5VlOksMYBraFzE/BztGJ+dCT93/GEF4sRZFKYmijPI985mISIfEp8P6bEYyuDimbzrfAUE4xvQIdbnm6ymioOZkEkvakKAYGsvrB7koyzxbCv3fOUuYdCxTgwuyCIcrTei8mOLOVUlzg6nPsW9+IYWqccx7rMzNMbvqDrgf7oy/MosM1kU/84YvpLy/JNhCZnQVMpwzZbhdfFyVA2i4jTwynXFiEisvbqfjpHwEhXJ5YE+zLbwgpHmSQmnnOzp7SVgFijmcoEOXK59BBmbbChceCTiCGPYGkpo4WNL2MMzXHRm/km420id8/gUkg53Tu/z7ryGLLKk0koPEhJAuSfLqC7bAykA3ECXBegAKnIw22oDNKA5lbxDZBny1GeFckqiQfgWuVtbsspAvlFFehNRq4X5NVOVsrltPTxp094E7pZF+NmmYy27ARVxbvxdRHIupGKa1URgyvP45l9FEPpWhigprhDFb8snE6qtxav6C74dX2Od9+dSNd2ISSs/ZG2xlSC08/y0rP98fRzQm2hRBAE7EP98PTzqF2+KIqsX7+fX36eW3uelJdU1YhlEidLjHR10zAzwpG1Si3N9lzi3JYdhD7xOPHDmrC5nxVloY78UH2M1Bvx+P/2Necv/cCL/ULwe7IPTbp04FxSPlV6yTuva3U2zwTbsbpvGLMbD2B+VXPaKTzg2yNYLj5MeJ6AtZ2U29DF1YEP3w7hq6XupE6MxKqRL7/bFWIR4Ikgk6EJ8yXftj9lVu2RifqabSpQUVrBim+389j052jSoTUGnfTbpWOncbCFFuF35uw6f0AaOKbHJ1OYnYtMBl/OhJ8+gjl1HXLqIJdJXlJvfQHnr93d7p9m5jPw66fg5QYpWXDsAhw7/2BtpWVL+c4AVEqpumh99WV+3iWFoq7fJeU4WzMfet5noYOb+d0EboW7/jeycWM6I0YcqSOWAWRmVjNixBE2brwzjO3vUlRUxM6dO5k8eXIdsewm9+PdMW3aNERRZPPmzQCEhYXh7OzMypUr0ev1VFdXs3LlSiIiIvDz87tHa/8ca9aswdramhdeeKHe3++1rq6urowdO5YtW7ZgqhHYt2zZQqtWrXj00UdxdXWlRYsWfP3117Xz6HRSBWwLi1v3crlcjkql4siRI39zjSRiY2OJi4tj+vTpdcSym9zPPnz55ZcpLy9nz549tdP279/P+vXrWbx48Z/O26JFCzw8POjRowcHDhz4U9ucnBw2btyIXC5HXuPVGxsby5UrV3jllVfu6H/z5s3p2bMn69atq6+5Bu6Ts2dPs3jxojpiGUBxcRGLFy/i7NnT/9iy5XI5c+fO5csvvyQjI+OudseOHaNLly4MGzaMNWvWNIhlDfzXsDm9nLFHsuqIZQBZ1UbGHslic3r5Xeb8e8ycOZMFCxYwa9Ysrly5wtq1a3Fzc/vTef54L1izZg1hYWF1xLKbCIKAnV39b3+rqqowGAw4Ojr+/RVp4P+d/34Psz9y+2hDLsN7QAu8B7Soa1Oprc1zBNwa6NfbnkwKyyyRBs25xxNxGxjFt++8TKcWTWgRFoSfjT3nUwsBKDieADdywN0BjdlEm/eGEfXmI2ScuQHAwtW/Mrf0CrJgmHfFloQle7D//AmKLYzkqqRB9FXyeLFla/bt24PJZKR167qjLqWdBtFsRjSLCDLqjN7yikq5nJwKwP7TF/johw3sPRULwMb9x+jSsin7l8+/0+Puj1TWhNuZRajWSyPFu2EH/IxUMdPj7mZ3IzajmMs5JYxo7ouFUo5Op2Pduh8QRZH09DSir3dB+KqmvzJ4bMozXFH+hjk8CNsRkojoai99akkEcgGcwKI7ZvNRNqg9sC7MpNuR+dhrE0lUniDXrgNhhYPAFUi9Nbs11ixw+ZZWUeNpdVxAawu/tgCzHORG0NKZ6y90pvmL2psFISnQuHM1wB6fGyJGLFFQhWNIME9fWEa7g5Dimkhmy3iQQ7DBDp/MYjzzHWgrefvS+TCkrmiF4edqlIDCaMsTzi8S7NobnVjKsWvQYSt4H1KRJa/gx86rULd7Eq1ewM8VDk6AqN1wIRjMCrDdpqdYk0ae8gg2Zje0OhlH1myli9GNNjjyiiyGH21kpJZu5rDbQXCEWdceZ5zmEcJyHgMgvyyD1t59OVO9B183RyzsTTQKa8TVxDjiZSXITaBXUuNVduuYMlWYKa/U8ulv03CycSffIwMsQV2kwqA00apJMFVmHWa5KAmigogowoCISOQC2Fmr6dG2A+5JcTjaheDj7oGTlQ3Xzl+kY3URLZxteM9LLhVoLanCLDPQMqgLKrWSEJ2MymNn6PPuAmRyJ6KoxmRrRdOeETzb2I6SwgoK88oIbOTFym/PQWo2AI1b+nH1fBrNm4zj/XmT2LnrKFdj02rXqdmgHuxs0oFd5/JZrdDyyIebAOj6aCRf6xJRAHqVjKp2vgTSgfz1vyJTadBgplPCSR5ZNp8OHZ7m5IlLdAuypZGbhnHPjcXCqgJjdgm6Dx/h8KzlqM9n0B3phv/zJ4uZMLYzgiBwKTGB3/btQa41kLV+H1llLmisHAjOKcJVbUd2ThbeNpYYrMtI9vgAn/yvUBtz6BFih6NTCe36d6XzsAGsX7SCs/sO02PUkLuekz1GD2Xrih9o1KYFrj6SGq5Q1A2/rI/Tl6WKlQA/bJHEuIfJhXiYswxcHGDBy2B3l5eWggDuztA6Ao6el6pqhgXUb/tnrN0BS34CO2spH5t7Pe9Vlv0i9cv/Nq8wO2vwve1aWFoOX6yVvNSmjr2zmudbz8Lm/VIf/Tz5r8RkMjNt2tl6b7eiKO2zl146x+DBXsj/ToWIP5CUlIQoioSHP/jB6OjoiKura21YnI2NDTExMQwePJj3338fgNDQUHbt2oVC8f/32JWYmEhgYODfGoiHh4dTXl5OYWEhrq6uXL9+naVLl/LKK6/w5ptvcurUKaZOnYpareaJJ54gPDwcPz8/Zs6cyfLly7GysuLTTz8lJyeH7Ozsh7ZeN/v2d9YLqN2HhYWFjB8/nh9//BFbW9t65/Hw8GDFihVERUWh0+n44Ycf6NGjBzExMXTu3LnW7tKlS1hbW2M2m6mulsTgqVOn1gq0CQkJADRq1Kje5TRq1OihiYv/i5jNZtauvTPc9nbWrVtNixZR9QquD4OhQ4cSGRnJO++8w8qVK+9q89hjj91ToG2ggf8kTGaR187mUd9IuibghBnn8hjoZY38Ib4RLC8v5/PPP+err77iySefBCAoKIjo6Og/ne+P94LExETCwsL+8vLfeOMNvLy86Nmz51+et4F/P/73BDOlArydpUqP1pr6bVQK6QwWkWyU99hMznYcmfQtlSn55J9PZXDSp9gHuvHy2KG1Jk1nDyNz4ykinq2JU6qoRqgZGcjVCvx6SMng84pKAGhbpMRDKyN942nsLX1oNn04XTyLuWTMwGbdz+xN/IK5c35EY+Nwxw3eMdKfNisnkXUpE4/O4cidb40avd2cmf74cDbHHOf1Jx+9Qxg7eO4SZZVV2Fnf+aa9DnZWklAml90qhFBDSmEFkzecxcVKzdJHW6FRKaRwvQcQy5ILymm3aDc6o5ld13L4YVx7lEolnp5eZGZm4OcXgGC+bR2M8Obua2yusoVz+XRtk03vcA/e3n6RlSeTea5DMO/0bQqRQAfgnADOrxMzMYeRP0pvhg9VnuCypScDPHsispsNzToxpJ03jL+1GAsrNdMbN0JxeizIfSl56z0osQARRm4Dt8vAPjDK1CgAETN5Dl3p/xuAA/AbRt8SrB+1pN33O4D++OeF0ETZlsQO14hc8jpqrQlP/ffcLDOqqoCjJwQuDbOkw2kdDuI2Zp07xfYu7amydKYgF3xiQECOtzmUflnuHBAEKrQQlwaoIO1mFVNElj51HbukTQiARl9Ebvotrw4zoJDJecTRneNlefwOoIRQZ298nrbGbb4ruWV5NDUGMrb1S7Tp4ERUfBkGrQ6bfH9eSk8iokJOfFiNx6IAXuoAcnJTMRWLKAsUGDBhMhvJK83ASxGER6AHmU4XKcqqJO1GHiZvK8QmZkloVQkocy34Xn+I8jgtxblV/HAqhU1vvY2PC+QUF2FnaYXj0Mc4fiWRzxa9hqgUsQt1oW/YS5R7vYdGJZ3vOaoU1u66ynUcwQQO7RrRY0QnMmu82eydrLF3ssbd2QknlZyb74M1lipEUUSr1SOYBPZuW8bixet58cWPkMkEqgJ9ayvvllXc2pa+rr48N7gXB48dx11uySVnK6J1b9D74nNciC7maJMsAlylsHFLSwvMIhxIKsE66STZicms//I7RFGkWad2XIw7gUIpUI2RVkYnegsBJOw9QYqlkesXr1K44xhyG0sS8v3Zm9gBgEW6LF4US8gUBL6KdCW/whYsm3Pday6NUifgYq3Etmg9+9d60nfCAh596VkefenZPz0vu44YSNcRA//U5nYycyUhSxCk3GXllRAVIVXIlMn+XoXM29mwB3ILpc/R2Hsn7B/RW6rWaWsN9g8QEXD2ivS3tAISUusKZrHXJK31x23S/5XVMGWMtK5/rNr5004ptxmArzuMGVD3dwdbySvtv5nDh/Pv8Cy7HVGE9PQqDh/Op2vXeyizf4GbuQvv+ZLoPtq52UZ1dTUTJkygY8eOrFu3DpPJxMcff0z//v05ffo0Go2GtLQ0GjduXDu/0WjEYDDUCbUcN24cy5Yt+1v9ulsf/04bcGt7mc1mWrVqxdy5cwHJ2youLo6lS5fyxBNPoFQq2bBhA08//TSOjo7I5XJ69uxJv3796rTbr18/Dh8+XGdaREREnf5WVFTcV58exnpNnDiRMWPG1BG+/khYWFidgVT79u1JT0/n448/rjNfWFgYW7ZsQafTsXnzZtavX18n59399O32dfs72+p/kYSEa3d4lv2RoqIiEhKuER7e+E/t/g4LFiyge/fud+TUu8ngwYP57bffOHz48J/mzGuggf8kjuZX3+FZdjsikFFl5Gh+NZ3dLB/acq9evYpOp6NHj79WsvyP94IHuW8uXLiQdevWERMTU8e7uoH/XP73BDMAC5X0uRsqJfi6gcn053a3oS2rJv9cCgprC5Q2dwpxzd8bQfPnu0NFjWeWgw1oVFBQLo0EalwKZk8cg8FowiOzGr44g7NVCM3ihyFMFHj85Uh2V/7Ewd++h0Zdybt0ioAOfe5Y1u9HTzPls6VEhgaydkhUrdt/UnoW+09fYPrYoXw07ela+8iwQFZv28dPuw8ypm/Xe4tlIG0XfzeKzqdw7e1fce8RQeAT0gPi+7vj2HFFSgocHejCM+0fPF9LfoUOnVHy9ksvlhLTy2Qy3nzzHdLSUvH3D+RKOlQlg4MDBBXCN+vbEmJ/hc9843GzsUBnNPHhnjgAPvntKKP8NIQ1CobmwDHgHHQ748Y7fZpwLaeMZlcH8UXJIUyCVA3shFMBQ4q9wRq4GXpVqYILm0FVBBShPh3LwLHtMJjAdXlN53NBbyug0INJLiMow7XOuinS7GG6CUyfg30M6aFh5PSypGm6nDhXVw6GhhGeu5vIhNE4lgpkdYUSW+kTWLga99hf8SqHpld2UK4Yh0p3622NCAgueVxPi8Pa0gdXZ+8/bFkBlV046+yLeelKa/I8k6BmPoNLFFZ+XiR0mYifnTt9zBB4vgtJWSKZYWEsSL3Ot95fIj98ndbypmwrV9HIeSR647cIQNq1OLyULpwvyYMcAbylm08352HMGtGWD385wJ7K7Xg7ulKuM1Mt6in3TKO/S3NkYncORV8jxVRADwtLGqubkGyTzGj3GaiUBlYceR9yFYDAuesxnLj+DJtPnmDKiq9wc3Ciout0TAY96sHvIyjUOMcfpr3zI5heHoDpynrkKbFUh/UlecebSK5rEBzZCJWFBalJeTi42tAusilrV2xm9andjJ8wmPYd/anSV2JtqyEzpQALjYqeAzthMos8//xwvlyyjvgrGSQtXcPwlk3Yt+UQk37bRtMXnsbS149trcJ4YX8aY768ysrmlVwuTcGmRTOKfE6CZ1OOrU8gMdCLcWOGsm7dB7w8cgq5MTto1iaSaq2+TjECAKMgUhQWhNtlLYhw+rtDnOhkRdHO4xiLyjAWlSHa3FJkSgotwLECL9GS8hwTcqtsNOlbsbbU1uxxqKpuTHUV7FmzgaTYyxRk5dLv+RdI0zahaQiE1ESRHTgFeUUwoLPklXU3RBHOxIGro+QRtWEvxEl1Hhg/GHp3gOx86Puc1M6St6VQxnshiiKXj57GztkR3/DgO37v2AJiTktt3m9+MN8HEPJv8vhAyMmX2mh7W82U/adg9lfSd0sLqNJKedse61t/O7ev+/1sh/9GsrPvLpY9iN39EhISgiAIXL16lSFDhjxQG4WFheTn5xMQILkprl27lpSUFI4fP177Qmvt2rU4ODiwefNmRo0ahaenZ52qmRs3bmTDhg118qDczbPpQQkNDeXIkSMYDIYH9jK7evUqtra2ODlJFTw8PDzqCH8geURt2LCh9v+oqChiY2MpLS1Fr9fj4uJC27ZtadWqVa3NN998U+t9BdJ+2bFjB15e907YFxoaWtu3yMjIB14voHYf7t+/ny1btvDxxx8D0rXHbDajUChYsWLFHbntbtKuXbva/G43UalUBAdL16uIiAgSExN5/vnna4ss3Oz/lStX6u3/tWvX6hQS+Dvb6n+R+60y+U9Xo+zcuTN9+vThzTffZPz48Xf8vnz5cl5//XX69evH9u3b6dKlyz/anwYa+FeQ8ydi2YPY3S8azV2cYu7BH+8FoaGhtdPuh48//pi5c+eyd+9emjVr9kB9aODfj/9Nwex+UMrrJMqvj49W/8qZKwnMemYMnddPI23DKZzbhWDhcpeHXDcHsDeAQk61wswJdS5+NnYEmuxrvdjsbaz5csbzAOQMiUOx1wJhd437RayW3s++hMogp3PPydKDeEHZH2INYe63P3M9M4frmTkcOneZnm1boNXp6ThhOvnFpSz+ZSsXflpSa98yPJiW4cEsenXSX95MRx9fQmlcBtd/OIJr50ZY+7vQzFPqj1wm0Mjt7z3wt/N35qNHIjmbXsTsPk1qp2s0loSFSeELR5KgqiZf64QvwLlMzYKySIbM8yM314HiIugd6s6507G0TjzKKxP38ursqXTzvfUGWPATeLdfU1gKHIBnld04bHkCYyMzL8aGwnYkLzk1oKuZSdceVOcRzU68FfgKmUkZTAvYgPB6a/gBaAuKQ6AzgroKnFPkVAWDRYkJWYEcg/o6MgKo8ArFLvMCPqYu+EwbgOhg4rN+VZSr5ZzyL+J60zLC4+3wU1VjUaVBqwHvs8EgkyGiptHZIdjnS12KawYKA+giitioTyHQtyfV2gpKygqwt70zXixLpsOx2oc8JMGsojAbk48Xvq6hqGWVfLT7KmadI2pzK5xKSum3VYaaMGLc4nhK35oTnaDIFcAGk3s7Ki5v4WpyJl1aPYptxxAOHtmMvzaCzPwkrHqVcSLegZMJZ8guycDDJYyK8BSydTfwktkiEyVh1EvuwH79FdJ0BUwOGUXXZs0orrTixMHfYK8ZgkSQA26wLe1Hrh+R8hrlFheiKkxD4SUpF6LBQMXuS7zxeTeGTXyVl7oGYN/MlS3FYbWVeRwd7ejdtx0XLsfj5muPQW9kwduLOXpMavN8wmWatwsCbCk32xDUyItrF9KIGvUBUc+NpuW7T9GyoIhifMg3WNMyI4kNG6Q8RjNSrnGyQye4VsKURXsoryzl0MplGPU6yk+fJ925kox16YTnu5N+Ppajk87TMboFPx74kYqiIizt7dFVVXP0cBop6QYyXEZw9oPBVCpUpJmsGPf6KjCYSPOWRH2zRrpeyVUKVqwcxZSpZynKziEkOJeSfCUXKcRcdobA6+sRi9NRObuBg5Sd3mT0InF7Hqllq2qPjbcWW1KpBLVKyve19SCskGossDUGfpx/9/N2xa/ww1bpsrZyDjQPhV93S95krSIkgenHbaDTS5+TF2HYfXitb1+5lt+/+wlBJmP6soUERNR1k+/TUWpfowbLuz0rFVeBSg5WfyPDfw2R4bBmwZ3TM3NvfR/YBaJbQLM/8egf2AXcnKR3Nc3/uuf/fwUeHvf3cHu/dveLo6Mjffr0YfHixXXC5G5SUlJyzxxYn3/+OTKZrFZwq6qqQiaT1XkrffP/m1X5FApFrYgCUn4wjUZTZ9rDZsyYMXzxxRcsWbLkjkT4cO91zcvLY+3atQwZMqRWCOzYsSPx8fF17BISEurN1XYz10tiYiJnzpypDVcF6hV7/Pz86hQQuBuRkZE0btyYTz75hMcee+wOr/v72YeLFi3C1ta2Nnzm+PHjtXnaADZv3syCBQs4duzYnwpT58+fx8Pjz1X4WbNmERoayssvv0zLli2JjIwkPDyczz77jFGjRtXp/4ULF9i7dy/z5s2rnfZ3ttX/IvdbZfJfUY1y/vz5REZG1oqktyMIAsuXL0cul9O/f3+2b99+35VzG2jg3xV3zf1JDfdrd7+EhISg0WjYt2/fXyou88d7wZgxYxg1ahSbN2++I4+ZKIqUlZXV3ts++ugjPvjgA3bt2lXnhVAD//k0CGYPyOm4BF7/4lsAsguKOfTNRwQ/XU9ZuNsRhFqPtW85xXmyUMhkvC/rhQvWd5i7d4uA9oASKDDBECkpYoc+zyMTax6o6imJ3atdS45euIKHsyNNg/0B0BkMFNdkps6tCft8GFi42lIaBworNQpraQA6rUsYUT6OOGhURHj8/VJ4r3avP6/HTXycIT4TnGzAMgg4D7KWAmELHNEXwp5BsKBzF06dy2dzzTynj52l86yOyL+RS/GHIYABsuPAQ56Om1nL7uxuMA8YWzOTFlAhnTVGoHow6KI5GX2NN5Z6cyFsL3sHzqVDj/VUtVOQ+B5o0uI56LiflopWRJW1JtYLmhSUYosjWrU/Rzr9SpnFp3TOL8M1QYVcBKFIjpqmlHMFa5kLT35ji6YadBYauqgzWRlxHOfCESAPQcQKe9OtY6fEEXI84ZGN9rTu35NEQGNhTUbxVUSNGQelKwazDpVcCi+c23oGFwM80V9KRCzPoqS6ArX5EHGXD7Mv1YUAi2FSu4Z81Af2E54q5S47al1B1y4vE+LckQhGAGDlEUTsSSc0fr4881RPdOo0hmpPkHJGilv79dh67OzaEp8pJbE6n3wA0U16o5RmLuKiIY0wtScxuqv4KJzZduYiP8YcR+4u8F7fUXy8ZiOE3hQ5RJAZWf3lJhQnzDh2d8a7SSBJbtJDqK1ShjbpBrlnLwBwatv3tO7YCQwwwFYk+933yIg7xAsvDCNfl48C6TxSqhTIlCKWikqqjFZYW97yMN1y/AaJey5L/+hSqD68j7KcXATAjxKqrV3p2j+aVnvOkBZ/g+EThnKyxqG0yFaDurwAk15SWyuy0ilRKnjbuS+jrTwwiSKvT36Prd+tYEq4A141SUI11lacVb5GmRs4m9Yjt4si9dsdJO09ws+vjGXUwE60Fqoo3rud/Ve2ItfB9Pc/JzDckyWfV7LwmRWcVrtytX8wRduTpfBbBytwisBQkIOhpBClvRMykxl1sU4SImvQCVKlOL0Bjl+A8opTCEIUoiinICuL0gIL7JzrT2aaUlNF22CExe+u4rVZPVi30Ae5/FbYYp+OkjeYjRV0iKy3mTsoyMyR9r7ZTFF23h2CGYCTvfQ3PkVKsu/vCS89XhP2ufcKvP4rWKph1QQIqqec5UNgWE/IyJWclMcPAdv7cNpt3eTeNvfi2g2pCmm3NhDi+/fb+1fSqZML3t4aMjOr681jJgjg7W1Jp04Pf58tWbKEDh060KZNG+bMmUOzZs0wGo3s2bOHpUuX1nm7XF5eTk5ODgaDgRs3bvDjjz/yzTffMG/evFqxq1evXrz22mtMnjyZKVOmYDabmT9/PgqFgm7d7vGc8A/Stm1bZsyYwfTp08nMzGTo0KF4enqSlJTEsmXLiI6OrhXSRFEkJycHURQpKSnh+PHjzJ07Fzs7O+bPv6WWv/zyy3To0IG5c+cycuRITp06xYoVK1ixYkWtzfr163FxccHX15dLly4xbdo0hgwZQu/evR/KegmCwHfffUfPnj3p3Lkzb775JuHh4VRUVLB161Z2797NwYMHa+1LSkrIyclBp9ORkJDA8uXL2bRpE6tXr64VTf6YT+zMmTPIZDKaNLl1oi5atAh/f38iIiLQ6/X8+OOPbNiwoY53XX0EBgYyePBgZs+ezbZt2xAEgW+++YbevXszfPhwZs6cibu7OydPnmT69Om0b9+el1566aFsq/9FQkPDcXBw/NOwTEdHR0JDH3JSzXpo2rQpY8eO5csvv6z3d0EQWLJkCXK5nAEDBrB161a6d+9er20DDfwn0NFFg5dGQVa1sd48ZgLgZamgo8vDfRlmYWHB66+/zowZM1CpVHTs2JH8/Hzi4uJ4+mkpyup+7gUjR47kt99+Y/To0cyaNYtevXrh4uLCpUuX+Oyzz5gyZQpDhgxh4cKFzJo1i7Vr1+Lv709OjvS8+seq1g38Z9IgmD0gro52WKhVaHV6fN3v/QC/d+8uDsbso5HGhz59BlDZSk/SjiSyTmXxyKgA+odH1j+jBfAuUKmHbOltp8rKGizU0mjUQToJ9WVVKG00CILA7IljGNO3K64O9tjWxE3ZWVvx8/yZbDpwjKeH3BnG+aB0/vUl0n49iXP7ECycb3mTRQf+MwPR+ugbBa1Dwc4SrlrHkbzvBl0conFeaQ9Ay+NgXSZj9IX+5MivE6u+yMG9R1FcieOV7i3BcxJMklPiCKd7X2NQ0vsIRV9LubNGA7drkvpbX0ucQdnFibYbOyCIAr1OPI1b9WnI2MfZtD6k+8Kp9EWUKcs4ZX+UUS4fcKmDP62O25EuZPKedh6Vu3UsKG2Hh+hTZ51G7O3GuVZtcQ0rQmES+GESlDiBc7EH7SsHU3EBrAVvYhtB89MgN0NKMBjbwrAFICCj5QnIcjOQo8smRvs9STeuY6Nw5M2g5YiiGhDIKJAyiMuajgPAyZBGaf4WTGagulA6/oBCQzbXHWIxMQIEgWvWpznoeoGDXGB2gQKlqKfcVI59u35sPfMNJT+vZOeN/ZRnlYBMBLNAsUU5PxV+jJ9nY9KyriLKTWACZAK2ggUbtWdol6Bk2EUTfee9T7+YWQCYysxsTztJpea2aqzpBtiqBaWA0SAyvfNQjAMHMS/2Ksbi/UT7N2XeuHYMWuvPtWsptGl/W5JPWQ6dOrrR9/XZqFUqdixZRsHSr6kcOIjsYhP5ScW0NeXj7ljE2aM3iL+Wjc7BjRuGW6qHRZNwTKHNsXJ1pTy/mBTRnvLyKvr+egnzs1MRgaPO1qz2s2FvagFLBmnocdGdtu2ncCIxnhMdBlIU2pLkKwmwNxG5IOCRk8vs+GKulOrY0u3W8dCrvRTSaKG2J+r39RxbLA3Gpr39JaOeHYQv9jw1+ilSlv1A6pWzmG9IudhcvD1wcHOmOD2PMt2tbScgIpqMiCYTVYnnsGrUAhycSaCc8DaRdBjYmx2/HKEodTXZLk/j5mrNgmWlzJ/2Nn4TfNizoRnGc3t5Z6SKV5YsqDc0ctKjkJuZR1H8SaoLf2Pv2jLGzZxaxyaqMWxZpCU9IQl7TSBw79wVgyY9jtFgwMHVmciuHf7UdvkvcP6q9OnYAto1Aw4lgkmEci2cTfnHBDMrjVSJ81+J0QQvLYCKKthyALZ+VX+1zn9X5HIZn38exYgRRxCEurV2bq7HokUtH2rC/5sEBARw7tw5PvzwQ6ZPn052djYuLi5ERUWxdOnSOrazZ89m9uzZqFQq3N3dadeuHfv27asjhIWHh7N161bee+892rdvj0wmo0WLFuzcufOe3kf/NAsWLCAqKorFixezbNkyzGYzQUFBjBgxojYxMkBZWRkeHh4IgoCtrS1hYWE8+eSTTJs2rU6oaOvWrfntt9+YOXMmc+bMISAggEWLFjF27Nham+zsbF555RVyc3Px8PDgiSeeYNasWQ91vdq0acOZM2f48MMPmThxIgUFBXh4eNChQwcWLVpUx/app54CpAGVl5cX0dHRnDp1ipYtW/6lZer1el599VUyMzPRaDRERESwfft2+vfvf895p0+fTseOHTl58iRt27alY8eOnDhxgvfee4/+/ftTVlaGr68vTz75JDNnzkSt/vsesf+ryGQyxox5gsWLF93VZvToJ/6xhP9/5P333+eXX3656++CIPDVV18hl8sZOHAgW7ZsaUgc3sB/LHKZwEdRrow9klWbMuYmNx9RFrZ0fagJ/28ya9YsFAoFs2fPJisrCw8PD5577rna3+/nXiAIAmvXrmXFihV8++23fPDBBygUCkJCQnjiiSfo00caUy9ZsgS9Xs+IESPq9OGdd97h3Xfffejr1sC/FkH8Y4KcfwE33RdLS0sfeo6OfxnFFVyOvcqlnFyGDu2FhcXdH2bMJhPPThovhWKIIt3WyfDfO4WuL89BFEUaB/py+Zd7JPatqIacYgAKrmVhGRWEpYcDVOs5M2Mt177ajXv3CLrvnonsHxhQPGzOz/yJ5FWHCH2+J81mD/tbbf3w9TrOn77I4JEDWDRXumBF2bfjvcJXEYxQNA6U+nI2bthKhDmcd1RScmIfQcEy22JwnQVXO2IyiXzq8xlleSk8oX+JEDEIMIMsC1y9IQLYJy3zciTsHShF7T72LTing4iI4DgBmr3I5ZIo9g6EvI2TyJFXYG0WCRzwNaisCLpqIO3AL+yo/A2ACFV33Gy68WxeMCf6KOm5XURAQAROjE/C+0AwGx6vu86RJ6HzefjiOQg4Uog6MYtr45uAINBjGzSNBb0atoyAX0t2Ul6UR4v2PbGyVGKncEFvhPjKM8gFJcGWzWvbNZu1GIrXoVRAl+jOfHs0Aw+TCY1dNBvyvkKRW0yBPhPBUU2gfQdayVygOpmbt8CfL6ZwNTMWAIVSidFQI9Q0N0M5jHXti1/gcD678CLVch2kQh+nVhzyiiPYYMWLWukmpXLw4cOkXSQVZiHzh5aBgZzZdr22n8KJKsR8yTtN4amk/wddWTJyNk1WTaak8rrUnY+rWDLnNbr16c7xZAfsKtNxIpaD2SmICEQGNeZ6XA7VsceJW/01JgR+JQITMuSYGU4ch/AnBxsUSgWCSoWxqqomp5iAcuxoVE2bse1bO17N+IIITRC/fDgAma2UPd5F0LE23MSemJPk7tvJ7h4TybFwwftqEuntogAIr8pn9bZDFBkrmFmVxvlnZjHA04pfutTNOVdeCRq1ibjEJAb2fImMrEKCnNSs+eE92vbrTlZ8Aq+FS7kSnHx9+CI1kZL8QjYtWUV6YjI5N9LrtKcvykdh5wBFefiEhJFZUo5aY8Hr3y7iwsFjbF4mVRRz8/cnM70AuakSmQxe/OwYZ/f6c2yrNOh/9OVJd03+n3o1kU9feB2j3sDYmVPpMLDXHTafPD+D6xev4hnox8zvv3ioA5YlP0lVLDVqWPUBeLkBlzJhxnqwt4SvxoDTf89bP6MJBk6WBDN7m39OMPun798bN6YzbdrZOgUAfHwsWbSoJcOG+fzJnA000EADd+fs2dOsXbu6jqeZo6Mjo0c/QVRU6//HnjXQwH8/m9PLee1sXp0CAN6WCha2dGWwzwNUXWqggX8hDR5mD0ppJUfjkziRkEyLqAjCQwPqt9MZkGUWEuTlR2L6DVyxodP8R9BrlVhpLKioqsbFvm7YoiiKiEYTsturc1pZUF5STc7OWC58vhvXro3ovPJZyCvhxhqp3HjO/jiqs4ux8nb6p9b6oWCs0hE3fwsAl97bQNO3h9RWF/yrZKZl8dP3ksfNqmW3kiVfk2ewawD03QwXthziM9NiTAoTv+hWM8z4CJdkcYwTO4CwFMLc4LJAvBBPTN5xALSK7/jI8D5YrgXLLdDjR3BW1Qpm6TW722CCnNngvE1EcLsC7V7BfKApTQ6DSwlYZMzjvP0OQmRRbLSwwmSGG42UVNhFIftlB4iwKkgk3yqWs/7VtGnRkvYHBawroNwWTrsHo/KqxD1XQbGLCu8EgWInkJvA2A1G/AyzMt5BHdmScEHK3ZXrCXYlcKA3HCo6xi/bvgCg0qRlSO9n0RvhRMl2fs79hEZGR8IN7ZFbuKALHolMYcGIfk8R5AEXbkCIbRCi2YAo6hnp/goVzqW8kzwcs9HM1YJEqt3a0AnJSw1BiYuNF1eJRa3Q0LP5Y8Rc3UilTSlogBsCOJZRUbofhaMAIjj6qrGVBdHFsQnanP21+69ErCIpPQsQUeWpOOd4nUaBbbh6/RS+zmGkBceBzozSXYWhkYIt+0/wVKOTRDnbs68SyYvIILJ9x2Gqba3RGuSU2HXm6vUSDh66TOvOYbw5fTlXLt/AwkJFW+cwjhSqMdW8PlBgRunmSmGuJQqlAoVcQFtZVdM7AcUjg1B06YxZLqc4uJrf1B/R4trjaJ/bjmW3zrQf8SjdTLHsKTZgRkdCiUC2m+SJlda2JUFZeZS5OrL5WCLeNwz8HuzO+TFP0sROxfJwO/hgG9hpoE0gnL5BWjMbKuxVREU0YdGs0fy0dC3OVgoKsqVkWa6BAYRFdyD+yDFsnJ14t2NXnFq259q5y/WeN3K1BTK5Alw8iX5mHAERYdg42GPv4oSjx60KhLkpKbU3CdEM8adfo9vInqTHr8bK1pamHdvc9dz0axTCO+uWERtXzfVqPxqVSdUebyftmpQ7L/tGGnqtDou7Jh776zz/GLRrDh7O4HHTkaypF/z+0kNbxr8TCjkseh0OnoHubf6zvMtuZ9gwHwYP9uLw4Xyys6vx8NDQqZPLP+JZ1kADDfzvEBXVmhYtokhIuFab1y40NPxf5lnWQAP/ywz2sWGglzVH86vJqTbirpHCMP8Jz7IGGnjYNAhmD8iFvDye/0aqcJRUWsLhlR/Xb1hRDWYzr46eyPXcbAJcPVAplWCh5Oi3H3PswlUe7XmrfHR1bim7Or5LVXoh0WtfxHd4zYBUENAjcHL2RhBFlLaWUnIhIOzxaC4v3Yf34CgsPR3+1nqVlpZw7twZwsMb4+Hh+bfauhsKSzXu3SPI2R+HZ7/IBxbLAByc7HFycaQwv4iwxiF06dePtRsv4BHRBVOBZLPFvAOTUQpnXWm1lxcrH0dmEsBrKhhEOL2AQtkCHM0OyEU5JsGEdwcvuPEWVJ+F6nGQI4OsW8uNugCFzmBVCSHBQA8Bk3MEv8VBhi/4dKqkyykFdkZHupa0BffPeeGwGxcrZ+CSo2bb6HC6vPANmM3EnNkFBh3yain2c9dAiDoFuweBWQGHu1vRMgiGbgD1NjDKRb7tHYPn+cYEJbmhV2kpvLQfO49gQrw6UmEjZ+O4mu2TfKvPN29JVmrQK6SV6WrwRWUyQGUWPorrqD0ao695+ZNd8xJWkCnRp2zH0r0DFipL3g/ayJGSzRwv3U5WmYGg0ADOXU8mRdCS4HaOZ5zGYGthwFZVxsjwR9m2YxMXrprwdHUn2MUdwaxjuEVrVlUfxqXMmgQhh/HO74DjGBISl1CgS8LRBCq5Ar3JiMJKjrXSmWe7zcXY2cCZpB2kFcRDF2vs5W7k70sGZwVDt7/O9Cmj6d4zkrXzd5BJDkHuRsrLEgFIqTSyOkeJMUtG7iebSM2tBORotTqStVpMqFFjpJ2biG+PNuw8lIqBIvy91JSU6NHW5CMTFHIU7dsiWFtjOnacoHkd2HH8KIXPlQCgO3iE34us+fxxR4wKGYJSiW1umpRvUCZDMJv5/vgFWs4aDJ+kAdAnuZjXK44wa9QEhPm/w69Snje+P8bJMBU75VI4aN6ag/Q/q0UbEoE5rZBusUYQRRRKJbPmL6do3gZizuxlY+4RygRLQF5bORURBuk9MIW7c1JfRGFWBnbOjkS0b4WTuyvojeTGJWE2mXj+43c4s/sgp3fH1Ky0gKu3B+0HPo6rjyfTlzfj/THPM3vE03gF+fPGqs/rHXToFa7M+VHyfjp9GT5/A9IuXiJufwxtHx3GY9Of58im32ndu+tDFctqukzLu6Q/FEXYfACqdTC8p5Rs/7+B8ADp85+OXC6ja1e3exs20EADDfwFZDIZ4eGN723YQAMNPHTkMoHObvdOv9FAA/9uNAhmD4idtytqlRKd3oCLw58ktreygNJKlCoVYVHNIbdYChfTGWnq7UXT4Lqjm9wDcVQk5+IRHUrxicRbghng1CqQ7jtfpzwhm6AJXUGlAIOJZjMH0+yzJ6QSdH+Tzz5bSFpaKlZWVnz88Reo1RZ/u8366L7rDSrTCrDy+3s5hCytLPny249IS8mgUdMwFAoFPiGNKCiDRiLgC9HF7Un4IQkrO1umBxSzWL+dwQovFlYUQiGIugyu9D/A9QM6urTqSKehHYhq2QJ+yIaj8XClh+RZ1gxuBuC76mDc11IfirKyUMd4IijM6MbLwB0utRDpc0jaH6LlOgR9IvKzbrSoKAazO03PiGT4FdHkUhrOab7IVIk09goh2RYKGkNRf3AugrQa0S82GYLPgyegMAl4FGZxxuIyQUzhbdPrLA+IQWVph2eeHOd0SAkBuQFm+nUg+5GXKKsooVObR5ALUK2Hp92ak5NykCrBIAkqKiuMMi/8V0OFHPLfhlaBUHIRxOuJ3FAZMPm7ogAUMujlNJYuDsNRyy3JLIglT36OOH0pSo2eELmW6ppiFNdsStjQKB+PSjWjmrQip1AqPOGnacx0u+FgrefT39/g+/3vo8lXcVL/O+Y2Mh639GFEWFsOVpwm07sKa1FDYu5erqZe58UBg5DJnqO8ysiJFeuh3AzlelDC9l3HuPD2D7y5fRy/vP0OBw4cgJZSIt/rxhLkLVsgi2hM7oTRVIrSTTtcVoi7uYwcrOmuysIhtwRxfRKVhAEyysqMlJRI4nS/fi3oNvlZZr77DYKzM+bCQt68cYGff/6QKVM+xmAwYmelQYmArkaEEWQyuvWOxiMnhov2Yczo2IhUqwhOHD1JoKyIHjhwJkJDksyW9anljHS+LUxQEEjwv6XmFCuMaAqqGVtqDwZbOHQdCivB2Rph/k6cMnQMd+/EWasqSkUpg39aQGO883IYXGRBX6Mn61OyKBQlwTRD1omNX67ERq1h6F4trmVaVIKBHdFqHv/sTYIjIzAZTUT1iMb6Nk/YhLMXKKzxbstMTmHh0y9jYWXJ2Dem4uJ9K0eT0YSUDw9Iz4HK0nLmdOpBdVkZh1b9wLzYU/WGahaUSEn6/+iR9rDYcRg+XiV91+rgqSF/v82yCqmAwX+qZ1cDDTTQQAMNNNBAAw00UJcGwewB8fd048jKjzkfn8xjvTrf3dBCBQHu0ndBAJ0BiiskF4fSytqqmTdx7x5B40ndaflqTdLYsiqwvaXGe/ZuBr2b3ZrBo/4qdQ9KeXkZAFqtFoPBIAlmRUA60BR4SJ7rMoUcm8CH40Fg52BH09tES29n8FYDU3+C8osMnzqWXtu/oxoZe+b/TkJ1OVcal0G7GZi3bOaIqh2tt/WmUzWQD3QEPgA2ewO35ZKK51a2ymnAT4ArXM+LxRFPZEYZfgYj+Si4kJfK8PA8ns0NZmhVYwTVRSibCSgwKcBCd47Hfr4A6qNEyMpBVwrxJzHkLSLbAg4lwHC3JFokHSPHog/aG1bYFWnQKvXE+Z0l2ykdvWUFq7uewNCkHf72IQBcl0NSIJQUZeN2ZDP7tZW0GzgWk6V0DN4MOSwrsWS8Tqr2ZXJrxYBHu5C1QEnUSen3419CXDsY/Ctoi80kRl1FNEteeoJMjiDIUMul41KudKaRPJxWPo/i4VxKwo1CNDIdB+Nj2HtsM2YXyHTX0aFbZ4QygW3HclBZNcFRtMZl20V6OUay+/vtUGpG86QLVkpHvKtCycn7hd44cKqyGg+nXizdtgARkfLqa4zr+imiCPnhiRRkpmOhUWNsr+aaVQFR0ybxWGRr1u8/jufxi8gMehwbBdGutJTKqGou+wRhdlZBvoDq+UkUBXnj//08ZkYEIaRak3T8JGajkWYRPpy4nIlMpgGk6pZ9+nTl6yW/YDpztvaw0PZojZWVJWfOfM/KlVvYseMoXZOO0/dGNMZQe/Rl1Uz+4jNkMhk52fk8/9Mxjiz9jsLETEQEHByscX/pA1IVDpw+m83g0VGovR0Q7TRsybxMen4mCkHAUqXmkVMVoFFCp1DYHQddQsGpphhBmDukF1EmM6Jzc0WqqACTk6roow1E1iYAckop11RAhiSYKcquEBtzDQA/nT/tccZBVOGdWMmeaZ+w5/IpPMMDQYAT2/fSfkBPOg8bgFdwADK5HLNJWkZ6gpRfbu/ajYyeMfnWuegGLcLh3FXIK4KDZwT01VJuqqqSknrP5+MX4I1FkmD2+RvQNKRes4fGw8jiOfsr2H8KOkfB3GkP1obJLOnxDyM6aP8pKYS2e9sGAa+BBhpooIEGGmiggQYelAbB7G8Q1SiEqEbSaC41O5cxby1EJgis/fB1fG6vnHn7iMVaAyWV0ihNc2ehAAtXO1rOfQyKyqUJNaGE/yqef34aBw/uJzKyJdbWNlKlyFFIf4cDb/xLu3P/nAPWAZ2AR4AfUiDvO+m3r4qw/WUZtsCZ6X04m15MmELL8n1HaNlrKPHXmxJdE25HIbAeOFK3ebNgRqa7bSQbAOLcAoT8fHamLcOsN1LiVIp7q158/uMpykUDo6r9CK/WINN1A+vVIFSBaEuhEzQ53Rx0UVSLQ7GwHo0AGNXpJN92Rlbu2Ef48Xgyjdbss/uWCtUA+ldPpNAmDwudJVWWLhS1bFunn+72UFBwmQ+XvIFJNDPIQSB6fzXKgW+jM2upNBbjoHDAXl5IuUMQerUHoltTDl5W4H1bRFypEioMcG2AmdDtAbgSgEXK94T1GMHJG5LbjyiKmI0lGKsvorKWPCEzCoxYWflhMOnZcV7KLUeZgKunPZHPTqK7UxPkFo2I7tSYc5d+ZkZGc6wnWWGLHUpLJQMHdSKvSIkxtaK2L33lEVirlRxRKNEa9Ygo6doUTlyDF998i0/eH4GvvxO+k8YAcDkzDUWClovHS7gohDIQWxxKSwGwydtPheY36GgNm3QoOnagQibj0MzlHAY2+ldR8NYMNEH+NGvTltnejWndujH79p3GaDQxZkwfYq/nEQeSuqHRMGpUbwAc5QbOnYglKSmDJCD2i1+w8PCgMK+M33+KRXv1PIF2Mpx9veiWeJjfaIQROXKdmdbJleQG2ZFuMvFYREeeW/w5qbbB5FzIAAEs1WpefuppztptJvnkaTo904zqYX74RkWiuHl9mTeM642sWLHya7SCCaWFmm59etEr2QKZsy28PRA0StocP8PZV98DIDRQTXocCDIBF2dnxBwwYSbSL4y3zv+GKMD1y9e4flkS1dKuJdGmbzfsXZyw7fsVmXs+BUFAIZhQa5Pxaxx6x6kZESwJZgAeXta8tOEnzm//ne4TJ9xhC3DmMphM0uf81X9GMOsXDTq9FJL5aO+/15bJDAdOS98PnZUi5f9qiGdcMkz/SMpD9sVMCPS+9zx3Y9tBmL9S+l5eBUO6P3hbDTTQQAMNNNBAAw008L9Mg2D2kFixcSfHL0qjwq837WTOc4/Xb6hWgr8rmEVQ3mXz21vdEsrsrf6B3t6d4OAQgoNvG6FmIollgKQS/JsyG8gFDgIdgCb2sNUaZBXgfmv0GeRsQ5CzDY8PnkhRYTG7tu7l/a9XculpDS5xen63T2fYJ944mGrEzGGw7OxKyjLKmGF6GQBRDZ9nvc0hcR6R1x15RfcGPz0dgnijEb9svUKKohIAGQIRVfaAHHStEB1eIdVtPHt7RvPUkpp9Lzqwr+NUmsft50SbYRQowPdCNf2PW6BWtybHScalssO46wPoXzoROQp6n5eqiv78OGTftgnkMmgTBhvTkjCJZvy9G6H29EZvY4kSUMss0ApK9sVNxUofCIClbTnGC0eodgzhQqvhFDuCyglSHEEhgLzZNX50cENu+Tg6YxVtm1ji6Q5J2XA5RUBQOhAY0p/8cqjSQrFex4q0p5jgPQcPhwCyi2/QxjMIeXYo2htH2LvpKHCUXbFr0ThY0b93OzbmHpYqkGLgQl4SsVnJFNKdlr7NsTSVYe3sgiBW8kzP18kqzWDB+P4EuYs0DxCQXB6lRFX2oVaUpFeAp0jC1pqEcyLszLHE5GZP2whnTtleBLMRMkwIgoDX2lWk9x6IYG+Pbskyni8roO/QLtj42OPh5ky/fh0AeOwxKWxQFEXOHzwFgJOjHU8+OYAFC75n/ocraZJ2iEKzPeAKQIVZSWmmdPKUxp6kHRmQB2ZtAUrMdOcG17FnSPgwloT71u7Hy0Of4ZnRMyhZvorRcju8TaXkWLrz2dF4zo4cjWg2s3PJUnSVlUQO6Mfza77ni6lvkZuWiclgRBQklymDVkeZoRrF8kl1TpWyglsVwvxCPHnk6WEolEoCS5UIL/+MAhmn02ywFhWUC0YEBJQaNfpqSVVOPH+ZqrIKqi6dItv5aSo1Ecx5MgV3qyIat2vJH3l6GAR4gZO95G1G+ABaDhpwh91NBneHM1ck0alv9F3N/hYyGQzr+XDakstgRC8pJ9rALncXy/KK4K0vJEHt/RfB91bkKvtPStUtQRLd/o5gVlZR//cGGmiggQYaaKCBBhpo4K/RIJg9JDq1iOCj1VLOoE6REXc3FEUpzFIE7K2hvuogMhm42v8j/fzLRACPAReBF/+f+/JneCAJZnZIFRk724PVYkhNgUEtEUVJg7ypUarUUiisQqkk2EuG7kkDnrM3U1lmxMlWzZDimhFrW9gXcxCtXEu02IF2Nm3I7SQQW7EKs43IueBCyvZeRa2ezshl0FbhwYamV9AJZoYWeWNsoiBNC855b4PFfE62MyBU7kCn6oXcpCTPDYIu9uNaqBXJ/pI4ExUDFuUC0JI94aewCh6AzbV45LedrgYFFEm6DBoRuuyHsEQQrsGTnj041TebVlHPIpPJEXXlqG5sRZSpsPLuhKPaD/Q17ZTlSQnhixLBz0BqoAJBEDiRkcTAVjJ8RS9OqWtyasmViMC5ZEjNA5VcEgdS82/tBmeVJ28ErUKrz6NXWGs677PFxWUU16Nas+ZcGWdqKicEOzSnd//xVHl7w9Vb8/cPbEvs4eucCtrPKQt4zfMZZNU6irUiiYXJ7Hh3AqcTr9L21QlYKFXs++Ajwr0lsWn2iHG8sncplIDKR0H7EjeOa0upSs/i9/RsFMI7bJn3HEorLVtLDjLvzPck7jhAQEoSFt07cfXUaa4D8aedeX7CY5w7nsDAgS/zxBP9OXcuHpVKyauvjuXiRamyY2mppEYkJWUAYIUtwRRyTXBFFMGEHGpS7ivlws0ISWTWtpjKSnCmCktPf6ZYuvKjTk9ZzTFpyCtA5e6NIJOxzro17nIj2WYlpEEf7yAss26gq5RE2YQjx0g4e5HMpJR6T4u89BrhcNN5OJoEY9vRuk83YvcdRLX3KqE/nCO/QuCXvTsI9/LnRWsvhAodqzybEyLzAt0ZgsYNxE13lF2rf8HCUoNcLmf1B58BEKqKpe0z77F9/ix01Vqihw3GaOHOkCd6YW0trY/ZLIUqWtzpUFsvvh7w/Yf3Z/vvwrRx0ufP2HUUrkqRq2zeD1PG3vqte1vYfki6PnWOgthrkrdZkwfwrhveC0prov5H9vnr8zfQQAMNNNBAAw000EADEg2C2UOib4dWJG76BkEQ8HV3vbthWRUUlt/639Hm4XSgWi+Jb+qHXO5NAF59uE3+I3wKHEXKs3bTKS/KHaLcMZpg+zbosAxszaB+DJbKFpHQMhHLKZaoTWqq0WOqSWa0MOIKQ4q8oR3QFV5VTWXH5t1oe2iR9RRw6wq9zE+xvu+HNE7xxLXLi7TNArUemukdyMkciqmZiOV8BdtFSMwCt1wjj/w0nsZH45g/YSzZ73Ti7e1b8DsMIOCVU8UZ7V42W9vi6+2B31UfCuRZ3Cjdhya6AxWd21O+X0dlpporTSEpEvQ1uzryIIQfr1nnX8ABGxZMfZ4NNRGk9qknMZRL7oE6XTVe8VmctKkgztlIGF500LtidG4GMmVtJU1LpZrPdtzAXhMIYdK0cF8lchmUlBuRlWeh17iiN90qCqEXq9GbdFgr7LFUuxPi5sz1pzpgUS7l2RswbjIV1TcwOTnw3FOfIpPLsXZKRC7IMIlm+ga05v3oCcz/+SfMCmlffHRuJX7l4aTmxwPw25EgYq5epKhcOod+O36EmY+OITErg5bWoXwQ+jS//bSZrtkKPitMwlzbOyVbt+ZibW3P2rUdcBpvw0cf/YjRaMJRY0Xyj1tRKOQYjSZ692qLv7sXkU89gclkYvfukxgMUunQYqUF7V54iuLDR5j8wkCSM9NQKhUolQr6d+9MXHIO4lUpD6CvlRl5nx5kqFzJaNeKPiteofDaVYL79cXNxRELbQUrrcJo0igaK72RTnbQ1VGFXbdIBn88mQSZJVdLdfyeVobj1VyUtnoi33gOmdmEV0YecZu24tihOwaVJY7urhTl5mHrYI+9swPBLZqRl5HFwGfGQm4ZvLcFRNDtv8zRaFuyzl1ljqIZMgQKt6TxiyVcy0zhA28DT4x/En9rGzbsdCPEqTmzRii5fNiLgRPHEfPrVlbOWlC7VcvKzcx95Re6BUt5yQ5v2ATAsSMZLFk7iaQ0mDJP8qr66BVo+T9WnGz5ejh1CZ4cDJHhksBsMkPUH96pRATBjiVS9P7Oo/DhCmn6h1OhS6u/tky1Cp5/7OH0v4EGGmiggQYaaKCBBv6XaRDMHiJ+HveRxP72fGaCQGW1lkVrN+HqaM/EoX0fbMGllZAv5WjC0wks79OV4yai+J+fGdoG6At8B3wDRAPzAJmUMs7uBLjk1dh+AyqdkibJjaEKuAD2Y1T8/mwXYq7oaObuRmVzqcApe6Ht2Va0ndwK/AETyKxh7I73GbHnTdQGDSyG0BHANSAV1K/KIRz4HopsABU0Oa3CqtyTpuWedD/xFLkByWT3BfcjIoIosLrPLiwUWvbtXIis1QKKKqr52ZCC0cYGR7+TKCxPcuONKKyULbly9lbEriiKnAouoM15FwQdYJR8mry/AJcXocgeKu3sUdVotNobR5EXpOJRADtsqgloPIBGTcbw286trKuMp4PSGZuyKrYnx/KYY1PMtxQnrqVD6xCwz/gNQ0oyZrUD2sZPIwoyBEGGStCg1hZhtrLFZCigWp/FqtKNvBb4A/qS66iVmYx4sjXxGl/iqo6zvWAlxuRqTKK0EL3JiEwm48XOQ/ni2gZJrM2FKvmtuLJNhw7h7mCLtUaDWqFkUJv2XE69QatXXkBnMPDuI8N5u3Ezjl+/UCuWderUhSNH/BFFC0RlMV+u/YEOkS3Yt28xn3yyhi1bDte2//XXb/LMM0MwGIx0GziE5PhEdGXZZGVJbnQrswwInbvhFN0LjSoWe7Mlr8wbzk9LD7A7S8Yb0yex9/lP0BmMBFWm4LHxc652epQbb2+goEISLS+v/p6PvjlC1xnDyJu9DJNMRpmFihktvOnuYQXtAiC7lEOvfcQ7nfthVFuyet9J2lSUs3yoLSa5jJ3Nu1OSrmT3t9t59/tjvNDeFUQoKyoh58wJOvftxPCpz0grVaYFGwso0/KTPJVTZwpBhOuyCoLNNlS7O0G5AKJITkYmCz+Yi1Kt4uBPy3FwtWPNvC84tm0PgiAg1ojKNxP+74yPplRrS2hpCu42Bchl0lYvKazAbDJx4qKccskZjkNnH1wwE0UoLoOTl+D0ZSnvWKPAB2vrX0VGLvywVfr+5RpY/yls+EzKzebscKf9zWT/abfFWd/+vYEGGmiggQYaaKCBBhr41/KQah7+92A2mjgybjGbgl8mY+vZe8/wV7HRSOGWLnZgb8WspauZtXQ1kz78go37jz5Ym3rjbd8N9z+fKEJmISRnQ3H5ve3/E/gJKdxwP7UJvhyswdQSdGowy4HbB9oXav7ugBBHN+zxJS1HzYGLQCaIbwG/ArNq7OTACmAsqEM0UrhqKyTp+V0kwS4C2A4she7rwLcaNI0kryOj3MCgw9N487PNKD6HMk0hM6d1YlvXLzgc9RNyw0GEy2dw1MXR2a8l9kOXYlb4Y2NhT4BrMEEeYH3LqQtBEJiTcYLUtRXwO/CspDNl+EK+vRQFaHRthTZ4JNqwcZisfABQWtoSO2UN66rH0HkKDE+MBpOW5NKrWAVW8WbbjnRq40tLT5CZAFES4tILoDxf2rAyXTGYtAjCrcuIvCID+fkF/Jz+Bl9X7qFMrAJBoFA0kFJyin6dRtPefjDbC74hV59KoTEPt7IAWlpGM6fNq+QUFDCpXV+CnDwhXsDV0oEBPbsTGdaV0KYtKbQpwlahJH/1r+SsXk8TvwCuZaRLXjtBPRAPnKbJ3iImWfgS3cyFbt2i+Pnn1zl5chRr1rUmtM0NikpL2XP8GJ07tyQxMaO2756eznTq1IL+/V+iXacpdBj4JFPnfc2ew+tYufJtOjob8PlmIZqpkwiJ3QZqm5p9IKOooJxz567hFRLA49GedCANDyowA+cPx1NSYSATyT69bW/0WdlUuXjhtH8zAAHWSiIdb+3YGwt+4fsIXyqt7dEpVSyKcMW10IhFqRZdlZ5DJkfiHb0AMJhEUq8l3jomFEqy4xNuHSS2FvDDMxDoTLVQo7QKsEp9g3kRdnQY0Rt5aHid08ig07N2wZfoqrVkp6QDkjirtFBjYWXJlM/fp++TI+nbzQIzas5mSC5TFZomFFt1QhAN6HV6urYGD2dwsIU+HXlg3lsKj0yRPK92H4M5y/56Gzr9w6mIeb842oGbk/T9prjnYFu/WHY7j/WFHu2gb8eHl2etgQYaaKCBBhpooIF74+/vz6JFi/6/u/H/xv/6+tdHg2D2BwpPJZOy5igVyblcfHdDvTbl13PZ12ceR8Z8hbFSW6/NXREEsLUEO6s7vLqEB/XycrCWvMqsNVLb94vBKJWJAyiterBl34MbSSlMHPUiLz45nbyc/HvP8He56aTXAqhx+JPLoMdwUO0E2U5gwW32CiQR7FFQ3HY2KOWgBUw10wpuL1bqC7wEzEoE77WQncEd1OiWXukwrBKCX7Hll8lGfnhWiUuhHwCOhWBT5YRrUQAqvQX9Dr9ElmsYIlLupyy/tsiUllRW9qKg6FG2nrAlJQ+GdoAAN9AZ9RRpKwiwc0JpKQN7YCLsfhI2PI6kcNVgtgnEwcMbm46Tses3j6GzFuPm4g6rgQpodcmC15P3MzntCMEHNlG6eTblu2aSElUjMgrSYRbsAR3798LFywODe1NQWtdZba3aBVGwJ1rWkQjbXkz0mofOqGVP7HpW7P2dCkM6bvYCwZaR0gw6gRcjP+VxnzlcuOrK4p/XMu/7VXwS+QypS9eSu/JXmjexItZlPwl2Z/B38GBQl25YqNUo5FLOwMFtO/Dmox8xrutMulQGEKy1I1Bry1ONG/Py/K8oNTnj4yMyZ84bfDF7IxkpBfi4uwPw7LNDkMlktGnTmMP7vmDdD9v5/fdjnDt5loNb14EgIFfbcvjweTQFqSQY7SksqCJu9VYyigrxa9mT5VfllFcZ6Ng1CoMoY+XhbE7jzUW1L5nBHWq2jMBBAjju3ZWzJ9PRznybpPgChKRM3rIqpdmaj3klrCk/zXwbgEN+ImEOItZmLQqjnk4pyey1yCNlxyHOXatAr7Rk5qOdCGgeQisysSpKI6JlY5zsLGjZqTV9prxQd7+4WHJxSgtGKoLobHBhhOhPm68X8cHAfhRaqimKiLrjEL5y4hyvDxjLjcvXsLC2ZMgL4/l45zrmb/uR0BZNGfTs43y/5Vn0htHs3tWVyM6tCXAqpJlXJk88HoQgCHi7SZ5VW7/6ex5hN6tQ3sTJDowGA7Exx8hNvfP8S8mEtdshPUf6f/1u6DkRJsySilP8K7C0gG/nwOK3YPbz9z+fvQ289wK8PQmsNPe2b+DhkJOTw5QpUwgMDEStVuPj48OgQYPYt29frY2/vz+CICAIAhqNBn9/f0aOHMn+/fvvaO/06dP06NEDe3t7HBwc6N27N7GxsQ+lr++++25tP+72SUlJeaB53n33XSIjI+vMW1ZWxqxZs4iIiECj0eDk5ETr1q1ZuHAhxcXFtXZdu3blpZdeIiUl5Z7Levfddx/KtgA4cOAA/fv3x8nJCUtLSxo3bsz06dPJzMwEICYmpna5MpkMOzs7WrRowYwZM8jOvrsb508//YQgCAwZMqTO9Pq2pXvNPeX2bXHzN5VKRVBQEDNnzkSn092xnIyMDFQqFeHh4Xf81sB/NuPHj0cQBObPn19n+qZNm+o88988RktKSmqnZWVl0aRJE6Kjo+tM/yNJSUk89dRTeHt7o1arCQgIYPTo0Zw5c6bW5vZj1crKipCQEMaPH8/Zs3UdA7RaLePHj6dp06YoFIo7jv3b+/rHz7Vr1+rYLVq0iLCwMDQaDT4+Prz88stotX/tBjxt2jSioqJQq9V3XJcaaOCf5m7H+u2fVatW3XX+8+fP8+ijj+Lm5oaFhQWhoaFMnDiRhATppfYf75U2NjZEREQwefJkEhMT67SVnZ3NmDFjCAsLQyaT8dJLL92xvFWrVtXbx9vPO6PRyNtvv01AQAAajYbAwEDmzJmD+faQogbuoCEk8w/Yhnlg6e1IVUYR7j2b1msTN28L2bsvAeDapRGhk3o88PI+eOEJXB3tcXO0Z2i3DveeoT4UcikU86+iVICFCrT6vya0/QV2bt1HVoY0aj207ygjxg75R5ZTy8vARKQ8Zn/QH4Wb2o4dkrB2AHgSeEaydQMGt5Oc7Zr4QWI2XHocPNIhobnUbGqelJMs3FWP9xuvQ3UlbN8JP6y+taDjwEdIcvRIE7RLxFzuTb6LNQYjHO4NLY/D6fZgUyow5YdV9F3/JfLW1mx/XI5Q/i1Kk5Zie5/aJqt00uf3M/B8f+gZCddzlKgVKkaHt0d988ErMRFdoAMYnAFwsobCCmn9TGZ4uo8cs7kp1pZGfk77kOxRlTyzZgbp3jqszNKDvKWFI7Ihr1NwZiVFtzkedoqQwlSDmjbCI7QRyVlajsVrqdSpkNVo79ViATq3UPw8e+BXM9+2099w/noMCkEgwM2Vbk3BQjWN9umDiEs6wVdbXqG0Mp+JvV5j14VEEnKusuPaNdK/+wGAaVHDcUND+rod2BXm4tvbgakrvmLb6RO8PXIsE3r1o7l/Ez7Z9Dn7tFfpTKi07pFjSM6Wcz0HSi5tIf5qGgBnDscTGOJBflERL700milTRnLpyCk+nTidzFI9MpmA2SwSEuxFVDDYqgopF0qpRIkCI0YUCHI5+7af5fCTixDcXBGCgzkac5aRI29gMpowoeBa10cxnj0P3AopvZFxq0JlqsGSlAvpJB+IpevP32IANn+0iPWHk2k2uBMOZj2TSw4RWGXm9PHVHPLy5vGZr+PXuRNKlZIfr5eR+/psjFf6E/HjPOI2/MLUX34kLPoPrlynb7Dli685eP0SH1Q2pVxt5IiQQu9t21ll1ZgtYd681X8Iam9n0lbtYW9FMkVm6eZq0EnVIbQVVXQfNYTyohKUahXK20pBbkgrY3tcAZojJwFQqlVsWbaag79u443vFmHreMulqqqsgrLiYtz9fPgrjOkPG/dC++bQKkJKjL9m/pec2nkAlcaC2WuW4ODmAkjH+YtzoaQcft0DGxfBziOSd1liGiSmQvOwv7T4B8bO5l+3rP8mzIgkUEApWuywIBRnZH+8oD9EUlJS6NixI/b29ixcuJBmzZphMBjYtWsXkydPrjMQnDNnDhMnTkSv15OSksKPP/5Iz549ef/993nrrbcAKC8vp0+fPgwePJglS5ZgNBp555136NOnDxkZGSiVd+YaXbVqFatWrSImJuae/X311Vd57rnnav9v3bo1zz77LBMnTqyd5uLi8rfnASgqKiI6OpqysjLef/99oqKiUKlUJCUlsXbtWtauXcvkyZPrzOPj41NHiPr444/ZuXMne/furZ1mbV33ZQtIg5Px48ffIfb9GcuXL+eFF17gySefZMOGDfj7+5OWlsbq1av55JNP+PTTT2tt4+PjsbW1paysjHPnzrFw4UJWrlxJTEwMTZvWfd5LTU3l1VdfpVOnTvUuNyIios76yGte4NzOxIkTmTNnDnq9ntOnT/PUU08BMG/evDp2q1atYuTIkRw6dIijR4/SsePd3XFTUlIICAioDY9v4K8hmkwUHz2MLicbtbsHDh07IdSz7x4mFhYWLFiwgEmTJuHgcA8X4xqSk5Pp1asX4eHh/Prrr1ha1v+MfubMGXr06EGTJk1Yvnw54eHhlJeXs3nzZqZPn87Bgwdrbb/77jv69u2LVqslISGBFStW0LZtW7799lueeOIJAEwmExqNhqlTp7JhQ/1OAze5eT7d5Pbrx5o1a3jjjTf49ttv6dChAwkJCYwfPx6Azz777L62AUie7RMmTODkyZNcvHjxnvZ/5TrawL8ek8nE4fNxZBcU4eHsSKcWEfVeO/9d6NChQ5172bRp0ygrK+O7776rnWZnZ1fvvNu2bWP48OH06dOHNWvWEBQURF5eHuvXr2fWrFn8/PPPtbZ79+4lIiKCqqoqLl26xOeff07z5s3ZunUrPXpIGoNOp8PFxYW33nrrT88hW1tb4uPj60yzsLgVwbJgwQKWLVvG999/T0REBGfOnOGpp57Czs6OadOm/bUNdBuCIHDjxg38/f0fuI1/ZxoEsz+gdrJhYNxCqjOLsWvkVa+NQwt/AASFHIemf23gdztlFVVcS0nn1XHDUSj+Hy4YggDezmAW66/W+RBo3a4FOzfvQalU0DyqfgHyoXPnc3hdBOD9+n8KcJM+AIHuEOMLOV7g5yoNxPftB6sC2O5pZmK1UZKJCg1SGOhPQAmSZ9dNj7TY47D/ffTegRj6LwXgQgvovBu8MuBMazNPaXZy2VBKjwA3PmnWnQMXbz10qEwwdAvYX4eY3lDtcBbd89+S7RSO0EoqWyoIAj/GQE9VHE2WvEpbhwCyhn6KqLTAWgaFNW3JzVJEcH4+LPx1IidDv0doKnB5dixNy3egyG6PsioNvZs0QHBrMxSTCWSCiFd1Ov4pWZhc23HhBuyPK+PrnLU4W7agvSaY1o4iqTnpfFH0Ce6aUJ4SuyGrCdUc0GoC7hb5uNgo8XBwIqsI0gsEvCyCyLFIIbckFYCknD3klEmJ5ooqiimuqMBSbYEgCHimVBKXnEoZsPvXn/lyt5Qc6q0fvyPS24+y4myOXdsKKgj3KGPX7LlU6ZtBiVQHo1u3Vsy3VKHTGght4o3eYCAzLxcXR0fkcjlJsZcRzWaslQKNbIyYSwtJOLyfn+z9Wf3JW1SVl9Gl/wA8z98gLbuSnIxicg8lgCgi5uRCTi4AeXlF2MoNtFbmc8HPldLgkRgWL6lzjDlSRaWgRidK53xVcSU6a3vUFSVUySzJOZ1M1xQLWg2MxGdSTzbM/ZCClFQKMzIoKCykrbW0TUJtJU9E69w0DClJlAB7l66oK5htvQCzNjESNWVqBz6ziKdQLolgh7fsYmFVLo92DoXeozF/cYqASg0dacxbjldQO9pRmJ1be4xN7TwEAAtLDa8sW4hXkD95WiNPHcvGsURkQM0iTTUJ9koLishIvEHjttIAoSS/kHnjp1FRUsrAiePoN/7+M9NPelT63E5+hvQQo6/WUlZUXCuYiWYp/BIkbzJRhEe6wWerITwAwvzve7EN/D9wlkx+4gLFVNdOc0DDKJoTRf335L/LCy+8gCAInDp1Cisrq9rpERERTJgwoY6tjY1NrTeRr68vnTt3xsPDg9mzZzNixAjCwsKIj4+nuLiYOXPm4OMjPSO88847NGvWjLS0NIKCgv5Wf62tresITnK5vE6/HtY8AG+++SZpaWnEx8fj5XVr+4eHhzNw4MB6hRu5XF6nXWtraxQKxT2X9VfJyMhg6tSpTJ06tc4Awt/fn86dO9/hlePq6oq9vT3u7u6EhoYyePBgWrRowfPPP8+RI0dq7UwmE2PHjuW9997j8OHD9Xr33M/6WFpa1jlW1q5dy+7du+sIZqIo8t1337FkyRK8vb1ZuXLlnwpmDTw4uZs2Ev/aNHSZt7yS1V7ehH30OW5Dhv1jy+3ZsydJSUnMmzePhQsX3tP+4sWL9OnTh65du7J69ep6BXaQjp3x48cTEhLC4cOHkcluhUlERkbeMfi9eeyDdI707t2bJ598khdffJFBgwbh4OCAlZUVS5dKz6pHjx79U8+2m+dTfRw/fpyOHTsyZsyY2uWNHj2aU6dO1en/Rx99xLJly8jOziY0NJRZs2YxYsSIWpsvvvgCgPz8/PsSzBr492Xj/qO89PFyMvIKaqd5uzqz6NVJDOv+z1zzysvLee6559i0aRO2trbMmDGDzZs3ExkZWRtymJeXx9NPP83evXtxd3fngw8+qJ1fpVLVuc5rNBp0Ot09r/1VVVU89dRT9O/fn99++612ekBAAG3btr3jvHJycqptMzAwkEGDBtGjRw+efvppkpOTkcvl+Pv78/nnnwPw7bff3nXZ9Xk8387x48cZPHgwAwZIT+3+/v6sW7eujkcqSNtuzJgxbNmyBVtbW2bOnMmUKVP+dL3/m2kIyawHla3lXcUygLAXetHn+HsMvDQflw6hD7QMrU5P6yem0m78y4x+c/69Z/gn+YfEMoBW7VuyetMKVm1cTkj43xsk/KvRqODZvjC+BwxtD0IRjFkKj30P7fdYsGHQh1wLGAba92EP8CXwA1TkQkUomJsBho1Q3R2LGyYmbpnEExueo9uuTPYMhOshEJ1q5rJBKthwPL2Axj7QyBksa8aKnnngEQeaaog6Ab33r0SdlkTw+W24513D9raQrcqUbDCbMSrUVMssCD4N7T4HrxSwK4L+koMVl76FSkESqURBRKssQKUCTVA0Fe49Mdv6A1BmdiQ1H8yiQIVWQDZ3DqdOFnPoMqzJXERG2U4exZ2Qi99REvMd/ZrJKTIXcrniKCvzpmJR+4wnEOrijpVlE15cvp3rObdySQV5NMPeygUHS2uGt2nNc72nEeTejGf7TMLLybl23TxCGiFXKBBkMsKatyDAVepjq6AItsbsJz75Ioqah8VUCyM/XjyCi/osvSLhsU7QuUMzLsWt4bedc+naoyUhfn40Crx1PLboN5BCpTNrzhdwpVSGB+V4XvyVJbNfpKK0FLNZJD2lCJ+QW/OICFDPg6y9qRI3bQHNTm5B0aYVsiZNsGjfBsWox1C+8BxWHdvSss2tMolRHvboGo9ifOhEvG07czy8P1Oc/fG6UcHx2ctoEt6SpiGtub5kA48pW9JrZxJmUaS/lzUHe/uycMJArJ2ckMnltBrySN3OpBXWfnUxqymU61EpJaEuxGTDTmUWxVl5mIxGBBcpx1qlYMS/WWPaDbiVQOv2QbG2qprki1cAsJAL2Chk5Hv4kzj4ScKimvPoy8/i4OZMRPtWhEQ2qZ0v63oqFSXSsR5/JvaO7fZXeWz6czSNbsugZ8fh1+jWdVihgIXTpfxfH02X3gsM7gYHvoVls8HiL9ZEaeBfx1kyWcqJOmIZQDHVLOUEZ8l86MssKipi586dTJ48uY5YdpO7DQhvZ9q0aYiiyObNUk7CsLAwnJ2dWblyJXq9nurqalauXElERAR+fn73aO3fB7PZzM8//8y4cePqiGW388CpJB4C69evR6/XM2PGjHp/v9e+02g0PPfccxw9epS8vLza6XPmzMHFxYWnn376rvMmJibi6elJQEAAo0aN4vr163+6rAsXLnD06NE7xI8DBw5QVVVFz549efzxx/nll18oL/8vySn7b0Tupo1cHDuijlgGoMvK5OLYEeRu2viPLVsulzN37ly+/PJLMjLqSeFxG8eOHaNLly4MGzaMNWvW3FUsA4iNjSUuLo7p06fXEctucj/Xrpdffpny8nL27NlzT9s/0qJFCzw8POjRowcHDhyo81t0dDRnz56tFciuX7/Ojh07agfpAG+//TbfffcdS5cuJS4ujpdffplx48bV8Ypr4L+DjfuP8uiMD+uIZQCZeQU8OuPDB8/hfQ9eeeUVjh49ypYtW9izZw+HDx/m3LlzdWxuejXv37+fX3/9lSVLltS5HzwIu3btoqCg4IHvTTKZjGnTppGamnpH2PS9qKiowM/PD29vbwYOHMj58+fr/B4dHc2+fftqw0IvXLjAkSNH6N+/fx27jz76iGbNmnHu3DlmzpzJyy+//EDXif8WGjzMHhCXdiF/a/784lIS07IAOHLhysPo0r8tdva29zb6i5jNIoVVOlxuz4D/D6BUgH3NS3lZFljUpHrzviGyv29TstybEvocyG5F2nGlCo6NhJY5Bpr/+B52WhtERKzMM7FSn6es/TEqLB9lyDoQULBjeBeerT6FWiFn3bkbPLEtAPbClRYQ0wOKHMGxCMwysC5qDJbJaFX2lNm4060JXE6FkgrwGNKFakM88eU+YDbTbacMuRlG/AiCHJBe1FHmDuM3fcZP/d5GbrakX7OPiBwA5w8e42hKPLg2w+jWBmVGDMqqDLQenQlMOQFKJdVm6ZKhrjKjF6sxlVxDEKWiE1dji/m27wy2XT/Giy2G4i6HQ5fMmAyZFJjlqMxJBFu7o1KYsbOSUaUFeysX3hy+DH3xz2SkpmJ0lDH8mZm8H+XMhbxkJu36hO62z+JKJB4dHsNVmYe1d3Oe6/cVReW5NPFz53r8N1golXw06gkKjQbK8/IQzWZOXDzF2+2iOH8+nmSTiVatGhPsLw1W8woL0ep0qFWSl9apbA/yHVsiinGAQD5WuMpuDdoFQaAop4KfVs+jS5fnqKyshuxsQiI8yEzKo0pnwsJChaitJKpmUF9q54bp+EnMly9jnvw8qo4d8NAXY5N4nNwDp/FyciU3uhdHGrXm+tZEPDVqeng5IRMEMp3lrHrEFlFmh9Op63RsP5CFVt4AHC8xcyi3iq7uVrRy0oBTU3qlJWLQarF2dKx7AI9rD9mlVGu1pJVUEKJ24pm5b1JVVsGHY18g1lTM73m50HU/E9r0IVvQciwngeJzJoZPn0TS+cvkZWZRml+E2WRCBLQyNacScukMaEQzu7t5cqLYwKChQbhaSG+GOw+te+MFCG3ZlBbdO5KVnErf8aPu+P3qqfNkX0+l/aDeaKzuHSLuExrEcwverve3FuHSB+B6BthYgotjvaYN/JtgRuSn2ios9fMTF2iB50MNz0xKSkIUxb+VP8rR0RFXV9faUEIbGxtiYmIYPHgw778vuTOHhoaya9cuFIr/nMeu/Px8SkpKCAurG1ccFRVVG/IxaNAg1q1b9//RPRITE7G1tcXDw+OB27i531NSUnB1deXo0aOsXLnyT/PNtW3bltWrVxMaGkpubi4ffPABHTp0IC4uDienW+kxlixZwjfffIPBYECv1yOTyVi8eHGdtlauXMmoUaOQy+VEREQQHBzMzz//zDPPPPPA69RAXUSTifjXptVf9aWmSnz8jJdwHTT4HwvPHDp0KJGRkbzzzjusXLnyT+0ee+yxO46T+riZ4+jvXLtuP/7vFw8PD1asWEFUVBQ6nY4ffviBHj16EBMTQ+fOnQEYNWoU+fn5REdHI4oiRqOR559/njfeeAOAyspKPv30U/bv30/79u0BybPmyJEjLF++nC5dujzwOjXw74XJZOKlj5dTXxC5iBT08/Inyxncpd1DDc8sLy/n+++/Z+3atbVhjd999x2enp61NgkJCfz++++cOHGCtm3bAtI1uVGjRn9r2Q/73GzTps19z7Nq1SqaNm1KWVkZn3/+OR07duTChQuEhEi6xeuvv05paSnh4eHI5XJMJhMffvgho0ePrtNWx44da8/X0NBQjh49ymeffUavXr0eeJ3+k/nPeXL7L8PH3YU3JzzG1kMneX38o/eeoYFaRFGkz7ID7E3I5cnWAawa2+6fWVAyMBUp+38g8AjQGjgNjoUCLc7n4TjWHlmIJLqwAEoz4YQVOBRA9EoFMrGmkiIC6NuB+jyOGYdxdXq0dsjXU+FOZmk1IjBx7XGeOBoAQHgs7O4PP06CdifBOh/csyeDticKwYWJn9mTch5SO4JcAItkJbuZzI0ap55cD/DMhAJXsF0B6hoHgS7D4Up+c8KqtpLpB+kFZkg0kBSXhEpfABn7EeVqlLknALAR9hLS1I/coV+iN9jQJh3GbXyZ2c3tyAm/ho3GCbMI2Yqm9LF3xNGjNzkpcKUCdAYZ4INKqAIRTIYclLIqQsNT+OzQSZpoetPERU5cvhRDV1FSyN7rlTRxVLHm5DJOZccz0qYpVWknKDi0hgxAqzVg1ehVVAo/vJyg46DB5BUWEhneCJVSyQ9bN3MjM4PGgUFs2XKIIUNeQxRF1q37gFGjevPSax+z5seduLjZM2RgV96dPQmDwUjHvsO5cfUCThotz/Xsy/IiK2QHY8HGho9WzKaLfRUHLsViaamWBDMgMe5WbgNRW4UOJbsJwQo9FWkmDJlSjhv9yu9wyUtlbBcnsrJOU2W8gb4wjR02gzDn5pGsrcTTWo0BEXUjD9I62iDWqLAHc7LYdOISgUHeJAS3wAYjAw5kMN5DyXwHuLT1MHpnS6KfGcqBUydJz8mma+u2+Hp4gJ0GPhiKBhiS0xWZIMPazhZ9tRZzzeOL0SSFUB44dphSd0sKZXpkyJErFUz9QnJNL8zJ49rpWMZM/pK09DQczq4gMsybLZ8tRRTNjHhpIq7Bt94c155CF69wfPteIru0p0mH1jzz/ht1fi8vKEBtbU1+Zg6Lp7+LaDaTcjWRCe+9dl+n6L3YtB8+XgVqFSyfDcG+D6XZBv4BEii4w7PsjxRTTQIFhHNnrq0H5ab35N/1lBJFsbaN6upqJkyYQMeOHVm3bh0mk4mPP/6Y/v37c/r0aTQaDWlpaTRu3Lh2fqPRiMFgqBM2OW7cOJYte4CSsA+ZP26b3377Db1ez+uvv0519Z/vs3tx+/qaTCZ0Ol2daZ06deL333+vd97bt/mDcvv+Ly8vZ9y4cXz99df/x955h0dRfm343ppseu+9QxJa6DX0XhSkoyiCjaZgA0FEAUFQFMUCSBFBuggovYUaWighpJBCek82fZPd/f6YZJOQgKjw81P3vq69dnfmnZl3ZnZmZ5455znY2Ng8cJr+/fvrPgcHB9OhQwe8vb3ZuHEjb7zxhm7cuHHjmDt3LkqlkqVLl2JmZsbw4cN14wsKCti9e3e9dNDx48fz/fff1xPMAgMDSUpKqtffutvI3d2dyMjIP7sJ/vXknw1rEFlWD62WipRk8s+GYdU19In1Y+nSpfTo0YNZs2Y9sM3QoUPZs2cPYWFhD/TPq+FxnLv+zDz8/f3riegdOnQgOTmZ5cuX6wSzkydPsmjRIlavXk27du2Ii4tjxowZODo6Mm/ePG7fvk15eXmDm2+VSkXLli0fuS//pPPof5Wwa5ENIsvqogWSM3MIuxZJaOtmj2258fHxVFZW1hObzM3N6/12o6KikEqltG7dWjcsICDgkaIzH8bj8Jj8M8dm+/btad++9p64U6dOtGrVilWrVunSm7dt28bmzZvZsmULgYGBREREMHPmTJycnHjuued009YI2XW/162c2b9/f8LCwuq1CQwMrNff4uJi/i3oBbO/SFWZiguT11CeXkDbr1/AzO/Rn3R+9OpzfPTqc7/f8D9IQiacvgX2FtCnJdSNNs8rVXE0RvBW2hZx7y8JZjcSICoFgt2h6f0300eAmqjcCOAGMAKortjX7dReeKYL7AwABTBQqCdgdS6P8KhCxms9AFCjBRMtErMTkDMXs4IWNJ8PZVWg0IB4ggjfRWXEiBW0Kssm2TsHl3gbbjcDiRockiHNFrKagUYiwjrXFcdkIXXIIAboBGotpP+oQe5Su6H2TACbdMixh353buF46Br7PEZToZXh2hlShU3IXY2Yu7fF2FVHj2nFMjRGDsgVhqjKyimTOfCLuCeSNCiqALEzODua4dPzFRBLycy6hqlDG2QSSMmFu40UHRMXG6IxVGJj6UxrP2Nabfia0ZafYCg2Ijlfg8LAkLKKcmxEIqYpPCi+q8FN641MFMm+uDUknd3P2Op5GZkY0qNTBa+v/ZIzt4t575kxXLx5g6tRkYwZMIgJg4dSXFqKiZERixev1/3pbNn1K916tOSLFTtw0eYTlaEk6vomKlSVmHuboTAK4PM1bxDsYkHr1s+Rm1+EwZuzkDRvxp40JfOXvUVJeTn+PZ0wv2pMUmIGlara8qlWlJCOGSXIKUGOzFDOz46elHw4kbETFmB46xri7r2pzBHSJOWoUXh5oEi/x/Pae7TOzuJ2UBXnNr5De5khlz78kMS4u+w9FEelVozs/S+49spkunToCFI4cCuBzrcvEBNsDtoi1k+bj1cz4clZeUUFU56p9Qi7GRPN7mNCKPWofgMI8PRiypK5hO35jcjzgm9BEVWUZufTe/xwfFsGY+1gp5ve1MIMJ083App44CUvpam9EXs++w6qhHKwu79YR7enGwpm3727mOKCQi4dOsHSX7dw98Zt1r//CVYOtrRo4ceWWW9h6ezE5B82oq2u0FPxF2/A63JDiDinQgXRiXrB7P8zhTxa9bRHbfeo+Pr6IhKJiIqKarQi3KOQm5tLdnY2np7Cw44tW7aQmJjI+fPndalSW7ZswdLSkr179zJ69GicnJzqRTHt3r2bXbt28eOPP+qG1TXU/juwtbXFwsKiQfU7NzfhQDI1NX2ox9GjUHcbXLx4kbfffrueYbdC8eBSsX5+fhQWFpKenv6no8yioqIAwcfl7t27JCYmMnjwYN34msphUqmU6OjoRv3njI2NCQ4OblDVzNzcHB8fHwA2b95MYGAg69at06V6btmyhfLycl1kAwg3SRqNhtu3b+uEgF9//ZXKSuFcm5qaSmhoaL3t9rC0PT1QkfHgSqh/pt2fpWvXrvTt25c5c+boDPDv59tvv+Xtt9+mf//+HDhw4KGRVn5+ghVBVFTUn64gWfP7rzl3/Vnat2/P5s2bdd/nzZvHhAkTdMJvcHAwJSUlTJkyhblz5+qOqwMHDjRI9zYweHTfhH/CefS/TnpO3u83+gPtHpUHCU51xazH9cDsfmqOzTt37jQQnh6Vx3FsisVi2rRpU++/6c033+Sdd95h9Ggh0yM4OJikpCSWLFlSTzBrjLrbae3atfUemPn6+vLrr78+0L7hn45eMPuLJG07T+KPQu71zY/20GnTq39zj/4dXLgD+cXCK8hdqE1Qg7WxAS+29+ana0m83u2+EnSVwO9dO6YASVAZAserPUSzCqCJq+B3pKMLgpF/GaCBcnM1L0aEM8rKlRBVOk7tUuB7Pzhd3T4WmAmORir6npKTLi8j07YMf4UJV1scJ9fKmae+E56+Ge/R8nL3S9zKKOSz8lb8XColveAgwdpyLowci/wYXOkEgw+Ax004Pg4STeDoIPCNggHJWkSIUJSATAWVcogOgL77oNJAi4GnCNvmcFoKJtIqHFYvJsZlDunWwsbJKxbCoLW6gGgoNfHFxi2ElFI7vLxscG4+iTNXctGYuiEqA4MiwEzwiEpqLUIsFdJhNSolPX0zOPb9Km5b+ULgRLQI/avSVKLOjqHizE4ASlzdEY8bjquhL5kV93BXBKCpKqCsQrgJlquVaLUaKsrFNDV9mfmyp7kV8wO2wcEcSYijf9uO3BCJiD+8i5/ChKiDpII0yuzLaClzx/CYAc8PG46psTGVVVWYuRnQtJU7GrUG/zbOXLgZQUhzL8QRp0jGQthvIi1aTRmq4mtItMEcOnSH3FzBa0t0JgzzIB8Si7SUl6kgspx0RSaDerbi3veZiEQ1WR5a/MmlBAOUGIKhIZXRMQy9E817Q4IxeeFZ7m78kfWfHaVlsw4oT56hsNcgPL1siNH6cONoLEZ2pvTuF8yCVT/ww7Ld9OrRipf69eKXA2nczSvEVirH72wyW8xiedXPiadKrwtiWTW5hUV41Xy5778/K7/2QiT7cjQBi8MI7tUUlzdf5bMJMzEtrEIjAjNvB4a9MrHetFqtls9efZd70XF0b+JPttiBcqUSqmqFC2PLxqMxjM1MKC4oxNDYCIlUytm9hygrLiE1roTiyKtotVryUlKpyM9l/JwZpMYm0Gvc4zNfHjcQkjPA2hy6P1pE+yMReVcoMOz952u+6LkPcx4tvf5R2z0qVlZW9O3bl6+++orp06c38DErKCj43afNn3/+OWKxWCe4lZaWIhaL611c1nyvK8DUiCkgGGgrFIp6w/5uxGIxI0eOZPPmzcybN++JXAjXXd+UlJQG2+VhjBgxgnfeeYdly5Y1WjXs9/ZdWVkZ3333HV27dsXW1hZTU1Nu3rxZr817771HUVERn3/+ua6Aw/1UVFQQFRX10IggmUzGnDlzePfddxkzZgxGRkasW7eOWbNmNRBPpk+fzvfff8/y5csB6vne1aT0/n/6nfx/x8Dh0cTUR233V/j4449p0aKF7ob6fkQiEd9++y0SiYQBAwZw4MABQkNDG23bokULmjZtyooVKxg1alQDH7NHOXetXLkSMzMzevXq9dB2v8e1a9fqidY158C6SCQStFotWq2Wpk2bYmBgwL179/5S+uU/4Tz6X8fR5tH8MB613aPi7e2NTCYjPDxcd+5WKpXExsbqfnNNmjShqqqKy5cv6yLRoqOj//KDoD59+mBjY8OyZcvqmf7X8HvHpkaj4YsvvsDT0/MPRVzej1arJSIiol4V6AcdmzXXJjVcuHChwfe6KaaNXQ+4u7vrq2TqaRyLYFfEcikaVRVWrf7aExo9tbjZQmYBGBuAlWnD8WtGt2XN6Dp3wFrgTeAUMBZ4/QEzzgTGAyUgHQxWnQTxyMasWiz7HtgJDAL6Am8BLYA7cOxABj+qE/nRNpGeFvYcXfABDK8z7+polp55DpAvfHbOU3ChjYhrfv3RiHoR3UyJ/w0z7gQo+e78XQDm7L7OQfNn8Y7pTLatFf0iLAg3h3wL2D8YWr0MbkWQkAJVMjAtMKbQHI4NgGQvdOJImquGquJMhmyrvmj5ERw6A1nZGCt9cLobhKwzVMqEaaqfq+i6X2zZHs9LUOEiRIklSUzRmAkb3yIPchyFbWSkgKtNQKuuRCKqwNy+KUd2HiAv7jpwnQTbTDJFZkhEhpwr2Mdgw6fxkshAXYltdeWWxR2ns/bkJYriN6K1rkQkMUckkiE3bopELEZT/QDIQFRFgI0B4IytiTkiqQytVktJkQqRSIRWq+WqKh5NlZrYqgz8cpqz/ogaK1MJ1sZFXI1IxtPPgebtvZHLpTjY2HL63Ho+6NYH7aU45F5NGTmiN6cjwymvqMDN0Ykgd3+sbc1QKkt5JsQE76KziJyCWCtvSXLCCZSoOJB+AVWF4N0mk0mY1NyI/MsltCUF4wHj2PvrRd123bX/LCUxyaBSkRSbRlIsgAs2EYlMHXyLuyUyAm4e5QVrN3ok+PL94ePkZ+WRuf8a4hsV/OLRms/Nopij8EcmEtPPyZiDIUZsOSuIn5oqDQd3X8KyTmlrc+P6pWI7NGtBXmEhYpGINh9HQG45XE7EsrA7C7OEC3etCFSTG1aurFSpSI4RfqupMXGMnzOdX9dtpTCvkMryMkQSOdM/m09cxC0cPNwwqfYsrKqspE3f7uSkZdBn3HBkchkhPbtw82w4ZlYW9HtmPD/OnIWjvy+BPbtj9ASeAnu7wpoFj3ee+0/Bx+uEWikr3oQ2Qb8/jZ7fxw8bLFE8NC3TEgV+PDhV7s+yevVqOnbsSNu2bVm4cCHNmjWjqqqKI0eO8PXXX+ue9ILgi5KRkUFlZSUJCQls3ryZtWvXsmTJEt1NWu/evXnzzTd57bXXmDZtGhqNho8//hipVEr37t0fe/+fJIsXL+bkyZO0a9eOhQsX0rp1a4yNjblx4wbnz58nKOjvOwBcXV357LPPmDp1KkqlkmeffRYPDw9SUlLYtGkTJiYmrFixQtc+KyuL8vJyioqKuHLlCsuWLSMnJ4fduwXDd0NDwwbrU3NTU3f47NmzGTx4MG5ubmRlZfHRRx+hVCp/9+n82LFjmTNnDqtXr6ZXr15cvXqVH3/8sYHPzZgxY5g7dy5LlizRR489Biw7dcHA2YWKtNTGfcxEIgycXbDs9PAUyMdBcHAw48aNY9WqVQ9sIxKJWL16NRKJhIEDB7Jv3z569OjRaLv169fTq1cvunbtypw5cwgICKC4uJh9+/Zx+PDhegb6BQUFZGRkUFFRQUxMDN9++y0///wzmzZtqnfzfvv2bVQqFXl5eRQVFekiuGqi2FauXImHhweBgYGoVCo2b97Mrl272LVrl24egwcP5tNPP6Vly5a6lMx58+YxZMgQXYXe2bNn8/rrr6PRaOjcuTNKpZJz585hYmKiO5bi4uIoLi4mIyODsrIyXV+aNm2KvNqDVs//b7q0DMTFzobUrJxGfcxEgIu9DV1aBjYy9s9jamrKc889x5tvvqnzGX3//ffrPczy9/enX79+TJ48me+++w6pVMrMmTMfGtn8KBgbG7N27VqeeeYZhgwZwvTp0/Hx8SEnJ4ft27dz7949fvrpJ1373NxcMjIyKC0t5datW6xcuZLw8HAOHDhQz9et5vdfXFxMdnY2ERERyOVyXTTyBx98QPv27fH19UWpVPLFF18QERFRzxNx8ODBLFq0CDc3NwIDA7l27Rqffvppg4rgZ8+eZdmyZQwbNowjR46wY8cODhw48Je2yz8ZvWD2F7EO8WLQraVU5Bb/5UIAemrp1BQCXMBYQZ1qiw8hD0EsA9gKPA81AUT1yAJKhI+iRBj5LmTlg4MVgoL0LaAB1gObADXQH1gItill2F0wIEtegZ+54LnFfARxTga8LQyq8gORJUjyocRHxMWu1ctDxqUXb+GvbInXehO+K2vDFI9LtD5vhXQckOeFtQtE9IDbadXzEkN4OsjV8MrXIFKDVgFRn0FytSWHWQmUmFSh1qo4McGCQT+BvBKSVfDzWdBqHek9YwqBi6t4YZWUZHchUk1lKKyzTAqV1ZmFjqnQ+jysnwZVtdmGWBtCpkRoX1Zd+EAkltHriozDrU0QBT+PuX1bSrKusTV/I1q0SMUSqjRqLskO8fb896nMzaFFF+GpTkKmGKcCFUWXdyEJCiLbwRZXhxcxkJiioYqaU1NOcR4GWkGcCPZujkhTREZODgZGbXl/VEc6NFEy6cInpBRlYyIywMyyPYWlEvLziziTksnGlT8zYGQbRFqwsbQkyMcHhcKQxedPMOO1j/ny27107fwyk9/uj4WNKZFxsYzqN4D1O+Zy+dYtxNUVZG9t+ZEWR34jkGJO4UFhfu22GftKT2x97diTLiUzNR+b8Dvs3bucYcNmo9XC3fOXMWzSlLLkZADadvXHyd2apLhM1Ii4Y+CA5sXnWf3Tdsx3bqQwPQMxGsKLs+lyO4zh5g70ae/Crkold5zcMBCVsap5II7Xb3M16jZpcXk4WdhzLSKGPoPbYGqhoGvr+uFUVcXFDLkDBruuCzscwNECTkXr2oi0kJdSxK30ErrZGSGXCOsuNzDgqakvcPG3Y3Qe2o92/XrQrl8PMpNSuHTkFAXZuSx/aTZlxSWIRCKa+LsSfeQQnn0GEhclVI5r3qU99u4uhPTqQmCHEGQGciRSKVbePhgaKZ6IWPakiBN2IxqtIGLrBbPHgxgRo2nO11x4YJvRNH+shv81eHp6cvXqVRYtWsSsWbNIT0/H1taWkJAQvv7663pt58+fz/z583Xl5tu3b8+xY8fqCWEBAQHs27ePDz74gA4dOiAWi2nZsiUHDx78Swb1fwfW1taEh4ezdOlSPvnkExISEhCLxfj6+jJq1Chmzpz5t/bv1Vdfxc/Pj+XLl/PUU09RVlaGh4cHgwYNqucnBsLNkUgkwsTEBC8vL/r06cMbb7yBQ/WDnEclJSWFMWPGkJOTg62tLe3bt+fChQu/WwFVLpczdepUli1bRmRkJE2bNm3UFHrYsGG88sor7Nu3j6effnwRt/9VRBIJ/p98zo1xI6gTFl49svrGednKJ2b4fz8ffvgh27dvf2gbkUjEl19+iUQiYdCgQfzyyy+NRoG1bduWy5cvs2jRIiZPnkxOTg6Ojo507Nixnt8QwPPPPw8IwrCzszOdO3cmPDycVq1a1Ws3YMAAnWceoItwqUlfU6lUzJ49m9TUVBQKBYGBgRw4cKBelb333nsPkUjEe++9R2pqKra2trob9brbwc7OjiVLlhAfH4+FhQWtWrVizpw5ujYvvvhiPdGvpi8JCQn/2kiWfxsSiYSVs1/imbcWVWe21FLzb/7ZrJceq+F/DZ9++ikvv/wygwYNwszMjLfeeovk5GQMDWsj1devX8+LL75It27dsLe356OPPmLevHl/edlDhw7l3LlzLFmyhLFjx6JUKnF1daVHjx589NFH9drWHNtGRka4u7vTvXt3vvvuuwaRknWjza5cucKWLVtwd3fXFe0oKChgypQpZGRkYG5uTsuWLTl9+nQ9H7dVq1Yxb948Xn31VbKysnBycuKll15i/vz59ZY1a9Ysrly5wgcffICpqSkrVqygb9++f3m7/FMRaR+HM90fRKlUYm5uTmFhoT63XM/jQYsgbOVWf18E9HlA26+B28DLwP0PNF4Hztw3rAWwBn7Z+SvbVh6gv7YvZu2kDPl0gCDOfVrd7h1I9IZ9ySCXwEg/UFvB5mpPRKm0igndpZhPAap1ihtG+TQrtYSpcLYNpByDZlchNgDi61xHizQwdQ1IsgFPKPwO1p8ERCCtgKo6lg+OySDWgFEHiK0W3pp7Qndr4A6wCU62AMOIfEyLqjjR/x5qY2cc8xx4ZiNkO8MW4boKS2PBP87KVEiPBfBVQWIsBF4FUzfYc1+08LnS79mRvJnngvqytNtkLAxMMJDKOXL+HHH3EunSqjXl+HHqci6F+2ehLc0jfKAbFwozmOX5NWYSWyqKr6OuzCLQrw0BzgWUlZdhbuHNW+sPoNFCp4Ah2FtKGBcK95SZHEm4QisLbyrLvTnyww+U3dpFlbELX+2LZPbS2qipph5ePNNfuKgbPPgN9u8XdnbHnoGcP3EbExMFkbe24exsS1T8XQ5eOE9xkRKAlC/XUnr7DuE4EVcd5WJkYsBby0YRfuoOv24L1y1nzZo5TJ68uN52kTQNwKk8l0mzBcPozNR8rhp7ctOjDQD2R0+R8P1a7qdDSy/6vtgJRCL2GwVxW+7Id4HGjGvmglar5eetexk+fglarRZfL0di7u6tN/2tY8f5ZMAwvvWfhqG4+ons4qehvRe8vRMuJYIICno2oVnbZuSqRQy0k7Olqwund+yj4mgSrn7eNJ01ALFMSkF2Lmf2HsS7WVOKCwrZ8MGKessrT02kPCkWU/9gJNbCjejzH7xJ615d67X75dsfOLRJuGl4dfn7BHZozT+B7Dz4ZAMoDOGt5wVR/7/Ek/7/vkIqP3G9XqSZJQpG05wQ/p3eGHr06HnyZP68m+g3Z9QrAGDg4or/spXYD9MLk3r0PEl2Hz/LzOXf1isA4Gpvw2ezXuLpHp3+J30oKSnB2dmZFStW6Lwk9eh5FPQRZnr+HYiAN4B5gD3Q6iFtX3nIuOXAe8DR6u+tgeqCRt37dKXF18G4KV3RntXCesjOgfRWEHAT5Gshrh2YuEO5ApIqocU1GBIA2UAzDykKAyAYQTCzgGZOlmAMDIbk3TByE4iBJrdg/3Ao7QSWJoKHm6QjcAVoB0YmQp2BMsBYBoV1ViG92mbFqQzkUjCQQVyaEDHWSwWi2yCJu8QiPqFDSz9skk3QiqTI279M2gsmhPsDRcI88quj8XKLwMESWvvA/kuAK6S7VG/36rLsNcwOeY53Ow/FzdyKvEIRNg6QlafkXMRVAA6fP8sbz/rhbG3NCcfvqarUMLO9iMyKZG5GWZOckUl50UUMTdtyLz0dY6MmtPKGdzbuZOc5odKRWCTmk5cHsfFuMR1sLZnUvPbJ5ol0wVROWpLCKy9PoCw1B4WzcGNvWC7k6Gdm5nLz5l3EYjHN23UmLjIarUZLkbKUVau2M2fORLb/cIICCzFW1Q+ipNaWaCUyMtS16Y4ycU0UVm0YpFwu5datuw1+WuLbt3B3kaBWa5BIxKTdyyWnTAvVgtnwYjWCY40WW4oJcLGkyNqTCTOGkFWaDYCNWlAto1LzoJkLv4ad5kZhCpNe7833K4/gY9nwCd3Nw8eoUqm4XBhDZ8sgCHGHfkFC2F5eCTEVxZiJpZxrZkauWlifG1EplCz5ia7Z5VxMziQi/xJiuYSmbwzk+/nLuHvjNmKJhAnvzay3LK1Wi4WpggwgoJk/nj36EBdxiz1fraeitIxOQ4SnU0e37NaJZQCZ91JRmJrg7O2BgeLxeVRdj4aVP4CXC7z7ouC/91extYJlb/x+Oz1/jhCcaYkTMeRQSDnmGOKHzROJLNOjR89/B/thT2M3eKhQNTMjHQMHRyw7dfmfRZbp0fNf5ukenRjarT1h1yJJz8nD0caKLi0Dn0hkWQ3Xrl3jzp07tG3blsLCQhYuXAgI0V969PwR9IKZnn8PfYCuCOmRf/b8KwHeRxDKXIE6mW2mZiaYepjADRBpRLAaLKWw9xVI7goDV0Lrs9DrAFQoQOUFRIKXAXjtB2qiwN4CBgIugAWk5MDVWHDSgNISLKrT/RwMoCwBoizBVFHdn2pdSAaM7AWp26AgAS4Lmgv2FtDSG9Ky4EZ16phKsNoi8h4YGIG7F+xRXEcTp0EqE25CRdoqkooqSXQCSUnjmyYjH45cqzOg5v5VJKKqIhWN6i4tm7bnXJQcsNY1MzaEknIzzO2eojBrD+6OQiXHm4mQVSgGxBy8AuNCPbBtUcLHRy5ga9oWsdSCwoKrXIks51a8K9k5cbp5WhuW8PbP+/g57DfERhbEL56Po6lg1t156FCO/vgDPi1aMuatSfDjRW7vPUmZhyUtxvcE4OjRSyQlCRWxsrOysHXxJCtDKBv6+ec/cfNmHAcPnsfIxIDnZg3AMP4ORefDuah2wMNIS1ppKaXIeKqJNdm79yOprBXMVKoqtmw53GD7uaBEmlLA+hUHsXEw59aVRN5aNJ2efsYot19hx82aVDQRuWJz7klsaOJoQ6dWLbkccwtlSRnnzyRSWRDJ/tibjCuZyO3UOyAHFx8HxroWs2D1u7rlReWV8PqVbKx6PIvjwaMcECURsHYBNi2bgFhElUrFOg94efcpjGQyFkcY0lJ9hzRXPyacPYN5jgGIxDhYidmafxq3HCHlrDYoWYtXUADTVn7IvjWbSYqKxcXHgxlf/ERBWhoOvj7kZ+Vw+IcdAOxbs1knmMVcrTXWbtK2JddOnmXXF2tRmBijrqpiwAtj6f0YzP/X7YbYe8KrT0do9/gqlv9hrt2BohLo0uq+4iJ6GiBGRAC2f3c39OjR8y9DJJFg1TX07+6GHj3/SSQSCaGt/7cXYsuXLyc6Ohq5XE5ISAhhYWHY2Dx+L1Q9/270gpmefxePIzjFkPpm/nVZBPwMHAMSQVoFchWUNwHGgkW156lBGRjU2ENVALuBGj9FEVDH9+jwNVCWAnbgPRjuJEKpMUjL4Ko5oIGL0dDOv/pGez+U34KcNhD0DeyYUDuvzAKhgIFkD9xwq11cjcQRUQbXxoJldm+M824Sk6mmtXMAwW19uZRvCYBaAyaGUFxbBFFHRZVQiKGkov5wqYEz/h42RKU0NGEtqZmP1JkJQ0bi4Sj8URnX2VeK6sm+DzuDKq+EOGkabsXX0GpKUKvSEIkHEuLRDjtzcyxNTVFU5uFYlofSxoiDUVfYcTaM6f36AdBpyDA6DRlWO/NnOxI0uq0QbldNjx6tcXd3JDkli5S7d0gBZDIplZVVqFSVOjGttLiCzHvZBHh5oK1SI0PD1LdfIGzBHLRaLdYFatIvxmAAmOJPUbUqKjMU17NKsbO3wjUzkSpEpCRmk5KYgxd5xL41iVy/AFbdOM/PmRFQbS6u0WhISsogKSmDiIgYMjJycXGxoyKngMpyFQU2RpQv2UeHICfCWinwrzJmXvxNXeWbu3cT6bP7Fnkugq/idz8fZpxnbVGA+MtXWNyzP2U0YY1LMImqUqwUdnS+fg5NbDhDZryC5uvrkJjD8fwr5JPDuR/W0HXxZJ5fMFuXkmnj5ICNkwMBbVrU2+dG/kIhAbmBARKZFHVlFSZ1ihL0ffYZ8jKysHN1YuKC2bzZVyhvXVYsqLUntu19LIJZMz+4GgWmxuDxN2bzXbwBs4TwQV4eCeMHNWyzYS+cuQpjB0KPx1jRU48ePXr06NGj579Gy5YtuXLlyt/dDT3/AvSCmR49f4Ry4DrgBjSFFFdwDIE2vkAnoDuCqOYCmAAHq6dr2vjsSitAIRa8ySocwHYgaCvhXBbYXASXBEjxBE/rarHsFPABlFlBZvIl1M2akOpamyIoFsHte+BxFXpFQLIntOgGx6sgW4mu+qSprTsdJ30OgK0ZtOsE0cdAWW0b1JhYVoOfC+QohVdZHeEsOr3WSE0qFvqiUgsCXm4R+DqBp5MdJYX5yBUKOjU1RCwWtkG3IMjKL6Y86S42aEArwsvQiApVMakaEyRyG6TqXJwM1ZjKKimqFJbTzMkVhdyArn6CMaZGo+GXE8dIzcqiT8fO+Lq7U1peRnZeHi72DkgkEgqKlIRHRbB593zuRuYw8VnB3LOysgp7e0tAxODBXYiKSgQg4U4GzZu7YuLbhLcmTeGFt1+hz6BQypRKDnzyGenRMYjEEsRaQAue9iYMebEzCjN/MtItcfTx4+vwgxi4j8Yy4RZmuy+jLCjFnxxkaCiKuc2d8+G88cZYftl1lJKyClR1Ci4UFgoiUkpKlq6yT3ZhOSo0dL5eTufr5dDdXjCbq2bq+TSdWCbWqGlqXrtvNGo1K4ePplypZE1QJ4wkwjjtkVxEu78AF0E4pU9nruw6wJmRnwDQBieo0mDlYMeQl55t9LcRFxFJ+KETBHdqQ0DbVuRlZKKurA5xrBNV5d2sKe9t/gqtVsu2FV9jbG6GWCpBhIi8jCxa9ez84B/gH+DF4dA1REijtPwb7TKz6xSJyMprZHwerK0W21f+oBfM9OjRo0ePHj169Oj5/4BeMNOj54+wBrhc/XkhuPQXtDEdbrng/THEqyDpHVLaOZI1Bpq2ahj8VloBm08I782SoOthkCYIqZiqZ+GGL/RWQh8XMK3xZNNCmgvsnAAaSRvS5CtxUs0EwDJbEL+u3oXbvaDLaejvCXSBsVohpXLnWSGCrC4ZJXAuShDL7q9gUxeZFAa3hahkSM6uHS4Vw1MdYdeZCjTVEVbO1pUUlMhQlQrRauNC4XIcbNh0nrt7FmFqZcUryz+jQ4A12YVwLR5sa3U/TEQVjDcqAiP4WdyBRImU0rIYAIpKS2jfrAWRcbEANHdywcJA2LpnbxUSm+1JRamSk5cuIpWI2X74IOUVFQR4ejGq3wAOngkjOjEBgO69B9Phk/nc2vUbnqX53L6dgJGRIQFNPJBIxKjVGuycLFCjRa2t4MS8twl9ZhQ2Pr6o1Rpe2rCGE2u+51pSAYXfHQNAlJnE7X3nsGnvTNteI9i04j0Kwg5zXCrmtXlDGTS2PVtWHycJCyzJoBBDBvWcQjenKkKtjDmYboijkYRmHVrhH+BBZGQ8x45dAkChMKC0tBw3d0dutLMgKNUcY6kcptUvOW9gb48ou5K2FYmEpEdiltiDKtMgSouKqSorJfdeMgburoS1NKRdvAiLYg0ilRoyCmsFM5GIkBGDeHvALIxic7Du0krY2fdRVlzC1eNncAvw5Zt3PqSsqISzvxxCYWLMjFWLaNmjE/HXo+j37DMNpk2JjSdsz28AOHq6MWfTKkqURdw+f4VLh0/Sunc3nUj4Z/Hz+EuTPxb6doLENFAWw/PDGo43MwEnOyGVOsDzf949PXr06NGjR48ePXr0NIJeMNOj548QABxGMBHzum/cTmBXKeRUgfwO+U4n2d1jDJocSLkGQ9rVaauCwg1QWl3NPt0ZpIeEz9IKsE+DHHsQdQQzMbXROaGQkapGU22SaSi1pw+Qdh587sDP44Rm5SYQ/RwEdhS+i0SgLGkoloEQdZZVIHz+vZK5RaWCYFYXMyNwtga56jD5ZWaoqwoIatmeA9fsAUjMggt34GIMYNEBs94fUHzxW1JiYvBr04EdZwSfNXNjE4b0GEhUYiqhRmWQcRsAV4NcbqWeQKPRIJXK8HB0pGf7DojFYs5FXMXIUIGNpSUl5XAlwQKZwhKJzA4H68v8sG+vbp1SswSPMmMjI25eSuC37eF8uSiYUmdfpDN8aXbuN27ciEOpLOHtb79j976P2XP4KB5+wk6y7B1KxvrtrN4WxzeL3qSqqoq5c19g6tRXWNxvBgBiNMjQcORyNlxejaHCnqJCoSKQukpDQVwSuaUi5HIpTl0HceFOPPEp2QzSRKNOUaEAzPCkolLCV6vfxtvbhZ07j3H8WDhitISK7zHsq6UgkxMfn8akvDQu/3aEHqFf4N82hCyvtnTp2or3gjwJKE5BURgHlgbEfXsY2Y0dZKiK8HZwZeDYSUS38eaCgZz4dga8EiGHFq7Q2qPBPm+6fyHZ16NYNGECmsCveH3Pdhz9fHXj1y9YTuT5y8gM5JiYm1FWJETElRWXEBV+jRc/fOeBvydrR3ss7GwoyMrBu3kgYrGYK0dOs2PldwBUVqjoOPhB5W7/OcikMHXMg8cbyGHtB5CQAk29/3f90qNHjx49evTo0aNHz4PRC2Z69DwCReWVzN57DeSw/OuWmNrLBBP+GlKBpQCuIJkNNi+iUjRBU118oCYrTccOcFgLzftCuls+nS6Ug6Mj5EG5K8Q2EZrdOgZN1wDPIBQLAAJHSoi7XEBuWSFjgzpz7TZkhoDKFgzFEK/MZ0f0JTytjSgobU9xqZSOTUDTiFjmYg1t/aGyEsorhUqaBdWm/xbGtZ9r1uHEjdrvLb2EdEsPQRejR5sgDoZnYWDUAYXCBiMDIXoOID6zdjq5Swg2Vh/i3dwUjbZWxKtQQVMvd1r6u0NFGVyrAqmUnNJK1MlCjmKbwED6dBTS9Xp36EiQjy/mJiYYKRSoKsFQLqJcBfZWCto3a8HVqNu65YY0DQSgf+euvDH5C0pLKlArS5DYgVgjYnxsXw4Y7idfXky2SQmpufmMGdmf8BvXUWs0GJr5EvDRYcJvXKOkRMhdnT//W37YfIC7sUKZeg1ikgwcBbM3wK7qNl1CrKhKN8A6J4HKmzKuZhihUlVx9Gg4EomghuajwAwVFWIZoZoEJMC+jT8yc+HbDOrXjrak4IwSw2I16RfCeP+HcN16dSWBEmURV5MTOcFVVnxqztT3h9K6wpC7zkIxAsNKEW5lBrhhAKllDAvuxqeKHNQaDZUWhrCmjhEeQFE5fHsKTAzgxa6c3rOT5Ju3ADixdgNjly2qbZpfIPw+KlSMnzuD2+evcG7/ESQyKW5NfDm+ZScXN23EzsOd51Z9hlRWWyDByNSEuZtWkZueiYuvoECXlZTqxpfX+fxvx8wYmvv/3b3Qo0ePHj169OjRo0dPDXrBTI+eR+Dz09F8d/4uAK6WRrzXOqh+A1PADFACzW24MP5TDkddxkjlgkJhhbONmN3nwN0KQj4DrgpBY90PASY/US6zgXwhZa2sVIvGWARqMM+onv8hYDYgBgMZdPazYM95C45fqq2Cec8HujSFbzZHkqjMJVGZi7PChRB7D67dhRd6Q3isIIoBPN0R3GwhqxD2XhCEq9Y+gteZkQH4OcHei/VXs6pa3LK3gHYBYFirfWBv54nGwJMyNRyJ0FCpzAQDQU0LcoeYVEjN1QIiNBo1afHxeAYGMbQ9/HYZylSw4wyM7w4YKKB9X/KVSi799CMABgamOtGrBkfb2kp6chmM7grpeeBpL8NQbkUTLy+i4uMxViho4S+okFKJhE4dWxAXm4rq81W4jh3OxvQxhOYYkxd0FFOrQRTnFVGQWkif8U/RtVVrSsvLSc4qIq/ElL697Ik6/yuxsUKonSL2CqO0meRgxFG8Ka8Wy2QyKRGffYg15bQVS3EYNQSrrh3xUlWx+sNfyM8tRl2tFp7DjTiKsbAyIyTnOgDXdv7M9AIJhYXFFCusMSwTjLBSi+qXMc2ReeFSeR0kcgrVQkqsSCSiQgLDjxZRIRPRMrqCjKpCrMTGyMVSys3EjOzbn5PHT+KIIRq1GnHd0t5rTsNmoWpntoUxQb16sG/Zpxj6BHH23A2sNm6n33MjAZgwdyZHt+zGp3kgAa1boDA25vi2vWi1Wla/sQB1VRVVynxuHTpCUM/utHumfkUNI1MTjExr83F7jhlGZUUFYomErsMHokePHj169OjRo0ePHj1/B3rBTI+eR8Dd0lj32c3CuGEDE6AVgr9ZTwNu5qQjkdkgldtQqYbL1UJVURSEXK2exrQKTL8CeQSH2i8m9CCYF4AoT8Ogo2qqJsvx/B4qZSBTAmeBLsKkcelQWS182ZlDYQk4WEJuMXia23A9OxmZWIKTieBH5WILEgk4WEBKbvXiFcJ7zs3aKK/LcUI1zg4BQnVLUwVUlFXS1DCFuxV2FGmNsTOHMd1qV720Ag5cgopKoRClqgooyyXrtw8xajkOB0sxzT3b0dwTzp+9w4mj1ymPO8bJGHs8P/gIFxthWhCKA6g1IKm2ysorLECtFlZUgymm1eujqlTxw769ZOTmMrhbd5r5CaE5FsbCq4aRfQdwMyaaX04e5+vtW3luyFM42try3XdzyMjI5datu3zew4fQk8aQCCr/Srrl+yJ2FLP/wDk+Wr0Xs6mvsLClAWmxN5FKpbz8zCi01eUvJRIxgZJ8RCqwpRRrSsjBBCMjQ0pLyzFGWDGxpopyKyG1UyaXYmphRH5uMX5+bkyZMoytWw9zJTqFwlHjsD32AyZpSZyLKkEZtb16TYwoNW6Ci4cN3Xq0wPlqJqn3hFRPucSUjzwmYtC/Nf7W0DTYg1JJMQYGcs6ZJCIuqYDZfbnw6Upid23B3sKeSeMn8erYedy6HkNXL1PMDI3oVlecMq113JsVq+Ttfp157+wpPps6F7Rwbv9hnWDm5OXOs++9rmt/69xl3fZRVwnioVhhjFQux8HPlzlzVnP27HU+/PAlunZtxf3IDQweWFRAjx49evTo0aNHjx49ev5X6AUzPX+Ympvhv2rG/U9iQhtP7KtFhD4Bjg0b3ANOVn/eDG2Xe7Dv1Hm0GhUisRxTBeQXg0oOGhGItHClgxRZ+xmIT0OxCWx9AezSof8eCR5nJWjd4ZfRkGAEza5CD4faxQW4wJ0UoRJlz+aCmX9ipvDq5hqAj4U9rb0MSM82AqBcJUxXd5dV70Z8d0CMKyRW21JF3AUfRyHyrKgMnqo8gLsqmU4yY/ZbT6Clv4y7d7M4ve8QVl7BOAa0IDW3tl+eDiDKyeRuQRJFxxfRfsJzQDtSMzNJLryLOv8MmqJ0XAP7EZcGjlbCOkTeg6ZutWKZWq3m1zPhGJi0RV2VjaFZO11a6c3kdA7miXHRyLgceYtmfv6UlJVhKJcjkUhQlgrbxkQBKVmZVKnVVKnV3E2+h6OtLXK5jIMHv6jdGIOAZJC7yNgv+4wRI97mwtnrDBrTnoxfN7P1sJYuw9pSVVVFbkEBCQlp1X3U4BAcSGbENQC8ZWXMW/4+96wc2LzwK27nSrDKSyAZc+Q/X6F1lZSM5DyS72ax0qkpPhb2vL1uH5FRCUjc3RC1CuFCajrq0mtolfXN4pw6tqBN9yZ8tXAv+TnFYGyMj6Md30odcTYwI7O5A/NfGKRrfyMmmj3x8WAiwyw3g5c2rOHG2KO4BjUl7HIsx85GAhCeXMzU+w/lFzrzdaGakyUa9vu4MEypYkhQE3xbBhMXcYtOg/sK7QpKufz1DtQulrQZNwixWEynIX0I+/lXSouKad61A+UlJXj4uKIsGMDqZetYtuW8sIgJ84lL2t/wWNKjR48ePXr01CM0NJQWLVqwcuXKv7srevT8q/Hw8GDmzJnMnDnz7+6Knv8nNCx5pkfPQ4i9c5exg15g/NDJJMbf+7u78z+lT4Bj42IZgAPgU/25MzT38+KN8U8zsZdQIXJcqFBh8plbcCcIvpgD50IgYCkEn4RhW8GmUIN5HhhUCEpWuZ8glgFEhQC1PuvYWcCUfvBiX0BUG20mq4BW56FPriU9g4x04lNaLlyJq03fNDMSXgCyFtD+FDrH/4oq2HJSSMs0NgRrbZ7QrrKEnNwK9ofDD0uWcPfkNi5tWEBORi7iasHF0wH8ncGveRBW9oLCd/XYEbRaLTuPHCIqKRFtQBMmffIp2fbD2X8JfjoNAa4wsouQuqnRaMgtyEdZWkqp1g9Ds7YYWw3EycYGQ7mwnBkxGn41DuIHk7b4evsRdvUqyzesY+n6LVyIKmf9UVh/FFJyoIV/E0yNjbEyN6eJlw8nbgjrdy8LMjJyqKysEh4deEKWMpfj4Rc4efIqHr4O5GYpCT95hxNHo7m89zyeZhbkFhYweGwHTMyEEL2zYi/uYkES5txwb82Cr/aw4rm3yYxNJK5USlFwD7SmVvilRbD9u+Oc+u0GWuCuqhTngkoio4SKneqke6i276Tq51/Q3qsVy+xtzYVosaORHPghXBDLAEpKyJsxlWU5vzDlxqfMnzqB8z9t103n7+GJt6sbNpaWtAkKJjYlGZ/Qrth6eBAU5IWxsdB/z05tGVnpwysXM3TTIhHT9cWOFHb2ZZynGQ6Xj/OaowfFkZfxnjKBBcfPsWHfEc5P/Jj1+3ey6Zs1nNryMwAWttZ8vO8Hvji5h0kL3+K1FR9g5ujMmf1HyYqJw0Aq/FhkZUrSE2rPIbkZWRzftrfeMD16/ldkZGQwbdo0vLy8MDAwwNXVlcGDB3Ps2DFdGw8PD0QiESKRCIVCgYeHByNHjuT48eMN5nfp0iV69uyJhYUFlpaW9OnTh4iIiMfS1wULFuj68aBXYmLin5pmwYIFtGjRot60SqWSefPmERgYiEKhwNramjZt2rBs2TLy8/N17UJDQ5k5cyaJiYm/u6wFCxY8lm0BcOLECQYMGIC1tTVGRkY0bdqUWbNmkZqaCsDJkyd1yxWLxZibm9OyZUveeust0tPTHzjfn376CZFIxLBhw+oNb2xbOjg41GsTGhqqGyeXy/H29ubdd9+loqKiwXL2799PaGgopqamGBkZ0aZNGzZs2PCXt4uev5+JEyciEon4+OOP6w3/+eef//BD5927d/Phhx8+zu41yuM8F16/fp0xY8bg6uqKQqGgSZMmfP755w2WefPmTbp164ZCocDZ2ZmFCxfqHs4/DuqeA2r6HBgYyHffffdI0xUUFOiGabVa1qxZQ4cOHTAzM8PExITAwEBmzJhBXFycrl1j59KwsDAsLCyYNm2abv127dpFaGgo5ubmmJiY0KxZMxYuXEheXt5jW389f477fzeNve4/V/+RaX5v32/YsKHedPb29gwePJjISOGB94oVKzA3N6e0tKHfb3l5ORYWFnz66afA4z9m/2voBTM9f4iw4+dQFhZRkFfAuZMX/u7u/P/BENgI7EVnzm+kUGBpKsfWHKQS8HaEa2Pg8FDQVh95NddLEjWMWCem5yHgORFsBsVA8HMWvM6a3V85rxQ4CRXpsPtc7eDuh6DrMei9GSL2X8PG8iRQSaUawiIhs0BopywVoscAeB6UC6itxImgnUWnwITuYNihB2pbF87Iu1IiMqE6Q1JHlUaLs43w+UaCELmm0WgokbthNX472m7LycqvwkghROgZyOQ4uXuQX637FJcJ6apqtZrrp06ydvtWvtz6Ixt+OYaBcbPqpWhoXUcwTC8XOlEhltPEvwnXYwR/ucrKQq7F5qCtLiaQlif4nL3x7PNMGzsBlcac6wlC9NxrM79k7heRfLEPzt0WUic3H/iFsCuXaRriRmZaPhpN7QWb6vxFgps04fC5s7To4E2/Z9oAEH41lou4Ef78fExfeoFAyzJkWkGZrCqv4ObNOFKK1JSbOiAV155ybSUyHKWGyKVCoK+vryvy8jLdeORyRGjIzC6ksrKSCxfWY2Vhphtt3sSLlyS3cF34LmpLM1RlZWx9bwHDD8XhvDGCL09HM37QEF4bPY6wK5fZfug3vtu5HVWlCj8/d+7c2c6lSxuIevYVijSwKb6QzLLa6hSBFgYc7OnGd+0dOfb5Kopzc7l56gyzV63n4q1oXlnypa4iJkB5XB3B7T6qVML2NZKLGd3ChsFNLejf3IG9Hy5i5/wP0KjVfDlzHru+WMtnr75DZYXqgfPS8+9Hq9GQm3qHtNiL5KbeQdtYxZLHSGJiIiEhIRw/fpxly5Zx8+ZNDh48SPfu3XnttdfqtV24cCHp6elER0ezadMmLCws6NWrF4sW1SmEUVRE3759cXNz4+LFi5w5cwYzMzP69u1LZWVlo33YsGEDoaGhj9Tf2bNnk56ernu5uLjo+lXzcnV1/cvTAOTl5dG+fXvWr1/P7NmzuXjxImfPnuX9998nIiKCLVu2NJjG1dW13nxnzZpFYGBgvWGzZ89uMN3Jkyfx8PB4pG1Qw7fffkuvXr1wcHBg165d3L59m2+++YbCwkJWrFhRr210dDRpaWlcunSJt99+m6NHjxIUFMTNmzcbzDcpKYnZs2fTpUuXRpd7//o0No/JkyeTnp5OXFwcy5Yt46uvvmogFK5atYqhQ4fSsWNHLl68yI0bNxg9ejQvv/xyo9uohj+zrfSARqMmJv4kl69vJSb+JBqN+vcn+osYGhqydOnSeuLyn8HKygpTU9PH1KvGedznwitXrmBra8vmzZuJjIxk7ty5vPvuu3z55Ze6Nkqlkt69e+Pk5MSlS5dYtWoVy5cv193oN8aCBQuYOHHiH16/6Oho0tPTuX37Ni+99BKvvPJKPSHw99BqtYwdO5bp06czYMAADh8+zI0bN/jiiy9QKBR89NFHD5z2wIED9O3blxkzZrBq1SpEIhFz585l1KhRtGnTht9++41bt26xYsUKrl+/zg8//NDofP7suv9/QK3RcDIplq2RVziZFIv6Cf+3/1U6duxY7zw/cuRI+vXrV2/YqFGj/tQ0j7rvzczMSE9PJy0tjQMHDlBSUsLAgQNRqVQ8++yzlJWVsWvXrgZ937VrF6WlpUyYUFvU63Eds/fzR65f/qnoUzL1/CE6dmvHb3uPIJGIad+l7d/dnf9fyAGnB4+uUkN8Vu330HKQVIDGGqR9gK3CcHE5UF0tb0Br0IYIn/OLBU8xqQSYBVyGKjdQVds9ySRgUceEPz+nJTlmuSgMo9FqgnRpmVKJYOhvYQzno4RUyAAXCPaAW4m6QDPupIDCALoFeYCLB4HFYJUHxeVwtfId1PGH0VoHEV9oo1tmaq5guu9kLcaq5ywung7D2MyCaz7tGNt/EFEJ8bg7OaFFjq8T5Coh2FMoZHBo0w+E7d6JtE9fRCIRSmUKZsZqRCIJvVqI8amzbTd0dGJNbAEDnU2wMZDSJqgFh86eRCK1I9DTgdQ8IbWzaZ37v7KKclLSkzGUeVNeKSb+zm16jpoKwPX4Kjo2rW3bsWcg8ZEZXD4dw9hxfUiISaJMKiO/pPbiesigLuxefwZN9R++Q5tAmq58B+uYCEwx5A42WDi7cC21FJFIRIpDEJXVhQLMzU2Y9sM7WJgZs13yAjN2XUJhKKNi0adgYIBsxNM4OxihXLGKPIyQi0X4+7vz7LODOH9eqFbZZ2hLDFBjgBq6diTr5/0YDRvD2TwoliuYH57ApNYelJSUkVMgXKgXFRTw3TuL0FZpGD9nOq1bN6VLcgS/ViloLq3A1rDW+P+31GJkYhG9HI1pM/wp7pw+g4O7KwFuzkQlpdLS35uur02l9KNvUKfl0/PnDAi+AsNDGvz2uz49gKzkNO5ciqDL0wOwcbTnzLp1hK3fCICBuQXKvAIAKsrLUavVyBrMRc9/gYz4K0Sd3UpFSe3NpYGxJU06jcHBq+Fv63Hw6quvIhKJCA8Px9i41gQxMDCQF154oV5bU1NTXTSRm5sbXbt2xdHRkfnz5zNixAj8/f2Jjo4mPz+fhQsX6kSo999/n2bNmnHv3j28ve9/AvLHMDExwcSktlCGRCKp16/HNQ3AnDlzuHfvHtHR0Tg7O+uGBwQEMGjQoEajQCQSSb35mpiYIJVKf3dZf5SUlBSmT5/O9OnT+eyzz3TDPTw86Nq1a72oEAA7OzssLCxwcHDAz8+PoUOH0rJlS1555RXOnDmja6dWqxk3bhwffPABYWFhDeYDPNL6GBkZ1futbNmyhcOHD7NkyRIAkpOTmTVrFjNnzmTx4sW66WbNmoVcLmf69Ok888wztGvX7o9uGj2NEHFrNzv3z6BAmaIbZmHmwohBn9Mi6OknttxevXoRFxfHkiVLWLZsWaNtcnNzmTp1KmFhYeTl5eHt7c2cOXMYM2aMrk3dlMx3332XEydOcOFC/QfXzZo146mnnuKDDz4AYP369SxbtoyEhAQ8PDyYPn06r7766gP7+rjPhfdP4+Xlxfnz59m9ezdTpwrXXz/++CPl5eVs2LABAwMDgoKCiImJ4dNPP+WNN954rPYvNecAgOnTp/P5559z9epVevbs+UjTb9u2jZ9++om9e/cyZMiQeuvVs2fPB0bFbdmyheeff55PPvmE6dOnAxAeHs7ixYtZuXIlM2bM0LX18PCgd+/ejZ53/snsvnOdGYf3kFJUoBvmYmrB532e4umA5k9kmUVFRbz88sv8/PPPmJmZ8dZbb7F37956qc1ZWVlMmjSJo0eP4uDgUE/0lMvl9c7zCoWCioqKh577H2WaP7Lv60YwOzo68vrrrzNkyBCio6MJDg5m8ODBfP/99/WEMYDvv/+eIUOGYFunONrjOmb/i+gjzPT8IQIC/dh64Ht+/GUdXr4ef3d3HsihqHR6fHWM5cej/u6u6IhNq43qspFA8Dcg0YI4F6ShwNNAX2Ci4DkWES+ITyIRHLsOG4/BllPVVS6ThPkY34O+foLg9XRHcFwM6YPh2IAqUt1BrbbGwsiKJi7QqYlg6D+lL7QPgHvZcDFGEMAux0Ezj1qxrIa6//3X44V+FJfByyPsee2tCcicWjZYz7vVgUZnDmzlh0/n8c2CaSTfPoexkRGtA4OwtbTityuCUJdZqMXJUhChivKFEGRNXBxyqSEGJm0QiSSIAIW8/jK62BmxqZMTozyEiKt2Qb7Mem4yLz8zlK7BUsZ0E1I8TRRQoVLxa9gpVv+0lV9PH0KZtYWnO1QydUpvkqJvABDoIZwKxw0cTOeWIdgb2pOamo1CDfcSMzl/KZqz52/xyeIfGT9oCAO6dGP0oIEsXDgFY2Mhci777fcp0AodNaMCN1k5yWUSAloH8fzYHmhjr2FDCT4+rkyZMoxzlUpo58WBKmOym7Xi1i9H0FRWQUUFsojLmH+xjD7G2YSQymCzTBQGUiZPHsp7773Aiy8OpV/fHmhEYqQGCt75+kuW3LhM2xFzecfIhwkGzmgjbzNz0ny6uHTkl1+jcXJ2x0NtQNSFq9y5HMHxbXvRaDQ4fbGQUesW0GrV+2iqTfq/jytgxOlUhp5MYUeSkn7TX+PrrGSW37nB+Y2fc/ybjzmyejHS1p4MGj2coSpn5EjgTuNRZhKplCqViqzkVHavWoeVgx12brU33wc27qS8pBQnL3emLJmLoZGi0fno+XeTEX+FiMOr64llABUl+UQcXk1G/JXHvsy8vDwOHjzIa6+9Vu8GsYaam6uHMWPGDLRaLXv37gXA398fGxsb1q1bh0qloqysjHXr1hEYGIi7u/vjXoUnhkajYdu2bYwfP76eWFaXv9PLdMeOHahUKt56661Gx//evlMoFLz88sucPXuWrKzap1kLFy7E1taWSZMmPXDa2NhYnJyc8PT0ZPTo0cTHxz90WdevX+fs2bPIZLWPAnbu3EllZWWjkWQvvfQSJiYmbN269aHz1fNoRNzazdotI+qJZQAFylTWbhlBxK3dT2zZEomExYsXs2rVKlJSUhptU15eTkhICPv37+fWrVtMmTKFCRMmcPHixUbbjxs3josXL3L37l3dsMjISG7evMm4ceMAWLNmDXPnzmXRokVERUWxePFi5s2bx8aNGxud55M4FzZGYWEhVlZWuu/nz5+nW7duGBgY6Ib17duXtLS0BqnljwutVsvBgwdJTk7+Q4L01q1b8ff3ryeW1aWx8+FXX33F888/z7p163RiGQhCoYmJyQMFzEfZ3v8Udt+5zohd6+uJZQCpRQWM2LWe3XeuP5HlvvHGG5w9e5ZffvmFI0eOEBYWxtWrV+u1mThxIomJiRw/fpydO3eyevXqev8HT4I/u+8LCgp0Ud01/yWTJk3i1KlTJCQk6NolJiZy4sSJh/6H1fBnjtn/IvoIMz1/GKn0///P5uUdl0jMK+FEbBYjmrviYW3y+xP9GZRQfAgSHcC1FZg3UkCzBitTwYheo4WAkyCqyb5rDgQhVNnUAivhN1NIshWipJ7rCUnV5+68IiGd0uo9hIi0LhDQBAIQqlXmlIPjPMiZKcWgXI1UU0k6TqTnCdFWCZkQHi2IcHWyDRGLhOg1YwMoqRCyMy1NoI2vIJrlFkFE9bn4RiJ0DYITN6CqOA8zhRylunb7ethDQQnk59b6L8jU9b0YKio1gBiNBg6EnWH8gG70nTARkViChY0NXUaM4deLldxNykJiYsf1BMEfLSE1h30nD2AolzN2wGDM6kRMGBsKr/Q8ITKuplrm2YirXLpVmy5TXl6IsbwY90ArvMRFdAmpwshQ+E3bW9tgb21DU3dfzL49zySZLelmxgQYx6IsKaVVK3+8Xd24dfUUr0x8gfJylS5ts7yojJtqOVcJpAox2koR5BWRk3eLO5dvATa05x75aPjkk818+ulWoqN30NPBjK2JSjRRdwAtxqjoFfkLd7Eix9AMf5IRFYg5uW49cVHxHAhLxsffkxGtmxDlYIykTESfvm9gZGRI/ynLMLOywV9iwt4JHfhuwPt0oJL8S0dYNvIFPjRRCjtfq8W9iS9isRhbZ0eqEu5h6+qEpPrYTimtTc3MTMyBgkLMmrmASITMAEJbN9ONZ3BzcvacoSQ5g8qmMp2V3/0UFyoBId2uVFnE0++/h2OAPwW5hfz6k2D+b+3kQGD7JxNFpOf/N1qNhqizDxcH7pz9CXuPlojEj+9ZX1xcHFqtloCAgD89DysrK+zs7HQ3d6amppw8eZKhQ4fqPIf8/Pw4dOjQP+L/s4bs7GwKCgrw9/evNzwkJITo6GgABg8e/LeJOrGxsZiZmeHo+ABv0UegZr8nJiZiZ2fH2bNnWbdu3UP95tq1a8emTZvw8/MjMzOTjz76iI4dOxIZGYm1tbWu3erVq1m7di2VlZWoVCrEYjFfffWVbnxMTAzm5uaN9l8ul+Pl5UVMTMyfXjc9AhqNmp37Z9DwkSDVw0TsPDCTZk2HIhZLGmnz13nqqado0aIF77//PuvWrWsw3tnZuZ5wOm3aNA4ePMiOHTsaFXSCgoJo1qwZW7ZsYd68eYBwE96mTRv8/PwA+PDDD1mxYgVPPy1Ez3l6enL79m2+/fZbnnvuuQbzfBLnwvs5f/4827dv58CBA7phGRkZDdKL7e3tdeM8PT3/dH/ux8XFBYCKigo0Gg0LFy6ka9eujzx9TExMg/PhzJkzWbt2LSAIHXVF0aioKKZOncq6desYP358veliY2Px8vKqJ6L/G1FrNMw4vOchRx/MPLKHoX7BSB7jf3tRUREbN25ky5YtugjC9evX4+RUm64SExPDb7/9xoULF3TH2bp162jSpMlj60dj/JF9X1hYiImJCVqtVudVNmTIEN1x2rdvX5ycnNiwYUO9yFInJyf69Onzu/P/M8fsf5F/zpWbHj1/gEAHcxLzSnAwM8Ta2OD3J/iTaGeBSQT4GML2N+HZxh86AWBvAeOvQulNcKnxNbcDvkRI5wS4CmyBionCV7VGiCjzcoSbCWAoh2t3oWMIqJoDIjBHENF+PAkVlWBjBuL+MPiuhNNeEkqqUzFv1ym6WDdyzMxIKEhgKIcRnWDXOSHqLK9YWFZukSC0iaj9c4tNgztXr2OQ9BsqmQkEvyaIKRJwtREi0ToPm4yypAoHOwv6DO4HCPM5fh1MDNVUlESiVqWTLU5Dq+3KvgtniZVK6OjhQ1pmKZFrX6WsIA+jFmPxHD+S3eekpOTYoJJ0oDD3MJF34+jQvAUAiZG3yEq+R7KiB8kFhkjEMKor2JmDqVGtiulsZ0/rwCAiou/oRDQLUxPaNasfDu7oaMMkBw/ILcExrYSRXdtg1sIJ37YOxKckM3r0XMrLG/pslZaqgPsuuI2NoET4k1PJzbCztyY6TjCj3rnzGN98s5sWHs7ctTRBW5ZFDwRlMpBMMrz6EuLRAht3NzZOfb16hjbsuBHPHU0GN1XJ2CYbkn1DUFRbdfoN2x4TaOIKIY6+bEAQvgzzskir0PLLb6ex1GqxtLOhde9uALy++mNir91Chpqs+HhsPTwwWjCVoUeOoRo0lucTrKFcC2Pawtv9669bfillv13lo73LyK4owOK1HXz1VAKN8czMKZhYmOPo6YZfiCC4dRo7Gq1Wi8bAmMzkFIa89Gyj0+r595OXHtMgsux+ykvyyEuPwdr5z9/Q3c/jqvqs1Wp18ygrK+OFF16gU6dObN26FbVazfLlyxkwYACXLl1CoVBw7949mjatzQOvqqqisrKyXtrk+PHj+eabb/5Svx4H92+bPXv2oFKpePvttykrK3vAVI9G3fVVq9VUVFTUG9alSxd+++23Rqetu83/LHX3f1FREePHj2fNmjXY2Ng8cJr+/WvP1ID12wAAceFJREFUg8HBwXTo0AFvb282btzIG2+8oRs3btw45s6di1KpZOnSpZiZmTF8+PA/1Le66/dXttV/mbjEsAaRZfXRUlCYTFxiGH5eoU+sH0uXLqVHjx7MmjWrwTi1Ws3HH3/Mtm3bSE1NpaKigoqKikYjvWoYN24c33//PfPmzUOr1bJ161ZdVb/s7GySk5OZNGkSkydP1k1TVVWFubl5o/N7EufCukRGRjJ06FDmz59P79696427v/39fQkLC6t33KlUKqGY1M6dumFz5sxhzpw5D+1bWFgYpqamVFRUEB4eztSpU7GysuKVV1555PW7v69z585l6tSp7N69u15qNQgCnYWFBcuWLaN///71xPFHPX89rnX/uwhLvtsgsqwuWiBZWUBY8l1C3X0f2O6PEh8fT2VlJW3b1toHmZub1xM8o6KikEqltG7dWjcsICDgiUf3/ZH/LlNTU65evUpVVRWnTp3ik08+qXddIJFIeO6559iwYQPvv/8+IpGIjRs3MnHiRCSSR3sA8EeP2X/S9cvjQi+Y6flXsmNiJ07EZdHS2RJTwz/+9CYmVXgFeYCH3UMa5ghvBuV1IsYegpUarGrEsteBPgiJ0Wur33sBRtD3F7g6Dpy6C5FpiRlCRFhpBdxMElI7k7IF8Wpoe2FcRbWXdI4QyMOJJoLYBYJYV2P4D4JnWEUd72nb6uunmhRNgMuVBbx/I4s3FV6YiKS6p0Na4FgESIoEBU5cWYy5Kg6pjS/dgoU2dhZgYmbBMy+9SXnMYTZvPMH0qb24FCOiqAyKymT4OBuTl1NA55ZdUJYUE5sk5JneTPMm4kYiZQVCVFp5UhhZBYNIyRHSL2UKLzSlcjydhSeFmfeS+H7eHDQaDQbeUZh2nYVaA6lZJWRlpxHo7YOJkRESiQQ/dw9hPW/Whn+bGBk1uq9u9gnG76cL7MtPZ931q1heMWW661P8UnIKrVwOdQQzn6bOyOQSom8k1ysUIJXL6Pv9Ss688ibKvELSLDzIOHsDU1MjTEwVnL5ymaR7GSQmpmNpacpbi94k6oevUd25SSkynNW55L6/m5937KHGjk0EmJoacbswGRSQLSvSLa9HB2eGD6j5ZsOrm9ez76efOdPpaZ53N0ZeWkAFYGlf62lgbGZK7p1bfP/yNKRyOS+t/45re35GBFgc2oGx20tCw8i0hhvptc0obqez0Hci0yO/xMql8bQtACsHO8a9M033/U4C2FiAjaWIwVPGkxafxM9frcfZx5OBk8Y+cD6/h7pKDWh10XJ6/hlUlBY+1naPiq+vLyKRiKioqAbVEB+V3NxcsrOzdZEQW7ZsITExkfPnzyOufmK+ZcsWLC0t2bt3L6NHj8bJyaleFNPu3bvZtWsXP/74o26YmZkZfye2trZYWFhw586desPd3NwA4UL+r/rs1N0GFy9e5O233+bkyZO6YQrFg9Oz/fz8KCwsJD09/U9HmUVFCbYNHh4e3L17l8TERAYPHqwbX+NRKZVKiY6ObtR/ztjYmODgYGJjY+sNNzc3x8dHiLndvHkzgYGBrFu3TpcmU9P/tLS0elEPINwUx8fH06NHD92wv7Kt/ssoix5cCfXPtPuzdO3alb59+zJnzpwGpu0rVqzgs88+Y+XKlQQHB2NsbMzMmTNRqR5cAGfs2LG88847XL16lbKyMpKTkxk9ejRQ+7tds2ZNgwi1B91EP4lzYQ23b9+mR48eTJ48mffee6/eOAcHBzIy6ts51KTE1USatW7dut7v/4svviA1NZWlS5fqhj1Kypinp6dODAkMDOTixYssWrTokQUzX1/fBudDW1tbbG1tsbNreLNgamrK0aNH6dOnD6GhoZw4cUJ3rPv5+XHmzBkqKysfGmn0uNb97yK9WPlY2z0qDxKA6/rMPS6R+I/yqPseQCwW6/5HAgICyMjIYNSoUZw+fVrX5oUXXmDJkiW6ipf37t3j+eeff6S+/Jlj9p9w/fK40XuY6flXopBLGdDUCUfzP34BqaqCg1cgLh1+vfTwtqKFUNoVop6HXr0f3hYt8DYwHfgUGAvYgHoL8C3wNbAzA7aC2QcaDDtlY2MpqFf2lg37qNUKQllaLpSW146TVB/VTla1n7MK6vuAGcjA30WIRusaWDu8bpuraiVVaNmvympgZFqlgUqHtmgU9qjNvCiUujIuFNyqdZgmLkKaZ9mNHZScX43y9Od8+fVpbOqcPzOLvRjVfyR2Nt6YGZvg6+YOIiliqQ1SW3/kbu0QKcwwbjGOqFQzvBzAUAatfbS8PmEiDtURABWlpbqLQ02FIB6ZKrScuriTXUcOsX7vbpp4eSMWidi4dw9nr12lbVAznunTjzEDBhHoIzzRKq2AytpMRJ4+fQLDiAM8k3QVLWBeneN5T2sMb7yOyNERNx/hxjEhJp2+vTrQuvV9YdwaDV0Tb1CYV4gWyMgqAKCoqJT0tFwO7g5HWy2wFRQU8fPeMLq+NYcdBLOPJqQbOvPxqx8S9vUuwqXuNBk1nqcWzKe0tByLmyL8rJ1p5uqlW1xiYv0L/k5jR/PxLz9x5u2RrOrgTPtnJ9BhzDM8PfX5amFJ4G74ZWG/qlQU5+Xh1lyIALPu3I74ZhZonMzh+c40IFO4wDGVGTHl6y9567e93IuOIy8jmx8/XsW373xEXkZDL4gNe+HF92Hs25CaKQzb+fkarp++wK/fbyXmasOKc49CSmwC7w6ewFsDxpFw687vT6Dn/w0GRo1HPfzZdo+KlZUVffv25auvvqKkpKTB+EcRhD7//HPEYrHuJrO0tBSxWFzvIrzme10BxsfHR/eys7NDoVA0GPZ3IhaLGTlyJJs3byY1NfWJLKPu+jo7OzfYLg/yTgMYMWIEcrn8gUbqv7fvysrK+O677+jatSu2trYEBARw8+ZNIiIidK8hQ4bQvXt3IiIiGq0iCkJ6V1RU1ENFO5lMxpw5c3jvvfd0aTXDhw9HKpU2qOYJ8M0331BSUlLP9P2vbKv/MmamjyamPmq7v8LHH3/Mvn37OHfuXL3hYWFhDB06lPHjx9O8eXO8vLwaCLD34+LiQteuXfnxxx/58ccf6dWrl05gsre3x9nZmfj4+Hq/ER8fnwemOD6JcyEIUSrdu3fnueeeq1eNr4YOHTpw+vTpeuLg4cOHcXJy0qVq3n9urKkYev+wP4pEIvlDUbJjxowhOjr6oX5P92NpacnRo0extLQkNDRUdy4dO3YsxcXFrF69utHparb3k1r3/xWOJo8mnDxqu0fF29sbmUxGeHi4bphSqax3XDVp0oSqqiouX76sGxYdHf3ECy486r5vjNdff53r16+zZ88e3TBvb2+6devG+vXr+f777wkNDX3k4kJ/5pj9J1y/PG70j+D16LkPiRiMJVBWCr9bwTsYjD6Gpj8CvwDjaXhU5QAvAbnAEmCCIHaJELy+bt9V07E6jU9zdB/MfJEXT4az4acEHMwMuf3OQPq1ktPcE0rKhTRNJyvYdRaUZRCTJnyvQSaGjh4QEgw+TrDnvKDVlamgqRvcviekcFoYw/juEBYJ56KgrR90DhSWEZMG5iJhRSQyLbbmIqxNobWvIKr9fAHyxXaYtH+eHKUQhVdUBidvCj5iocEwqC3svFKg61eVqoLIe1pEiNAiiH5bTwn9aucnYuzAwajVaq7Fw50UGT1en0d2oZZbSSJEQHt/IXKN++onugU0YdCUl8lISMC58yjCk6G4TI2yWLjgKygqQqvVsv/0SQqLikhMSyXQ24em3rVuW5H34Og1wftsdFchTVWeUXuDOHXWBGbPGE6ltpJPUqRIxMUYf7qM9wyzeXn4bNRVGgJ8vPjmyz31+lZVpebtt7+kQ8+m+AW7cOPCXW6E30WtAbFYhEZdK0RaaUtxDd/O0YifkeNBGTJOXE6A6hTNOMxZfTqNVsVRqNUacjML+WbgO8THp3FjdyQAp05dZdascY3+VN9772sWL97AsGArzm/dQUDrFkz7/EMormCwQ0cy/a9hGuhF14nP0uOlyRTn5mJhZgUDVkJBGaw9Dd3re3fw8XDYdhlRzwA69g/ml283cWjTDuSGhqjKBRXXxMK8XmQZwK3q65XScohPAWd7sHF2IPrydaRyGRZ21vwZboRdoEQpiKbXTp7DM+jxpe7pebJYOfphYGz50LRMQ2MrrBz9HvuyV69eTceOHWnbti0LFy6kWbNmVFVVceTIEb7++mtdFBIIvigZGRlUVlaSkJDA5s2bWbt2LUuWLNE9Be7duzdvvvkmr732GtOmTUOj0fDxxx8jlUrp3r37Y+//k2Tx4sWcPHmSdu3asXDhQlq3bo2xsTE3btzg/PnzBAUF/W19c3V15bPPPmPq1KkolUqeffZZPDw8SElJYdOmTZiYmNQTo7KysigvL6eoqIgrV66wbNkycnJy2L1bMHw3NDRssD410Sh1h8+ePZvBgwfj5uZGVlYWH330EUqlslFfqLqMHTuWOXPmsHr1ambPno2bmxvLli1j9uzZGBoaMmHCBGQyGXv37mXOnDnMmjVLXyHzMeDj0QULMxcKlKk07mMmwsLcBR+PLk+8L8HBwYwbN45Vq1bV76OPD7t27eLcuXNYWlry6aefkpGR8bteSuPGjWPBggWoVKp6lWIBFixYwPTp0zEzM6N///5UVFRw+fJl8vPz66UO1+Vxnwtrbrz79OnDG2+8oYskk0gkuup9Y8eO5YMPPmDixInMmTOH2NhYFi9ezPz58x975E/NOaAmJfOHH35gxIgRjzz96NGj2b17N6NHj+bdd9+lb9++2Nvbk5SUxLZt2x4YvWdubs7hw4fp16+fLtKsXbt2vPXWW8yaNYvU1FSeeuopnJyciIuL45tvvqFz5871Kij+U+ni6o2LqQWpRQUPOPrAxcyCLq5/rXr0/ZiamvLcc8/x5ptv6ny63n///XoPs/z9/enXrx+TJ0/mu+++QyqVMnPmzCcerftX9r2ZmRkvvvgi77//PsOGDdOtS9306xpPvft5XMfsfxG9YKZHz31IkuD5z4BSUC15hAl+Amp8fGXA/XrFOaAmDXM/3PWA364IJvvN3OFSSwgJ/4ZCC2N2Dx+N9qCIcwm5AGQoy7mXX0JzZznO92kIBnKgDPKLwcRASN3MK4LyKrhzDkLygPuutfycIS5NEKuMDCAqGa7ECePCbkOAK/RsIVxSvlXlRKsmatzMxdx/zTK+uyD6aYGiUjA1giPXBI8yEAS8pm4w452JfLO8kGKtKzLPjqg1wozsLMDdFi5VCyf3cqADwgm5ta8gzAFUqUU4WoKFSY1YJnDoKkSnQCsf6NwU2g8YxKxZKzmy9h06PfUy/s3b4uPdG3FVDC0CmiASibCztKKwqAgTIyMUhob11uduurAupRVC0YDLyhJ6Dm+NuqoEJ3cbZr8xHPfqMPrPnDS0sVViXaZk5uBliMUiPvzwFeztLev5monEIrQaLeaWxvQdLvgjNPW358rrHXCYshOVRIJMIiM7uwAAc8qQoyZfpaWMxkO03dwcaNUqgAMHzgKQlZVHjx4hiEQitFotlRaW/JhQyBgPM8QiEflpaRhbWSE3NOTGjTjEInAyFeYdfeU66io1ktUncDyQyDzDgaieHUyVBqQyGRYODpBXAsrq8MXsooYdauMpvKqJvylcTKvKy3XFBRw8GkZlTHoa4pMKKclPRFsqBoIZ9cbLNG3bCjs3Z+xcnBpM8yi0CO3I6T2/olGrCen55G9+9Dw+RGIxTTqNIeJw409cAQI6jX6shv81eHp6cvXqVRYtWsSsWbNIT0/H1taWkJAQvv7663pt58+fz/z583Wl49u3b8+xY8fqCWEBAQHs27ePDz74gA4dOiAWi2nZsiUHDx78Swb1fwfW1taEh4ezdOlSPvnkExISEhCLxfj6+jJq1CidZ9Lfxauvvoqfnx/Lly/nqaeeoqysDA8PDwYNGtRAFPD390ckEmFiYoKXl5fuhsDBweEPLTMlJYUxY8aQk5ODra0t7du358KFC79bAVUulzN16lSWLVvGyy+/jImJCa+//jre3t4sX76czz//HLVaTWBgIF9//fUjp9ToeThisYQRgz5n7ZYR1Lqx1iBck4wYuPKJGf7fz4cffsj27dvrDZs3bx4JCQn07dsXIyMjpkyZwrBhwygsfHgK+jPPPMO0adOQSCQN0ihffPFFjIyM+OSTT3jrrbd0qcMPO2Yf97lwx44dZGdn66LganB3d9eZjJubm3PkyBFee+01WrdujaWlJW+88cYDRb2/Qo1/lVQqxdXVlZdeeokFCxY88vQikYht27axZs0a1q9fz7Jly6isrMTFxYWePXvy6aefPnBaMzMzDh06RP/+/XWi2dKlSwkJCeGrr77im2++QaPR4O3tzYgRI35XgP+nIBGL+bzPU4zYtf4BRx+s7P3UYzX8r+HTTz/l5ZdfZtCgQZiZmfHWW2+RnJyMYZ17gPXr1/Piiy/SrVs37O3t+eijj3SFNJ4kf2Xfz5gxgy+++IIdO3YwcuRIQIhYnjp1KoCu0Mf9PK5j9r+ISHt/rtX/AKVSibm5OYWFhf+6HFc9/wK2IqRMAgwD5v5O+5+AmofYbwIj7xufAUwC8oHF8IsC4qvtGno0g1tJIEtLwraikggrQeFXF99kXUIqbqb2LOjbkrZ+UPNfUlQmRHlFJQsRXWohwwcXGyjMgiIxhJyHLqagnQPbTkNGAfg6goMVJGYKglmNp1lNZUw/ZxjQujbVU/KI/10JmXA+CqQSSMsTdJKRncGxOurtRPhFTl+5hETugpntEBRyMc90EQTDQ1chuxC6Bf+OV1w1sUlJZOYXcTlJeNpfVRZFkGsOpmJTOnecAoCrlw/zVm9hYJv6kXeVVVUkpqbgYGOL6X1GuveyhTRcMyNw8i2l/8lkupXF0q4iEYDnhz2Nm2N9Eeennw4zZoyQ1z9kSFcGDO7Fy5Pn68b3GtaKO9fv4efnRpeBQYikYJSbw73vt7MxQUaJWMEzz/Rg27ajAJhRxkCDZDAyY1uBAxotOiEMwMhIwflDy3h5wETOFwmhj9Mn9WPSM13Ik1vw0+UENtk3RSSTsaSlLR671rDtvfexlZvz4Vc/ktTekxVfb8TB2gBJXDKd+nSn/8RR8OVxWBtGrqiCT+wSKSkr4dn3XqdNn1BhRX67CadiYGRraOWOqrycL16cTur167TuE4p3uza0e2Y4IpGI2IhbfPHWYm4nZGHm5cvij16iSZsWDfZjVlYejo4D0Gg0uLs7kpj46OkNj8LjMAPX0zhP+v87I/4KUWe31os0MzS2IqDTaBy89BVU9ejR8+eIuLWbnftn1CsAYGHuyoiBK2kR1PgNph49eh4Pu+9cZ8bhPfUKALiaWbCy91M8HdD8wRM+RkpKSnB2dmbFihU6L0k9eh4FfYSZHj33EwrsBIqAwQ9vCsAz1Fa5HCa8lauEKLJyFfRtBVa/AJWAITRJE0QrEwV4O0IzTyDcneyFED0WqmRq+oT/hqTHWwBciBZEtTHd4EYiXIwGc2PBh6xGLANIzYF+/mD7BVilAh8L4tVooRgip28J6Zf3Y2YkeJKZGQlRW4evCfMNcodW3kLk2oO4kwxHrwuVPAF6NheEMhszIVrrWARkFrSlXSt7zBVaItOFaDWNRhDkBrR+8LzvJyUjgy2/7gPA0c0BZamakvxjXMwHd0dnbG0tyM4uoE/3pkzuKwh/CZmCIGhnATGJCSSkpmJhZtZAMHOzhSlCIU/2pwgrc0rhS7lIQrfyu9Q+B6ulV6+2BAV5k5iYjl/7oZRYdWT0pHsUZ0ZRUlLOoO7d+Gl9P9JTcjl6PBxHg0r2LXwHbWUVLTHjtMaDtm0DSSyp4uL+k5TITDGf9TpNm3qy/bnVoNbU844rLS1j2YwFOBcl4YYLdi6OFG1bzdJ1y+jx0ou0eONDfrgi+IUVqjRc2fEzANmqQu5tPIBJ/1l4BNmhVavRRBeSeu4UyoE9UExsz8Hzv5BeUoAyS4lIJCLi1Plawax/sPCqZsvHX5CQkI6qEn799HMAcpLuMejNN/BtEcSWK1nk5Skh7gqr1jUeTaNQGGBubkJ+vhIHhz+Xfvkw9GLZPxcHrxDsPVoKVTNLCzEwMsfK0e+JRJbp0aPnv0OLoKdp1nQocYlhKIvSMTN1xMejy/8sskyPnv8yTwc0Z6hfMGHJd0kvVuJoYkYXV+8nEllWw7Vr17hz5w5t27alsLCQhQsXAjB06NAntkw9/070gpkePffjCOz6A+0lwH0PJ6NTIana6/zqXejVorod4OsEngMFwUh3X38XbDNhymdwrY2Eq61H4JwZSaq94MhfXC7ML6o6tbOwoR8rWiAyH55+QBXfq3cbDpOKIb06kONybP1khVtJEJsGL/YBWSNnCq0WjkTUinZGBsK6Gcrh1E0Iv52IzNADEFFQ4YGxSW0FzphUaP8H7aVUVbVlPa3lV+jfOoT1e4QILKlWw3DrDMzbOGEvSkCtVnMpTsKFO8I27tdCyc4jhwBIzcrkpWdGUaWGrEJB3JPXWb+BziZ80NyGuPwSOpQa4GLcmt3bThIU5E2vXrXlqW1sLLh5cytlFfDtQWFY52FTeG1Q7byKi0vp3HkyhYXFNPFzpVW1wX8RcoKDvXn22YE8+9ooen9/lo45F7CzMSZPqWTpsqm8/daXqOsqosAvV1PphZguskyee/cNNrw2E4CfN+zk0v5Enlv3CddvJ/Lx1GlMbBuAeXQcHjJbfMcOolBhhFgspuDCZTK27+EuIJZIsHRyZOcW4Ufj3LEbYks7+vmEwFfHYURrsK8fRVRTBVRbWZt+WphZa+w/efIwli7dxMCBnXByatzvwNTUmAsX1hEWFsHQod0etMvrcfnIKZR5BXQZ1h+Zgfz3J9Dzj0UkFmPtrPef06NHz+NFLJbg5xX6d3dDj57/JBKxmFB33//pMpcvX050dDRyuZyQkBDCwsKwqS4apkfPo6IXzPToeQLYWwiCWI1B//1I73+gORiqrkPKPbjaAcqNXQgxScfPB87cBksTCI8RTP5BiOJKz2s4X6+H2OOIRUKqZQ2ulpB8n7/2/fnZlVVwJ0Xog4MlDG5b23eRSIg+yy4EE0PoFiSkehrKISoFygpOILEZgVhqiquNGg97CdcThH542NdZplbwXjM3bmS71F03F1cGdOlGbmEBnVuGYGJkxLiBg8nKy6UqKpYbztZIZVJyszPJTEqkoNhbN/9SlQSpREKVWo2hXBBbdp8TUkhtzWFst1rxUiQSMbupNWANuDFmzHv89NNhxGIxERGbCQ72qdcvhQGE+AgiYKtqz9KS0lIM5HJUqko0JUX0IAF54j3kAyZweN8JUjHjy5eexsbGAoBrr3Sjz5BtaJs5cuf6PVZ9/A6mJsZ88slmDAxkREbGY2Ago6gC9tCED+ZOodcrL5J7L4UTu/ZzMK6KvNQsJPv3c/6rnWi1WlYfLKCsJBlDjQhMDLAFJj01nEsyBds3/QSAhaNDvcidAS+MJrTvMBi6CtRaCk5F8v0gE5r7B9CzXQcAEqJuc827OXaIGDYgFK1Gw7D33tHN44P3X8StKpf8zGySomLxDLyvUEA1fn7upFy9xk+LP6P3uKfxD3lwSP7Ns+GsX7AcgILsXJ6e+sKDfyh69OjRo0ePHj16/tO0bNmSK1eu/N3d0PMvQC+Y6dHzBHCwhIm9BMHpYSmNOkygaiGcOQvFSgA5F8vcedUNmnsJTT6vY/PUPgBOXBeqbIIgQg1q83DBrGNTOFMnJdNYDEbFUGoCIZfhyn3pkQYy6N1CEOoqKoUIt8wC6hUfGNFJEJ3upsOBy4LoJBYJJv1iqRlF2T9ia+VIh4AhnLkNtmbQIUDYPiAIir9eFqa3NhXSTh8mmrUJCq733dvVDW9XN8q9fTn+w0YqAQsbW2ycnengAJVqMDWEZl7G2Jk+TXJGOsF+/mi1kFEtFmYXCimljUXRARQVCRtZo9FQWiqEyEUWVJBeVkVPByNEIhFdAqGLEAzIxRvXOXg2DHMTU4xVZvT1MUJ+pxhUkKhV03viWExNjZk0aUi95fi7e/Lloh34+7tjZWXOlClP0aSJB6dOXWPevG+oqKiJsBMx7KlQRCIRoz/+iKZjn2N7t5dRVKh4+unuZGTksnPncYYM6UpxaTk7fjtH164tcXd3xMnOnqEvPI+3mxtFObm0GfE0mqoq5AoFcoWCrs8/B2m1JsOFRUqKSkScuXqFriFtkEml/Nh+JJlOPkgqyvgwREFwcH1B7ObZcCLPCyW6j2zeyZQldUwAr92DWdvBypjcBX3YtWqdsA+S0/hgx5oH7vdKVW10YVVl5QPb6dGjR48ePXr06NGjR8/jQi+Y6dHzhDC9ryqxqgqOXxfEpx7NG45PzIQcZe13B0uQ1RGP7C0E836RCCyM4KmOsP6IMM7c+OFiGUBrH0Gw2ncREEFQAPRIgPLjoB0AV8rrtzczAh8nyCsWUhctjYX0xboYyMDTHi7cEb5rtaDWQq4SXhs5BGVRNg42NmQUiHQpoWejwM1OEMu2h9UWH8gtEnzPzIwevh6NYWhiwvsHDlBcUEB2mSnbz0lwsBRExJrIMWd7e5ztq0PbzobR/Xo8NwL606SlLTKp0CgrN5fNB34BYNzAwdhb2/DNN+/wySebCQzyJVEVxKUDWn4oyeGWupi5QdbMCa4N7c5NTyci8iYAhcVFfPXlHorvZBEqEiFCRFpAaw4tncLZK5f4/udddGjegpZNmgKwePGr3LgRR3h4JM7OAxk+vDs7dx5v4Mdlb2+Fq2ttiJ6fnxv9+rUnOTkLOztLtm9fQk5OAYaGcgICniEtLQeFwoC8vKNUSWSsvJOHjVsrfMqv08S9P3nlWo4c+ZJWrapT4Fws4YuxEHGPq5b5UJiOh5MzMqnwd2Hq4UmmCpAbYOPtzb0bN7l24DfaDn8KRz9f3Px9MDQ2orykFL/7o8Z2XREqb+aVYBqRiYmFOcUFhdi5OT90/7YM7cgzr79EUV4BvcbpzZn16NGjR48ePXr06NHz5NELZnr0/I+IuiekNwJcihFEs7o4WgvVL8tUQhRWiE8djzMEgexOMthaCAIZCCmSqbnVhQMegfgMweAfhAgryUAI9xWixlqUw61EsLcUvge6C+3a+gkFAAxkD66c6e9cK3yB4IW2+5yMIA8nzM2FKK8asgqF4gPBHrXTiETQ3PPPiWUAVWo1+YWFWFtYcD5CTI5SEB+bujWeEsumDfilp1ORdhZ775cAofrerbhYikpKdJ/trW1wcbHn889nkZABey8Ka9dWYk5+RQrKa9fYlu5KflUnTFTxxP44C42FJdJWIZQbWpCUVkwlpuT2eQHb58awvEtzVBXlnLocDsChc2d0gtm2bUc4ffoaAFLUXDp5AUBn/G9oKGf8+P688cZYLC3NSEhIJSoqkfXr97Fz53EA2rZ9HpWqkq5dWxIfn0pGWhYgprysnIunwjlg689X0fk43ouhzy9r6ONhyLHYQnbuPE6rZn6CqR1AJx/o5MNQjYZuRUosTGuV0m29vFn7y216XE/E1qaKV0f3oSQ/n2PfrOGLpFhSYuNp378nrXp2xrtZ0/rbvUcAHLwFpobIu/jzTu/PuBdzt9FKmnURiUSEjhj00DZ69OjRo0ePHj169OjR8zjRC2Z69PyPsDKrNdW/P1ILwNwIXugtpBEaGTQcbyCrTc+swdtReN1PXpEwD8P7vNE97QUzf4lYqAx5JEJISUzIhPHdITS44byg8f7UpZkn3MsWxDBThSCEFZXD+TtCsYGxdXzdtVq4EicULmjiIiy7nT+09H74Mh6EVqtl497dpGRm4uvujpPrYLIKhT5bGD9gombN2WvvQJSjI5JLF3nNxwdLM3P8PDy4ePM6AP4e9VVIU1EBSZ9NpawoHZtnejHKygqpupI7d3OosHLFLDUJdWUlZGdx63Y6v3bsRf81gXRNimTKlGGYmgqdOX/+BlGXk8nKysPF2QHN80Kq5969pxGJRBhoVfQnDkVOJc29WhEZn0UeCvLLYe3avVy+HMXGje/Ttu3zVFSo6vWxJmX0+HEhJTKQbJQY4IqSyqRY5PZCFJllbjqiasc6TxNDpp3IgfaLYOEwGFD7IxCLxViZW9RbRkBZOctXCFF42uvxVFVUAFBZVk5yTDzr5i0FICctnVc+eV83XXlxMYfD92P7igcdxo8BAymWgKV944UB9OjRo0ePHj169OjRo+fvRC+Y6fnPEpUsiEdNXWujqZ4krjYwNlTwNXOybryNTNrQS+tWkiCAhfiAsWHj0wGk5QqRWsk5cC5KiFYbG1o/9dPDHia3AVEMGMgFQSm7UKgSqZCDRgO3k8FQJhQaKCgRRLbfq/oslcAwwROeXCVsCxNSUEFIQUUkFAW4GAPl1RpPXDrMGCIIaDGpQqSc8wO2y8NQVVaSkpkJQHxyMmP6C0KcmbGwTo3y6jRKt22B/HzUGg0VKqFTLvYOvDlxkrBO0vo74vyGtWSd2imMs5JhMHw4ZkC5SMpJjYrJTTvhyVWSMzK54N0HAH9PR2aNaKGbR3x8KqGhr6DSeXJdp3OrVhSVFnPw0Hm0Wi0+1gYocoXxllmxtKOIKkTsx59S5CQlZXDz5t0GYtn06SP54ovt9YaVy4zpXJWIzNSUFJWcOYGW2BtKcHLqjiQ2gW13rmNaaIijmRbQwt6IeoJZo5gbgaM5pBciCnBk1ru72LN0JR7tO6DRaBCJhMqlYkl9M7qtb8/l6OpvATBytqd5vz4PX44ePXr06NGjR48ePXr0/I3oBTM9/0m0WjhyTagamZYH/i4PN5t/XNia/7H2qblwNEL4rCyFQW0bbxeVDIeuCp+tq4sMlKkgp/A+r7RyMJwEZAEh0PcrIZ3SxlwQ485HCaIW1FbVbO4J3ZsJy7h2F/ycofVDqkJbm8GkPkLfI++Bu52gsbT0Fua157wg6gW6CQJfWCQ6f7NRXYQKoA+jqEzYdxIx9GkJCgM5XUJaczMmmrbBzRCJhLTShyISMbjfAM5eu4azvT0ONrasjMpjya0c+jqZsKFjw7A91+AgnRhk4OyIk5Mrm5TmZIqMmOBrxnOt5Ej6zQLAL7mIdXEFrI4pIKGkkm1dnBGLRBQWFtcRywQyijPRKqp4ec4gvvv4ALdzVfRq0Zqi5CRUhiYcLLZHi4gmnVvhLqmkxXNjWa7wxLtPV/KvRJCXKxjftW7dlK++epNp05ajqS6HerfShMFT5/PFlzs5Nu1Djs96FUdPL15zGoc4z5DmZm0YJ46hxN4E49xSGPLgSpU6FDLYMgViM6GFK5l7DpBerCH96FnsfH14edk8UmLj6Ty0X73JtBpNo58b49i3a8hNTmHg7NcxtrD4/T7p0aNHjx49evTo0aNHz2NGL5jp+X9FdqFgBu/we4LHX0QkEoSd7Goz+wd5c/2vycnOpTCnEO8mQu5lXRGvpgBAuQrkMsjIE9I0rc2ECLQaHC0FocvaFFzvz3YrQRDLABKE+fs41Y5Oya39XK25kF8svJ+4IUSNZRUKnmb3p3vWxUAGXg7Cqy5iMQzvJOzjmm1eUqfYQGnFg+dZQ0S8kP4JcDNJ8Fjr0bY9Pdq217UpKikmp6AAd0cnxA8Ij7O2sGRI9x6671/cyaO4Ssuue0V80NwGT5PaFVy2bBNnzlznpU0/EuDnilvLFshkMgYpK0gsrqS3ozHiOn5zQ1xNmXYpEy3wa2oJKaVVuBnLaNnSn6+/fpsPPlhLRoawsRUWMkorqrCxN8fC2oT87GLOG/hyMVeFiRSqNz921w5hWJLLxVvnuOk3EJGtDVNeG8Pqhd8il8sICvKmZUt/rl+L5ru1QspkQIA7d5Oy0SDGm3zUKhW5sQmIFKUAeCqMOXdxq7CAKk2th9nvYWkEbT2JPnOW49+uQUg2BplcTlDHNgR1bNNgktFLF2HuYI+1qwstBvRrML6Gq/t/5fuXpwFQlJ3DpG+/erQ+6dGj53+Ch4cHM2fOZObMmX93V/To+c8QGhpKixYtWLly5d/dFT169Oj5T/H/RCbQoweSsmDLSfjpNNy+9+SXN6ITDG0PI7vUN9f/u0i5l8qO4XvweNad/AEFUCJUxhzWHroGClFeF6Lhm99g3SHYfgY2nxQi5Fp5C5FfAS7QJQie6wktvGBfOFyOFeZfWQV5ctC+CbQB5tYuOzMfNh0TosJqaO0jpEjmKOGH47WRa1YmQgrnX6GuQNklUDDnbx/QUGBrDHsL4V1U53NdSkpL+Xr7T2z65Wf2nTrxyH0a7iYYy7WzMcTFSKYbfv16DG+//SX79oXx/sqf8W7bBplMGO9vZkBfJxPEjfyAJngJ4YQ9HYxwVtRusHbtgtBqtZiaGjF//iT6dOpEWYmKG5fiyU4voLKyiosXIwEorgKxVIpILMaiRNg5sbla1OcvUPXLfnwdrTh/fh2RkT8RE3OPYL9h7F27VbesO3eS2L//DC+8MJguE8aSKzEjytyduMkh0KsJLBle2+FHFcvqsOG1mSScOEppXCR9xz1Ft+ED641PTs5kyZINXLhwEyMzM4a//x6hL0x86Dyl8tptLzX4HfM8PXoeExkZGUybNg0vLy8MDAxwdXVl8ODBHDt2TNfGw8MDkUiESCRCoVDg4eHByJEjOX78eIP5Xbp0iZ49e2JhYYGlpSV9+vQhIiLisfR1wYIFun486JWYmPhYltUYly5dYsqUKU9s/nr0/FuYOHEiIpGIjz/+uN7wn3/+uUEF7N9j9+7dfPjhh4+ze43yOM+F169fZ8yYMbi6uqJQKGjSpAmff/55g2XevHmTbt26oVAocHZ2ZuHChbqCR4+DkydP1js/KhQKAgMD+e677x5puoKCAt0wrVbLmjVr6NChA2ZmZpiYmBAYGMiMGTOIi4vTtVuwYAEtWrSoN7+wsDAsLCyYNm2abv127dpFaGgo5ubmmJiY0KxZMxYuXEheXt5jW389jRMaGqr7TRgYGODs7MzgwYPZvXt3o+1PnDjBgAEDsLa2xsjIiKZNmzJr1ixSU1P/xz3X879GL5jp+X9DrhJq/h6zC5/88gxkgj/XwyKlHgW1Rqg4WePZ9WdJiEuie3lXJEiwzLaA25CcDaduCaKYWAwx1VU2S6ojsbRaCI8W1mFAa+gXIqwXwLHrggh55rawPbecgk3H4agvsBroWrvsK3chr5h6dGoqeJmVVkBuETjbCCLjqK6Ne5oVlsLmE8Iy6ka8geCNdikWLkZDlbr+OBOFkFrZ3EPwNbs/yqxKrWbz/r0s/X4NN2Oi8XMWChRM6CGkezboR3ERZeVC2FpGTs4DtnZDPgmxI+lpb470dENWJ1zMzs5KZ9jv7e3yyPP7qIUtuSN9+aW7K5+v3IJc3pGBA19nw4Z9ZGbmUVRUioGBnOb+AVw7G0dRQSn3Xx9aWZmRmvwLr70xjrLqgGADalM6VUolERExvPrqMkaPnsut2DQyqV/pQKvVMm3aKF5Y8CYnxD6cyzdkyu59HH7amdt2f+2C1DHAHwBZZRmhzwxu4Fs2bNibzJmzmh49XiU3t+CR5tmsT2+m/vQDYz9ZwuiPP/pL/dPzz0StVnPyZgRbTx3n5M0I1Gr170/0F0hMTCQkJITjx4+zbNkybt68ycGDB+nevTuvvfZavbYLFy4kPT2d6OhoNm3ahIWFBb169WLRokW6NkVFRfTt2xc3NzcuXrzImTNnMDMzo2/fvlRWVt6/eAA2bNhAaGjoI/V39uzZpKen614uLi66ftW8XF1d//T2+D1sbW0xMvqTJY316PkbUWs1nCzIYGtWPCcLMlBrH24P8DgwNDRk6dKl5Ofn/6X5WFlZYWpq+ph61TiP+1x45coVbG1t2bx5M5GRkcydO5d3332XL7/8UtdGqVTSu3dvnJycuHTpEqtWrWL58uV8+umnD+znggULmDhx4h9ev+joaNLT07l9+zYvvfQSr7zySj0h8PfQarWMHTuW6dOnM2DAAA4fPsyNGzf44osvUCgUfPTRg69ZDhw4QN++fZkxYwarVq1CJBIxd+5cRo0aRZs2bfjtt9+4desWK1as4Pr16/zwww9/eP3+v6NWq7ly4SSHf9nKlQsnn/h/+6MwefJk0tPTiYuLY9euXf/X3n3H13T/cRx/3dwMkR0REStWEHvvVVS11CiltKWq7a9U6R5KlaK0iqrRUqotilqttqjVpnZttWITQowkElmS8/vj1E0iCUEixvv5eNxHbs75nu/5nkvu+NzP9/MlKCiILl26pPtS6KuvvqJ58+b4+fkxf/589uzZw+TJk4mMjGT06NG5NHq5Y4xcEBkZaQBGZGRkbpxe7lJxCYaxZJNhLFpvGJcu5/Zosm7BOsMYs8gwvltpGElJt95PfFy88XuP5caVGleMuCfiDCPaMOb9bfY9ZpFhHA4zjJ1HDOPLXwxjTrBhTP4tZd/RM+n7+3mDuW/Sb4Zx+kJK26nL0rfdecTc98XPhjFztWEcOGkYe0+kHDP2v5/z/jaMI2GGEXo+5diLlwzjj22GsXhDSvu/dqftf9uhlH0b92V8/d+uMPdP/8MwkpNTth8NDTUGTxxvDJ443pg898csPZbL1601vlnwk3Hk5Ikstb+RAweOGT/9tNKIjY27peMDAh43oKYBNY3p038xnJ0bGB4eTY0tW/YaSUlJxuhvphtP9HzdKFziUVs7qGkMGDDRWLBgldGu3ZuGC5WN8hQ18lHeKFWqg/Hll3MMi6VWmvZXb5X96hh1KGCUp6jROaixYRiGUblyV9v+6vW7GoO+HGcMnjjeOHv81C0/LglxccaWX341zh49muH+oKAnDahpODjUNcLCzt3yeeTukdOv3/PX/mUU7tHZoE0z261wj87G/LV/5cj5DMMwWrVqZRQqVMiIjo5Ot+/ixYu2+8WKFTPGjBmTrs2gQYMMOzs7Y98+88lt8+bNBmAcP37c1mbnzp0GYBw8eDDDMUyfPt1o3LjxLY0/s3Fda/Xq1QZgrFixwqhevbrh7Oxs1K1b1zZuwzCMgwcPGo8//rjh6+truLi4GDVq1DD++OOPTM/XpUsXo3Pnzmn2JyQkGPny5TOmTZtmGIZhJCcnGyNHjjSKFy9u5MmTx6hUqZIxb968W7pWkVs1P/yoUXjDXIO/vrXdCm+Ya8wPz/j1Kzt0797daN26tVG2bFnjrbfesm1fuHChkfoj2Llz54wuXboYhQoVMpydnY0KFSoYs2bNStNX48aNjX79+hmGYRjvvvuuUbt27XTnq1ixojFo0CDb79OmTTPKli1rODk5GWXKlDEmTJhw3fFm93NhRnr37m00bdrU9vvEiRMNDw8PIy4u5f3ViBEjDH9/fyM59ZvBVD788EOje/fu172W1K4+96W+BsMwjBIlShijRo3K8nGzZ882AGPx4sUZtk893g8//NCoXLmyYRiGMXPmTMPR0dEYN26cbf/GjRsNwBg7dmyGfV071nvdqt/nG23qFjFqF7fYbm3qFjFW/T4/x87ZuHFjo0+fPkafPn0MDw8Pw9vb2xgwYIDt3yn131Rq06ZNMwDba9+JEycMR0dHo3///hme5377t5L0lGEmdw0nB3ispjlN0tX5xu3vFqf/y5o+fwnibyPLzNHJkcqjW7BhupVL05zABYr6mPucHSG/O1QMgD6t4ckGZrF+MIvzu+YxM9xCz8O8v+Gr380i/gG+8Hgtc+pixQBwzwt1y6Y/d8UAeK459HrYXFmzdKH0WWIAJ8/Bog0wN9isJbblICzdaq7keTjMnGpptYOi19ROu1qLzdFIoNzh+bBkGpw5YdufbJiLGoD5MzlV4pNhlw87q6fZT55SnDl/jotR109BbFG3Hj3bP0FAoaxnhF1P6dJFeeKJhzgUeoIx33/LT38sIzk5maSkJGbPXkZw8LZMjx069BsiIswHs06dCjz11MOcPbuMQ4cXEGPEUKfuc4we8iMLvv2bk4fDsWBQgGiauEcSfz6cDh3e4eef/yLRMS//UoDz5CUs7DzJydhS+p2cHNKcs0b7ptQs4kplztC9VwcSE6+wa9ch2/4ta0PY/c9RLMkG1ldnQ2TsLT0uDk5OVGv9KPmLZbzM7E8/fcJrrz3F4sWfUaDALSyBKg+UBeuC6fjJR5w8nzYzNPT8OTp+8hEL1gVn+zkvXLjA0qVL6dOnDy4uLun2e2Zh0Yl+/fphGAaLFy8GoEyZMvj4+PDNN9+QkJBAbGws33zzDeXLl6dYJn8rd9KAAQMYPXo0//zzD/b29vTs2dO2Lzo6mkcffZQVK1awbds2WrZsSZs2bTh+POM6Cd26dePnn38mOjolRXnZsmXExMTwxBPmlO8PPviA6dOnM2nSJP79919ee+01nn76af7888+cvVCR/yw4d4yOe9dwMuFymu2hCZfpuHcNC84dy7FzW61Whg8fzvjx4zl58mSGbeLi4qhevTpLlixh9+7dvPjiizzzzDNs3Lgxw/bdunVj48aNHDqU8rr+77//smvXLrp16wbAlClTGDBgAMOGDWPv3r0MHz6cgQMHMmPGjAz7zInnwoxERkbi7Z2yutP69etp3LgxTqlKMLRs2ZJTp07l2NRywzBYunQpJ06coHbt2lk+bvbs2ZQpU4bHH388w/0ZTbOdMGECzz33HN988w2vvvqqbfvMmTNxdXWld+/eGfaVlcf7XrF66QLe69OJs2Fp//+fPRPKe306sXppxlMgs8OMGTOwt7dn48aNfPHFF4wZM4apU6de95ju3bvj5eVlm5o5b948EhISePvttzNsfz/9W0nGVPRf5DY1rgDbDkNpfzOwlVWh580gU7ki4ONuTlVcuN4MfO0JNeuQ1SpjFuXP65R+6mijClDYBzxczNusP9MGuXYeNX+evmhOYWx2gwUQPa55f1S5BJw6bwYyvd3MAvtueSDcXJSR4H/N6ahX65nZWaBTA3NxgogYiE9MmR5avqhZc8z13DHcDp8yN4ZshwJFbMe2rAZ7ToC7M3yz3Kyf1qoGODo64er7FEZyAvb2R5g890fs7Ox4rm0HCvtloehZNgrespmo6Gj+PRhC3UpV+HLsT3zyyQwsFgvBwV9Tv37aBzkuLp5Bg74CzDdSf/89BavVipOTI/PnLGbDT7+wZ9MeYnC0vdEq6OFEk8hdEAUnt/wDQHKyQa9e7Zg48ScAypULIH9+LywWc1ruo4/WZ/JX7/D8K0Ow2Bv0fLETNUYPJCYiAq+C5oqfY1/vwbCxP3DmSgIADS+78Phvl/AOTYTjF6BioZt6LJKTkrDY2V23Dku5csX5/PPXbqpfeTAlJSXRb8oEjAz2GZjPH/2nTqRt7XpYr5n6ezsOHjyIYRiULZvBNwlZ5O3tja+vr+3DnZubG2vWrKFt27a2mkOBgYEsW7YMe/vcf9s1bNgwGjduDMC7777LY489RlxcHHny5KFy5cpUrpzyPPbxxx+zcOFCfv75Z1555ZV0fbVs2RIXFxcWLlzIM888A8CsWbNo06YN7u7uxMTE8Pnnn7Nq1Srq1q0LQIkSJfj777/56quvbOMQySlJRjL9Dm26/nPL4U20zVcEqyVn8gjat29PlSpV+PDDD/nmm2/S7S9UqBBvvvmm7fe+ffuydOlS5s2bl2FAp0KFClSqVIlZs2YxcOBAwAzA1KxZk8DAQACGDh3K6NGj6dChAwDFixdnz549fPXVV3Tv3j1dnznxXHit9evXM3fuXH799VfbtrCwMAICAtK0K1CggG1f8eLFb3k81ypc2PwSNT4+nuTkZIYMGUKjRo1ucFSKAwcOUKZMmTTb+vfvbwvAeHp6pgmK7t27l1deeYVvvvmGp59+Os1xISEhlChRwlYT936VlJTEmCH9SVdzBMxtFgtjh75GoxZts/W1/aoiRYowZswYLBYLZcqUYdeuXYwZM4YXXngh02Ps7OwIDAy0/T8OCQnB3d2dgv+9n5YHjzLMRG5T+WJmQKp2mRu3vSoh0QyObTkIizek3385Dib9BvtOmsGqjOqs2dmZwbT8HubKmVeDZdeGL+ITYdfRrI/tqvV7zVUzj4ebwcD/tYL29czMtrKFU177nBzMBQk6NjDHsnijudjAwvUpfVks5uNUrJwfOP1X+8Y/7ZugwELmAgcnzpl1zEJOwclwWLsH3PNaqVLSGXfHMACSk5M5fS785i/qNpUqamaHeLq5k8/Tk1OnzDEYhsHp02mzYqKiozkedsoWRHvooRpp3gxsGPgxUT8t4GEOYiWZl15qzw8/DGHO9HfJ6+lJwcDSNO/RFavVDicnB3r2bMOvv47hjTe6snnzHp56agDNmtVi3Lg3mDHjQ3zz52Px7DHMnPwx6wd9zGsBZTg49keiwy7SsmVfxsxYzKyiVfmxaFVW9+pO/z7PUMLJA9pVgfL+pDPkF6gxFD5dmm7XgS07ebPlU3zQ/jnOhYZl06MrD7LgPbvSZZalZgAnzoUTvGdXtp73apbmzRbgzqifq33ExsbSs2dP6tevz4YNG1i7di3ly5fn0UcfJTbWzOY8fvw4rq6uttv//vc/goOD023LCZUqVbLdv/oB4OxZc/nkmJgY3n77bYKCgvD09MTV1ZV9+/ZlmmHm4OBAp06dmDlzpu34xYsX27Jc9uzZQ1xcHC1atEhzbd99912a7BiRnBIceTZdZllqBnAi/jLBkWczbZMdRo4cyYwZM9izZ0+6fUlJSQwbNoxKlSqRL18+XF1dWb58eaZ/d2BmmV39uzMMg9mzZ9v+7sLDwzlx4gTPP/98mr+7jz/+ONO/u5x4Lkzt33//pW3btgwaNIgWLVqk2Xdt+2vHcu1z4/Dhw20ZWqm33UhwcDDbt29n+/btTJ06leHDhzNp0qSbur5rxzpgwAC2b9/OoEGD0mTaghmgq1atGqNGjeL06dPprvFGj/W1rxNZuca7zfbNwekyy9IwDM6cPsH2zdmfQQ5Qp06dNI9z3bp1CQkJuWH9tNT/Pln5t5L7W+5/1SnyILKkBLauFtC3t0L7uuaqlofCAAMOhJrBqRtxdYYapeHwaXN65a4j5iy7pGTzPP63MBvu5H+fXROTYE6wOQ20gJeZ9QVm4OzIGahQDHw9zW3xiSlTK8MumqtvFvBK1WleN3j0WbiSgOHkki64B+ZKmVsOgperefzVlTsNwNe3GvnPRZDPIw+VAlMilIZhriAaGQN1y4FHBvWoT4aFsXRtMOciLlKsoD9Ptmx1099mNa9Tj2rlyuOWNy8ODg6MGNEHq9VK4cK+dOjQ1NYuPiGBr3+aQ0xsLC++9RhfffUugYFpp2IZkWaqXr7KZWhUsCKlSheiW7dHAGjQPozt2w/QuPFLJCUlk5SUzLJlG3j//edYsCBl5c89O/bSvkA0qy8f5/F338IuOIQTc5aw9Rfz29tfvhzPsR1RLF9uTuv43NWDJS0fhQ8fh0Ke0CgQwzDYuHE3xYv7p0ybjE2EBVsBSJq1gXW+5zh59CSRl6/QvGt7Ni9fQ3xsLPGxsexet5kmndrc1OMocq3TWVwRLKvtsqp06dJYLBb27t1Lu3btbqmP8+fPEx4ebsuEmDVrFkePHmX9+vXY/fcEP2vWLLy8vFi8eDFdunTB398/zaqZCxYsYP78+bYPwADu7u63fF3Xkzqj4eqHgORks/j5W2+9xbJly/jss88oVaoUzs7OdOzYkYSEhEz769atG40bN+bs2bP88ccf5MmTh1atWqXp99dff6VQobRZrE5aBVfugNPXCZbdSrtb1ahRI1q2bMn777+frmD96NGjGTNmDGPHjqVixYq4uLjQv3//6/7dde3alXfffZetW7cSGxvLiRMn6NKlC5DydzdlypR0GWqZve/JiefCq/bs2cNDDz3ECy+8wAcffJBmn5+fH2Fhab94uxrAv5ppVqNGjTTPl1988QWhoaGMHDnSti31NM/MFC9e3DZ9rnz58mzcuJFhw4bx8ssvZ+n6Spcuzb59+9Jsy58/P/nz58fXN/0qVG5ubqxYsYKHH36YJk2asHr1avz9zS8oAwMD+fvvv0lMTMw0y+za14msXOPd5vzZ0zdudBPt7oSkpCRCQkKoWbMmYP5bRUZGcvr0aWWZPaCUYSaSCxztoUM9Myutbar3MgW9oXlVc4qmvZ0Z+Ll2VcnMNAiCZ5vBnuNwIcYMlrnnhR4tzFpmNyM5OSXwBWZfp69Z4Km4HzxUOSVYBma2WeoA3/Yj6fu+GOfA1D9d+GqpGVS7VsPy0LMFdGsCRXzNQKIFiI2HzYc9ScjTgeqVHsXJMSXt7ugZcwXOfScheHfG17Ro9QpCz54hPiGBA8eOcvLMmRs9DBny9vCwvbnx98/PyJGvEBZ2ng8+mMyVK2YRu8txccT8l0ly8VIU5cuXxMEh7fcTfWd/h0O1OhR+6TkaP16dGKv5zeSZ8+eYu+x3fliwhKioGPOc3u506tQMgHfeeRZ3dxesVistfOJYO/NH5rw3kK/7D8N4fQ5F/jpL/rzmm6qq7qWoae+Cj48nABU7NyR23JNmsOw/b7wxlrp1nycoqDNHD51gy89LOH/+DDQ1p2V8Z7eVyT16sWTwYHwWbadYj3k8Ep0fR+c8ePh4U75ujVt6HEVSK5jFDwJZbZdV3t7etGzZkgkTJhATE5Nuf0RExA37GDduHHZ2drYPmZcvX8bumunKV3+/+kHW3t6eUqVK2W6+vr44Ozun23anBQcH06NHD9q3b0/FihXx8/O7YR2hevXqUaRIEebMmcPMmTPp1KkTjv89PwcFBeHk5MTx48fTXFupUqVydCVPkasKOmZtRdestrsdn3zyCb/88gvr1q1Lsz04OJi2bdvy9NNPU7lyZUqUKEFISMh1+ypcuDCNGjVi5syZzJw5k+bNm9sCTAUKFKBQoUIcPnw43d9dZlMcc+K5EMzMsqZNm9K9e/c0K2heVbduXf766680wcHly5fj7+9vm6p57XPj1RVDr912s6xWqy3rNyueeuop9u/ff90abdfy8vJixYoVeHl50aRJE0JDQwEz4BkdHc3EiRMzPC4iIiLd68S9GDDL55u1AFNW292sDRs2pPu9dOnS1/3CfMaMGVy8eNFWh7Njx444OjoyatSoDNtn5W9D7m3KMBPJJQW9zdu1nB2hdS34fpVZGy02AR6pfuP+ImPg4Gk4F5Wyzd0542yrG7GzM7PWoi6b9cUK+0CZLNbPr1narM2WeAWKZfB57+ApiI4z7+87CX5e6du4/zdmPy9oXwfOREBkqgBe4jVBRJc8ZlDNANwyWTDCw9WN8/+9qLm7uuGbL3veeHz44ddMmbIIgDJlitK9e2u83N1pUbc+h04cp37VahkeV/6hpnQcbmXL4Z0AFC1ivtH97a8/ObJhPXljYwkM9OX06RhWrpxI6dJFAXMBgshIM8tsygsvs2bvFpKx8PH4+Yxz8KC5iwsj2w8kpkEx8h2Lg+71OOT/P9q2fZNPPpnBsmUb2Lz5W9ubhQ0bzAjjhQtRfNLtRS5tXI27ry+jQ3azp0tJNvX/wzbmovEOODhbyLfyMJ/9/SN21uvXMBPJqoZBFSmcz4fQ8+cyrDVkAQr75KdhUMVsP/fEiROpV68etWrVYsiQIVSqVIkrV67wxx9/MGnSJPbu3Wtre+nSJcLCwkhMTOTIkSP88MMPTJ06lREjRlCqVCkAWrRowVtvvUWfPn3o27cvycnJfPLJJ9jb29O0adPMhnFXKFWqFAsWLKBNmzZYLBYGDhxoC/JlxmKx0LVrVyZPnsyBAwdYvTolC9bNzY0333yT1157jeTkZBo0aEBUVBTr1q3D1dU1w1pKItmpoYcvhR3zEppwOfPnFqe8NPTI+QB1xYoV6datG+PHj0+zvVSpUsyfP59169bh5eXF559/TlhYGOXKlbtuf926dWPw4MEkJCQwZsyYNPsGDx7Mq6++iru7O61atSI+Pp5//vmHixcv8vrrr2fYX3Y/F14Nlj388MO8/vrrtkwyq9VK/vzm6lBdu3blo48+okePHrz//vuEhIQwfPhwBg0alO3vL86ePUtcXBzx8fFs2rSJ77//no4dO2b5+C5durBgwQK6dOnCe++9R8uWLSlQoADHjh1jzpw5mQZhPDw8WL58OY888ogt06x27dq8/fbbvPHGG4SGhtK+fXv8/f05ePAgkydPpkGDBvTr1y+7Lj3XVKnZEF+/wpw9E5pxHTOLhQJ+halSs2GOnP/EiRO8/vrrvPTSS2zdupXx48czevRo2/7Lly8TFhbGlStXCA0NZcGCBYwZM4aXX37Z9np9tQ7aK6+8QlRUFM8++ywBAQGcPHmS7777DldX1zR9yv1HATORu1BsvJnVBSnBpYho2HsCivqaBfGvNX9d2qwwV2d4rFbK74ZhTpnMqB5aRp5sYNYvK5r/5lYtzeduZohdScr4uOJ+sOUQJCWZtdGuJybOXJUzMcnMkqsVCHkc0k9T9fWEzo3MoFrpTL6kerJlK/YfPYK7qyuFfAvgkE3FtwsW9Mnwfr0qValXpep1j10490827diFr78nb73yX2Dt/DmS95sp/+89W5sOfV/D3d01w+PLPt0Li38J3hkygwvJ9jwUv4tz8dGMPJrAhz8st7VzBzZu/BeAbdv2ExUVg5eXOd1rxIg+vPnmOGrUKIfj0m+5BESdPUvMhQtEGAn4tHsMi709JcuUITCqPBy4CC0rYLXP/uKs8uCyWq2Me6EPHT/5yBb8vurqR6axvXrnSFHg4sWLs3XrVoYNG8Ybb7zB6dOnyZ8/P9WrV09X32bQoEEMGjQIR0dH/Pz8qFOnDitXrkwTCCtbtiy//PILH330EXXr1sXOzo6qVauydOnSu346x5gxY+jZsyf16tXDx8eHd955h6ioqBse161bN4YPH06xYsWoX79+mn1Dhw7F19eXESNGcPjwYTw9PalWrRrvv/9+Tl2GiI3VYse4krXouHdN5s8tJWrlWMH/aw0dOpS5c+em2TZw4ECOHDlCy5YtyZs3Ly+++CLt2rUjMvL6K4J36tSJvn37YrVa002j7NWrF3nz5uXTTz/l7bffxsXFhYoVK9K/f/9M+8vu58J58+YRHh5uy4K7qlixYrbMVQ8PD/744w/69OlDjRo18PLy4vXXX880qHc7rhbst7e3p0iRIrz00ksMHjw4y8dbLBbmzJnDlClTmD59OqNGjSIxMZHChQvTrFkzPv/880yPdXd3Z9myZbRq1coWNBs5ciTVq1dnwoQJTJ48meTkZEqWLEnHjh3vmy8TrFYrrw0ay3t9OmFbqeqq/wKi/QeOyZHXdoBnn32W2NhYatWqhdVqpW/fvrz44ou2/VOmTGHKlCk4OjqSL18+qlevzpw5c2jfvn2afnr37k1gYCCfffYZ7du3JzY2loCAAFq3bp0j/1fl7mIxjIzCvTkrKioKDw8PIiMjc6xGh8i9bstBOBthTtv0djMzzs5fMqco9no4feDrq9/NbLSrnmyQUrssKRnm/W1Ogaxeypz2mJuSk803rdYbvD+9cAm+W2Xez+9hTtO82yQnJzP7x+WEnDxC8TJ+PNaoCT5eGaTN/efw4VBCQo7TvHktXnxxONOm/QLAqlUTadq0Bod27WT6QPODZJ1HW+MZVIdRo76nVq0gPvjgeVs/7703gU8+mYG7uwtvv/0MUyb9RP1Q88Gy2NnxXWK0rX4SwMSJPzFu3I907dqSDz98gaPbtvPtK/3xK1WSXlMmYe/oyO6Vq1gy6nMqP/IwrV57lbj4eFZuXI+9vT3NatXB3mqFqDjwuIkIqtxXcvr1e8G6YPpNmZBmAYAiPvkZ26s3HerlzDfQInL/W3DuGP0ObUqzAEARp7yMLVGLDj7FrnOkiNyu1UsXMGZI/zQLABQoWIT+A8fQ9JEOOXLOJk2aUKVKFcaOHZsj/cuDQwEzkXvEdyvhQrQZZOrV0py6mdrpC7BsK0T8V3qiUQWoFGAG2FIHntyc4fmH0x77T4hZNL94AXi0hu1Ln7vCjiPmAgQ1S6etl3Y32bF/H4tWrQCgYulAOjR/OMN2x46dpkKFp4iOvszLLz/BiBF9GDdxNg7eBgFF/HmiRUscHRzY/89mIsLDqdasOUWLtSUszFz5YODAngwZYq6c17x5H1au3AzA0qXjaN68FuN7vcKuRYvYcdmFi4UrsmbNZIr8N9XzWp+16cC2Jb8B8NrCudRo93i2Pib3g8SERBLj48nrlnGG34PoTrx+JyUlEbxnF6cvXKCgtzcNgyrm2LfPIvLgSDKSCY48y+mEyxR0NKdh3qnMMpEHXVJSEts3B3P+7Gny+RakSs2GOfraroCZZBdNyRS5R7SulTIl89pgGZj10NrWgWVbIDwK/toNp86bx3m6QsmCcOwsVC2Z/tith8wplCGnICr21uqe3Uh0LPy52xx7owpmIC8rKhc3b3czX+98WO3sSEpOxs8nf6btjh07TXS0+e32v/8exsPDlbLVCrP38CEOHDvKviOHqRRYhjI1atqOcXXNC5gBsx07UooAf/zx/4iJiaVChZI0b26mmrcfPIg/I1zYsugvOBzK77+v48UX06aVX1WyVg22LfkNJxcXCgVdv07Kgygi/DyfvvAGkecv8vR7r1Ln0Wa5PaQHhtVqpUnFKrk9DBG5z1gtdjTx9MvtYYg8kKxWK9XrNMntYYjcNAXMRO4R3m5QPwiOhMG6vVAxIH2B+7V7ICwi5ffzl8yfdhZoU4tMBRaC7YfB3xtc82T3yE0bD5gBOTAzxSrcRzMgCubPT+8u3bgcF0vhApm/GW/YsCpvvfU027YdYMSI3gAEFCrE3sOHcHRwwCOvOwkJiTg6piwxvnr1RDp2fI+EhESGDHmJP//cyqFDJ+nW7RHWr5+Wqt0/PPywWWC8Su2SNG1dhWJlMg/etR/4PpVatsCzoB/5bnK1uhkzlvDqq6OpV68SixZ9ipNTFgvj3UMO7dxDRLgZqNy2Zq0CZiIiIiL3iDVr1uT2EOQ+oYCZyD0kIhp+3mjW/zp1ATrWh8vx5lTMK0lp65r5emS9VlmTimattDwOOTcd09Ml5f71MtgMA37fYgYGa5eBGqVzZjzZzdvDA28Pj3Tb4+LiefrpD9m//xiTJ7/LqFGvEh19mf37j3HlyhVqVahEiUJFWL1yC4ElO+Ll5cbatVMpWdJc2aBw4QJs2GAGxjZv3kPTpi9jGAZbtuxjwoS3bedZv34XV66Yy4fmdXPCI58LW0P+pWXjBrY2CQmJTJ68AE9PV8qWDWDHjlCeCrr5gnZjxswmKiqGpUvXs3XrPurWrXTTfdztytWsSrFypTkXGkaj9o/m9nBEREREROQOU8BM5B5hGOZ0yWuLDv573JxqCVCpuBkk83Yz65HdjIymeWan6qXMFTTzOIBf5jXxiboMB0LN+9sO3TsBs8wsXbqe+fPNAnLDhk1n0aJPqV37OfbsOUK7do1ZuPBT/rnsQI/xv5GQkMiZMxdYsWKTLWCW2oULkVwtOxkefjHNvp4927BixSbi4xNo8FAFAPZsP8batTuoU6cCVquVjz+extCh3wBmanxSUhIDBkyifv1KTJ8+CE9PtyxdU6dOzdixI4Ry5YpToUIGc3zvA3ndXXl7auYrXomIiIiIyP1NlS5F7hG/b4EF68xMrVqB8Eg1c7ufpznlEqBwPjMwdbPBsjslwPf6wTIAV2ezHhtA6UI5P6acVqVKoC0Q1bhxVc6fj2TPniMABAdvB2BySARJjRqBqyuFShahdesGGfbVsmVdRo3qywsvtGPMmNfS7PPz82HVqkmsXfsNF45cZtKwn/lhwgoaNHiBWrWeIzY2jvh4cxnV6g1Kk5RkZqOFh19k0aI/+Xrqoixf04ABPQkPX87OnTNxc3O58QEiIiIiIiL3GGWYidwjjp4xf0bEQJUSkNfJ/L1IfujeDBKvmPXLDp6CUv65NszbZrWDJxtAXAI4O+X2aG5fQIA/ISHzOXv2AkFBJQAYMOA5Fi5cw1tvPQNA+yKurAgqR9EfpvDnw8Uo6Jz5U/PVYzKzYcMuAksXxcmaB0dHexISrrB16z6+/XYJgwb1wtnZCYtvInld8xC8dBdgTsP18EkpiHc+4iKLV68kj5MTZQuWpk3rN0hKSmLZsi+oXDkQAB8fz9t5WERERERERO5qFuPq/J476E4sSy9yN/j3GPwTAiX9oUHQ7fW19RBsOQil/c2aY9davw827jfvt6llrop5N4lNMB8Ld2eoXCJ7+z4RDjuPmtdcNv1MxnvChfgkXOwtOFnNxF/DMAg5fgy3vC4UzJ958f7U1q7dQcOGL2IYBoMG9eLYsdPMmPErAO3aNWHhwlEALPlzDT/M+o05X68BoFRQIYL/nIKfjw8Av/y5mq17/gXg+I4LTPtqCQDvvdeD4cN7pz9xXKI511bue3r9FhEREZEHhTLMRHJQ8L9mLOGfEKhaAlxuYwXKaiXNW2YSElPuxydm3i4nHQ4zFyDwcoX2dcEpVQzlr92w94R538MFArJx2ujvW8zFDw6eNqd95rkHF230drKm+X3N5k38tWUzFouF5zt0pJDvjR+w48fDbDXOjh07zdCh/2PFis2cOXOep55qYWvXunETmtasRSHXrzlw4BjDRvS2BcsAihTwY+uef7Ha2dG2dQNmTfuN5CtJBPll8B945O8wexM0KA1fPJUyP1hEREREROQepoCZSA4q7GMGcfK5ZW8QJyYOVu4Aeys0q2wGpuqUBTs7837ZItl3rpux/bAZrAu7CCfOQalUWW721ozvZwfXPGbAzNkxa30nJiZy5vx5Cvj44GB/dz4NXoyKBMxMs4ioKHD15vM9FwjydOL5Up4ZHtOpUzO2bdtPaGg4w4a9zIapX9PJ5TgPjXqJNk+mBMxiYmIZMGAyycnJzJ49DFfXlGVLL12KYc/WYzxWpymlShXh+LqNtE3cAcDRBbPh1Z5pT/rLDt45tZe109cxtHkRmrZrmL0PhIiIiIiISC5Q0X+RHPRoDejWBLo0MmtzZZeth8xsrgOhsOuouc3JwVwhs1Zg2iQfwzDrmp0Iz77zZ6b0f7XT3Jyh4DXF/RuVh8YVzOmihX3SH3s72teFh6tC50ZZC5h9+/NCvln4E9/9vCh7B5INoqMv89lnPxATlki5EiWpXaky5UqU5LV/zjI5JIJXN59hXfjlDI+1t7dn1KhXmTlzKJ55HVgw+GPOHjjAwg8Gknr2/fjxcxk37kfGj5/L2LGz0/TRqdN7dOs2iOZN+5KUkEyRShXwLuCLFYMKLZqlO+eWOgUZFX6YtZcv8trgydn7YIjcIWFhYfTt25cSJUrg5OREkSJFaNOmDStXrrS1CQgIwGKxYLFYcHZ2JiAggCeffJJVq1al669fv35Ur14dJycnqlSpct1zHzx4EDc3Nzw9PbP1mtasWYPFYsHLy4u4uLg0+zZt2mS7FhERERHJmAJmIjnIzg7ye4BDNiQx7T4GP6w2p3fmc0vZnu8GZYS2HIQlm2H+Ojhy5tbPn5AIc4Nh8u9msC4jFQPgf62gR/P0008d7KFqyZyprebsBEFFwSPvjdsmJSVx6uxZAELPniE5OTn7B3Qb3nhjHG+99QXPPvMRfs4FcChRjUILDhF81gyS2VnA1T7tU3dIyHH++mtrmm3O7u4EVK1i+72Xhy87l/8BQMGC+Wzb/fzypTnu2DHzHzcyMpolS9biVbAgn+3fyWf7d9FuwLvpxlv0ncdtCwBUq1b21i5aJJVkw8xQ3XfS/Jmcw5VWjx49SvXq1Vm1ahWjRo1i165dLF26lKZNm9KnT580bYcMGcLp06fZv38/3333HZ6enjRv3pxhw4alaWcYBj179qRz587XPXdiYiJPPfUUDRveODNz8ODB9OjR46avz83NjYULF6bZNm3aNIoWLXrTfYmIiIg8SBQwE7lHrN4J56Lg7z1m0KlzQ+jaBIrfoLRVdGzG96/n5DnYfzLtB9UT5+DUBXP1yu2H0x9zJQkiY8ypp9mZTZfdrFYrLes3pEC+fDxSvyF2dnfXYOPi4m334+MT+e5wJFGJyUQlJtO5mBu/NClMJa+UaOTOnSFUqPAUjRv/j48//sa23c5q5cO1q+kw+APiL18m7tIl/pr+HQDdu7fm559Hs2jRp/Tq1S7N+adPH4jDfxHe//3vE+Li4snr4UHBwNIZjjd/fi927pzFqlUTmTLl/ex6GHJEQnz8jRtJrjp4CqYth/lrYekW8+e05eb2nNK7d28sFgubNm2iY8eOBAYGUr58eV5//XU2bNiQpq2bmxt+fn4ULVqURo0a8fXXXzNw4EAGDRrE/v37be2++OIL+vTpQ4kS11/h5IMPPqBs2bI8+eSTOXJtAN27d2fatGm232NjY/nxxx/p3r17urbz58+nfPnyODk5ERAQwOjRo9PsDwgIYPjw4fTs2RM3NzeKFi3K119/nabNrl27eOihh3B2diZfvny8+OKLREdH58zFiYiIiOSgu+uToohkyt/b/OnjDo72UNAbfD1ufFztMlC+qLlgQFAmCQXhkTDvb1i+FY6fhZ/WmoX0N+xLaePnZU61hPRZYgmJZvbb9BVmcf+7XZ1Klfnfk09Rq2KlmzouuxYVvl4/Y8a8xrvvdmfKlPdp0aI2HYq64WAHBZ3tGVw5P038XNK037fvKAn/rfiwY0cIAHHx8RiGgaOzM42fexavQoWwd3SkTudOtuPatGlI27aN052/Tp2KFC7sC4CbW16s1pQ5ritWbKJx45f46KMpaY4pWNCHpk1rpGl7t5n96URee6gjX7837MaNJVccPGVmw0annT1IdJy5PSeCZhcuXGDp0qX06dMHFxeXdPuzMk2yX79+GIbB4sWLb+rcq1atYt68eUyYMOGmjrtZzzzzDMHBwRw/fhwwg2IBAQFUq1YtTbstW7bw5JNP0qVLF3bt2sXgwYMZOHAg3377bZp2o0ePpkaNGmzbto3evXvz8ssvs2+f+WJx+fJlHnnkEby8vNi8eTPz5s1jxYoVvPLKKzl6jSIiIiI54e6sdi0i6bStA2cjzYDZzZSdcXaCFlXTb082wILZ1/p9EHrevKVe2TIm1QdXlzzQvRkkXjH7TC0ixrwBHD0DjSpkfXz3iiOhJ5mz9DecnZzo3rY9nm43mAubic27d7F0bTCF8/vyTPOHsHf3ZvuFONwd7Cjh5oi3twcjRqRMA2tbxI3QJ0rjaGfBIYMVKNu1a0KvXm35d+8hytUpzOS5P3Lm/DmKFyrM060fx6doUb44doAriYk45snaMq2rVk3k55+Dadmyji3bDOCVVz5l//5j/PXXNjp1akZQ0PWzZ+4mG35bAcCOvzZwOSqavO6uuTwiSS3ZgDW7rt9mzW4oUTB7F2I9ePAghmFQtuytTyf29vbG19eXo0ePZvmY8+fP06NHD3744Qfc3W/tuSSrfH19adWqFd9++y2DBg1i2rRp9OzZM127zz//nGbNmjFw4EAAAgMD2bNnD59++mmaqaCPPvoovXv3BuCdd95hzJgxrFmzhrJlyzJz5kxiY2P57rvvbAHIL7/8kjZt2jBy5EgKFMjG5ZFFREREcpgyzETuEfZWM8vMMRvC3KHnYfJvMGUZXIyGAp4p5yhfzFw4oHxRqFcu/RiuDZYB+HhAmcLmapW1ytz++O5GO/fvIz4hgYhLlwg5duyW+9myZzfJyckcPxNG2JKZbA9eQ/1lx6j22xE2n8t4zqyLvV2GwTIAR0cHpkwZwFO9m2LNC2fOnwPMAN+ly2YU085qzXKwDKBIkQIcPhxK//6fs3v3Idv2ypXNaZm+vt4ULJjNKzfksIbtWmGxs6NGi0YKlt2FQs+nzyy7VnSs2S47Xc32vN3i94Zh3FQfL7zwAl27dqVRo0aZtgkODsbV1dV2Gz58ODNnzky3LSt69uzJt99+y+HDh1m/fj3dunVL12bv3r3Ur18/zbb69esTEhJCUlKSbVulSimZuRaLBT8/P87+Vxdy7969VK5cOU22Xv369UlOTk4zZVVERETkXqAMM5EH0P6TkHDFvB0OM6dtFslvZpF55DWz2G6GnQVaVc+Zsd4typcqze6DIeRxcqJkkVsvll25TFmWr1tLQauBrz0kXTgJFCQxGXZcjKemj/MN+4i5fJmTZ88Q4F8IJ0dHAIoVLMSFyEhiY+JxdLInsFhx3F1uLTC0dOl6xo37EQCr1Y4lS8YA8P33H/H8849TsWIpvLxu/J/k1Klw5s1bSdOm1alUKeMaaHdKx34v0KHv83ddzToxxdwgWHaz7bKqdOnSWCwW9u7dS7t27W6pj/PnzxMeHk7x4sWzfMyqVav4+eef+eyzzwAz4JacnIy9vT1ff/01PXv2pEaNGmzfvt12zBdffEFoaCgjR460bfP29s7S+R599FFeeuklnn/+edq0aUO+fPnStcko6JfR9HEHB4c0v1ssFtviKdcLHGpFThEREbnXKGAmcg85cxEuxUFJv5ublnmtwELmCnT21pRFA/yz9rnrgVWqaDHeff5FLBbLbQVd6lauSo1yQdhvXoHl4lkcy9ak4TFn8jlZ6Rxw4yBUUlISUxfMI+LSJQoXKMDzHcy6ZG2aNOXzYT+yYe2/xMclsm3bD7f8AbVkycLkyeNEXFw85cunTLt0dHTg4YfrZLmf1q1fZ9u2/bi7u3DixC+453Jml4Jld69rV9W93XZZ5e3tTcuWLZkwYQKvvvpqujpmERERN6xjNm7cOOzs7G4q4LZ+/fo0WVuLFy9m5MiRrFu3jkKFCgHg7OxMqVKl0ow1KioqzbasslqtPPPMM4waNYrff/89wzZBQUH8/fffabatW7eOwMDALNcnDAoKYsaMGcTExNgey7Vr12JnZ0dgYOBNj1tEREQkNylgJnKPCLsIc4LBMKBmaagfdOt9FfaB/z2aUsMsp11JMmsUZcd00tx0K0Xt12zeyLZ9e6kRVIGG1WsA4ODoBPUfA6AgsPQmPv8mXrlCxKVLAIRfvGjbbrFYGPZRHz76aCoNGlSmSpVb/3BatmwAO3b8wNGjp2nRovZNHXvqVDivvTYGHx9PLlyIBODy5TgSEq7c8njk/lconzml+3rTMl2dzXbZbeLEidSrV49atWoxZMgQKlWqxJUrV/jjjz+YNGkSe/futbW9dOkSYWFhJCYmcuTIEX744QemTp3KiBEj0gSyDh48SHR0NGFhYcTGxtoyxYKCgnB0dKRcubTz3f/55x/s7OyoUCHnCkAOHTqUt956K8PsMoA33niDmjVrMnToUDp37sz69ev58ssvmThxYpbP0a1bNz788EO6d+/O4MGDCQ8Pp2/fvjzzzDOqXyYiIiL3nHv846vIg+NSrBksA4i8fPv9ZWfh7Ou5cAnmBkNiErSulZLR9iC4kpTEn/9sBmDVpg3Ur1rttrOc8jg50bpxU/YcOkiN8mk/XNevX5nly8ffVv8s3Q0/bSGwVQUCn8h6NtlVQ4ZMZe5cs8D+Bx/05MyZCzz2WH18fDxvb1xyX7OzQJOK5mqYmWlSIWeet4oXL87WrVsZNmwYb7zxBqdPnyZ//vxUr16dSZMmpWk7aNAgBg0ahKOjI35+ftSpU4eVK1fStGnTNO169erFn3/+afu9alVz5ZUjR44QEBCQ/ReRBY6Ojvj4ZF57sFq1asydO5dBgwYxdOhQChYsyJAhQ9IU/L+RvHnzsmzZMvr160fNmjXJmzcvTzzxBJ9//nk2XIGIiIjInWUxMipQkcOioqLw8PAgMjIyx1eHErlfJBuwdg9EXYYG5c1aYzlynmRYvcsMdDWuAL6et9fftkPw527zfoVi0LxK1o+9ePYsB7b8Q+lq1fAu4Hd7A8klMxYv5OipUEoULsIzbdrm9nBurM4wiLtiRib+fhfyOt7U4Z999gNvvfUFFouFlSsn0LRpjRwaqOSGnH79PnjKXC0zdaaZq7MZLCvln+2nExERERHJlDLMRO4RdhZoWD7nz3P0LOw6at5ftxfa1b29/koWhJ1HIP4KBN1krfxvBrxLRPhZ3Ly9eWvqt/dkDaqnWz/OxagovD08sr3vLVv28uST7+Pt7c4vv4zGzy8bVq4s4Qt7TkFhL3C6+ZeIN998mgoVSuLt7U6tWnfgP6zcV0r5Q4mC5mqYMXFmzbJC+e5cRqyIiIiIyFUKmIk8wIL/hZPnoG5ZCPhvqqSXKzhYzSmU+a8T4zkTAXkcwMMl8zYA7nmhe/ObH1tycjKX/6vVFRcdg5GcDNkcMEtOTiY+MQFnp2yuJJ6K1WrFx8srR/qeOPEnDh8O5fDhUObPX02fPp1uv9Ovn4Xtx6FCIbCaj/fp2CssPxVN4wJ5CXC9ccbZI4+kjbJGRFxi8eI/qVOnImXKFLv9Mcp9zc4CRbIh9isiIiIicjsUMBN5QJ2Lgi0Hzft/bINnm4GTgxkwe/ohiI7NuMB2sgGbD8D6fWY8pXPD25+2mRE7Ozu6vTeA7WtWU6lRI6z22ft0lZiYyLRF8wk7d44mNWvRuEatbO3/TnjssQbMmPEbLi55aNSoavZ06uoEDUqn2dR61Qn2RSVQII+V/W1L4nCT6T4dOrzN6tVb8PBw5ciRRXh5aSq+iIiIiIjc3RQwE3lAueaBPI4QlwAx8bB0C7T9r8a7R96Ma6QZBixaD8fDzd+TkiE8KmcCZgAlK1ehZOUqOdL3uYiLhJ07B8DugyG2gJlhGJyPiMDD1RUHB4ccOfetCDl2jFWbNlC0YEEeqd8Qi8VChw5NOXXqV5ycHPHwcM2xc4fFmitcXkhIIiHZuOmA2cmTZwGIiorh0qXLCpiJiIiIiMhd794rCCQi2SKPIzyeKqkqJi7ztlclXEkJlgGU9ofAe7QQt693PkoVLYaDvT21K1a2bV/y1xom/DiTr36aQ2JiYi6OMK0VG9YSdi6cTbt22gJ9AL6+3tkSLIuNjeOFF4bRseO7nDoVnmbfDw386VTMje/r++Nif/MvG99//xGdO7dg6tQBFC16by7eICIiIiIiDxZlmIk8wPzzQbPKZoHt6qVu3N7JAaoUh70noUoJs/bZvcpqtdLtsTbpth8+cRyA8xERREZH51j9sZtVuIAfZy9cwDVvXjzd3LK9/xkzfmXq1MUA+Pp6MXHiO7Z9Tf1caOp3g2J111G7dgV+/HHYbY9RRERERETkTlHATOQBVzHAvGVk9zGzuH+NUinF/ZtUMm/3qyY1a7Nm80ZKFClKPk/P3B6OTevGTalaLghvDw+c89zeIgUnT54hf34vnJxSCviXLl0Ei8WCYRjXLcz/44/L6dv3M2rWDGLhwlFp+hAREREREblfWAzDMO70SaOiovDw8CAyMhJ3d9WyEbkbnY2AWX+a94v4wBP1c3U4kkUXoyKJT0jAzyd/hvs/+GASw4ZNJzCwKJs3f4u7e8p0zi1b9hIRcYlmzTJfAKFGjWfZsmUfAMHBX9OgQZVsHb/c3fT6LSIiIiIPCtUwE5EMOdjD1druTndP7fsHXkJC5nXVQs+cYcLsmXw1bw7//Ls73f6YixfZ+NVEAjnHgQPH2b//eJr91auXu26wDKBDh6YAlCpVhAoVStq27917hCVLgklKSrqZyxEREREREbkrKWAmIhnycjWzyppWhBZVc3s0DwbDMLgQGcGVTIJO33yzmLx5G1Gx4lNERkan2x92/hxJyckAhJ49k27/rLffx/dcCDU4RXkPgypVSgOwbdt+ypTpSP36vQgPv3jdMb7//nOcPv0bu3fPxtPTrKV24MAxqlZ9hjZt3uD118fezCWLiIiIiIjclRQwE5FMFcoHlUsow+xOWbRqBeNn/cC0BT9lmKk1ffoSkpKS2L37EBs3ps8gq1i6NOVKlKRYQX8aVK2Wbr9T3ry2++cio4mMjAFg/Pi5HDhwnHXrdvLOO+NvOE4/Px9b7bKfflrJO+98SXx8AgD79x/L2sWKiIiIiIjcxRQwExG5Sxw8bgabTp8LJyY2Nt3+Xr3aYm9vpUqVQOrUqZBuv6ODI0+2bEWPdh3I55l+dc8un3yMZ7O2/G1XnKZdnmDGjF9p1OhFvL1TVt2cPn0JO3YcyNp4D57gySffZ9GiPylY0IfWrRswenS/rF7uPSE5OZkZM5bw008rc3soIiIiIiJyB2mVTBGRu0TjGrX4e9sWygSUwN3VNd3+Hj1a88wzrdi//xjt2r1FsWIFmTz53SyvVOno7MyEFXP40jA4e/YCfn6tANi37xgPP1yb5cs3Ymdnl+X+nJwccXCwJyEhkXLlAvjll8+v2/77739j3Lgf6dSpGe+80z1L58hto0fP5O23zay72bM/pkuXh3N5RCIiIiIicicoYCYicpeoVbEStSpWum4bq9XKhx9+zerVWwB45JG6dO7c4qbOY7FY8PBwpVixghw7dprKlUsze/bHTJ26mKpVy1C2bICt7YgR3/LLL8G8886ztG3bOE0/RYoUYOXKCaxfv4vu3R+74Xn79v2MyMhotmzZx/PPt8XHx/Omxp0bLl68ZLsfEXHpOi1FREREROR+YjEMw7jTJ9Wy9CIit27EiG95//2JODk5snnzt1SsWOqW+gkPv8i2bftp2LAKzs550u0/ceIMRYu2AcDfPz+hob/e1rgffrgvf/yxkbJlA9i5cxYODnf/dzbR0Zf56KOpuLjkYcCAnvfEmHOSXr9FRERE5EGhgJmIyD1o7dod+Pnlo2TJwjl2jsuX4yhX7kmOHw/jscfqs2TJmNvqLy4uns2b91CpUmk8PNJPOZW7n16/RURERORBoYCZiIhk6ty5CHbuDKF+/cpZrm0m9y+9fouIiIjIg+LBnlsiIiJpGIbByq+mEhsZSct+r+Dj48lDD9XM7WGJiIiIiIjcUQqYiUiOMAwIuwjuecElfXksuUutm/Uj01/uC0DspUs8+fFHuTwiERERERGRO08BMxHJEX/uhu2HIY8jPNNUQbPcYBgGX875hQtRl3jzmSdwyaCwv4iIiIiIiKSngJmI5Iiwi+bPuASIiFHALDf8uOxP+n02GYBLl2P5rH+vGx5Tr2sX4qKjuRwZRctX++T0EEVERERERO5KCpiJSI6oHwR//wsFPMHfO7dH82BysE95ind0yNrTvcViodlLL+TUkERERERERO4JWiVTROQ+9t2SlVyIusTLHR/DydEhV8dy7lwEjzzyKidPnmX27I9p2rRGro5Hbp5ev0VERETkQaEMMxGR+9izrZvl9hBsfvttLVu27ANg4sSfFDATEREREZG7ll1uD0BERB4MjRpVxdfXG6vVSvv2TXJ7OCIiIiIiIplShpmIyD3u1KlwOnZ8l9jYeObMGUZgYLHcHlKGAgL8OXp0EbGx8Xh7e+T2cERERERERDKlDDMRkXvcd9/9xvr1u9i+/QCTJs3P7eFcl7NzHgXLRERERETkrqeAmYjIPa5Ro6o4OTlitVp56KGauT0cERERERGRe56mZIqI3OPq1avE0aOLSExMokiRArk9HBERERERkXueAmYiIvcBPz+f3B6CiIiIiIjIfUNTMkVERERERERERFJRwExERERERERERCQVBcxERERERERERERSUcBMREREREREREQkFQXMREREREREREREUlHATEREREREREREJBUFzERERERERERERFJRwExERERERERERCQVBcxERERERERERERSUcBMREREREREREQkFQXMREREREREREREUlHATEREREREREREJBX73DipYRgAREVF5cbpRURE5BZcfd2++jouIiIiInK/ypWA2aVLlwAoUqRIbpxeREREbsOlS5fw8PDI7WGIiIiIiOQYi5ELXxMnJydz6tQp3NzcsFgsd/r0IiIicgsMw+DSpUv4+/tjZ6eqDiIiIiJy/8qVgJmIiIiIiIiIiMjdSl8Pi4iIiIiIiIiIpKKAmYiIiIiIiIiISCoKmImIiIiIiIiIiKSigJmIiIiIiIiIiEgqCpiJyHX16NEDi8WCxWLBwcGBEiVK8OabbxITE2NrM3/+fJo0aYKHhweurq5UqlSJIUOGcOHCBQBOnz5N165dKVOmDHZ2dvTv3z+XrkZERERERETkxhQwE5EbeuSRRzh9+jSHDx/m448/ZuLEibz55psADBgwgM6dO1OzZk1+//13du/ezejRo9mxYwfff/89APHx8eTPn58BAwZQuXLl3LwUERERERERkRuyGIZh5PYgROTu1aNHDyIiIli0aJFt2wsvvMCSJUtYvHgxtWvXZuzYsfTr1y/dsREREXh6eqbZ1qRJE6pUqcLYsWNzduAiIiIiIiIit0gZZiJy05ydnUlMTGTmzJm4urrSu3fvDNtdGywTERERERERuRcoYCYiN2XTpk3MmjWLZs2aERISQokSJXBwcMjtYYmIiIiIiIhkGwXMROSGlixZgqurK3ny5KFu3bo0atSI8ePHYxgGFoslt4cnIiIiIiIikq3sc3sAInL3a9q0KZMmTcLBwQF/f39bRllgYCB///03iYmJyjITERERERGR+4YyzETkhlxcXChVqhTFihVLExjr2rUr0dHRTJw4McPjIiIi7tAIRURERERERLKPMsxE5JbVrl2bt99+mzfeeIPQ0FDat2+Pv78/Bw8eZPLkyTRo0MC2eub27dsBiI6OJjw8nO3bt+Po6EhQUFAuXoGIiIiIiIhIehbDMIzcHoSI3L169OhBREQEixYtyrTN3LlzmTBhAtu2bSM5OZmSJUvSsWNH+vbta1spM6NaZ8WKFePo0aM5M3ARERERERGRW6SAmYiIiIiIiIiISCqqYSYiIiIiIiIiIpKKAmYiIiIiIiIiIiKpKGAmIiIiIiIiIiKSigJmIiIiIiIiIiIiqShgJiIiIiIiIiIikooCZiIiIiIiIiIiIqkoYCYiIiIiIiIiIpKKAmYiIiIiIiIiIiKpKGAmIiIiIiIiIiKSigJmIiIiIiIiIiIiqShgJiIiIiIiIiIikooCZiIiIiIiIiIiIqn8H1EGm34jX5vaAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Silhouetten-Score for latent_omiae: 0.040296976439856386\n", + "Davies-Bouldin-Index for latent_omiae: 4.8282559732273\n" + ] + } + ], + "source": [ + "pca_and_scores_for_embedding(test_data, LATENT_NAME, 10, [\"level1\", \"level2\", \"level3\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compute metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [], + "source": [ + "LABELS_COLUMN = \"level1\"\n", + "X = test_data.obsm[LATENT_NAME]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Silhouette score" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "silhouette_score1 = sklearn.metrics.silhouette_score(X, labels=test_data.obs[\"level1\"])\n", + "silhouette_score2 = sklearn.metrics.silhouette_score(X, labels=test_data.obs[\"level2\"])\n", + "silhouette_score3 = sklearn.metrics.silhouette_score(X, labels=test_data.obs[\"level3\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Silhouette score for level 1: 0.20011337101459503\n", + "Silhouette score for level 2: 0.032275088131427765\n", + "Silhouette score for level 3: 0.044666122645139694\n" + ] + } + ], + "source": [ + "print(f\"Silhouette score for level 1: {silhouette_score1}\")\n", + "print(f\"Silhouette score for level 2: {silhouette_score2}\")\n", + "print(f\"Silhouette score for level 3: {silhouette_score3}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For n_clusters = 7 The average silhouette_score is : 0.20011337\n", + "For n_clusters = 18 The average silhouette_score is : 0.032275088\n", + "For n_clusters = 40 The average silhouette_score is : 0.044666123\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABZoAAAKgCAYAAAAS1si3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd5gTVdsG8HvSk+29s4Wy9N57R6qAAgoqTV4RRIFXP7sUEQvqa+8KIhZAlCJFUao0Aem97dJ3l7K9JjnfH0OGZDfZzRZYyv27rlw7mTkzc2Yys5l5cuY5khBCgIiIiIiIiIiIiIiojFSVXQEiIiIiIiIiIiIiur0x0ExERERERERERERE5cJAMxERERERERERERGVCwPNRERERERERERERFQuDDQTERERERERERERUbkw0ExERERERERERERE5cJAMxERERERERERERGVCwPNRERERERERERERFQuDDQTERERERERERERUbkw0ExElWrOnDmQJEl52evYsaMyfsSIEcr4hIQEh3nWrVt3cytNt5x169Y5HBMJCQk3bd1Tp05V1hsTE3PD1pORkYGnnnoK0dHR0Gq1yjrnzJlzw9ZJt7fKPC9uBfyuIGdu1v/skowYMUKpR8eOHSutHreC8u6LO3lf8v8YERHdbhhoJqIKI4TADz/8gO7duyM4OBharRa+vr6Ii4tD586d8d///hcbNmyo7Gre0ty5Wbrbg0d3q7Fjx+KDDz7A6dOnYTabK7s6AIoei4WD3leuXEGTJk2U6Wq1Gt98843TeSVJwpAhQ5yu5+uvvy5SdurUqTd466giFHd8EFHFuVUC6BXtTg4i3y5iYmL43VuCs2fPYvr06ejXrx/Cw8Pdvl7JyMjAG2+8gdatW8Pf3x8ajQYmkwnVqlXDI488gm3btt28jSAiqiCayq4AEd05Hn74YXz//fcO49LS0pCWloZTp05h7dq1SEtLQ/v27ZXpzZo1w6xZs252VYkqTPfu3eHp6QkA8PHxuSHrKCgowMKFC5X37dq1Q+/evaFWq9GsWbMbss7ySklJQdeuXbF3714AgFqtxrfffothw4a5nOeXX37BuXPnEBER4TD+o48+uqF1pTuTv7+/w/dL1apVK7E2ROTKAw88gLp16wIAoqKiKrk2RKW3Y8cOTJkypVTzpKWloWXLljh8+LDD+JycHJw4cQInTpzA999/j2+//RYPPfRQRVaXiOiGYqCZiCrEypUrHYLMLVq0QNeuXaHX63HmzBkcOXIEW7ZsKTJfnTp1UKdOnZtZVaIK1bp1a7Ru3fqGruPChQsoKChQ3k+ZMgVdunS5oevMzc2FWq2GVqst9bwXLlxAly5dcOjQIQCAVqvF999/j0GDBhU7n9lsxmeffYZXX31VGff3339j9+7dpa4D3b1sx663tzeefvrpyq4OEZXgnnvuwT333FPZ1aBbiNlsRkFBAYxGY2VXxW2enp5o1KgRmjZtiv/9738llv/iiy8cgswdOnRA165dcfbsWXz99dcwm82wWq145ZVXGGgmotsKU2cQUYVYvXq1Mly9enVs3rwZM2bMwMsvv4wvvvgC69evR1JSEv7zn/84zFdcjubSWLhwIZo3bw6j0YjAwECMGDECV65ccVr2zz//xH333YeIiAjodDr4+PigRYsWeOONN5CRkeFQtqTceCU9Trhr1y6MHDkScXFxMBgM8PLyQrNmzfDuu+8iNze3yH749ttvlXHr168vsm5JktCpUyeHdcTGxjrNZV2a9ZckNzcXL774Iu655x7ExcXBx8cHWq0WgYGBaN++PT766KMi6Ryc7bt58+ahadOmxX5OycnJeOaZZ9C5c2dER0fDy8sLOp0OISEh6N69O+bNmwchhFv17ty5s7L+4cOHF5n+/vvvK9NDQkKUYO6+ffvw0EMPISYmBnq9HkajEVWqVEHnzp3x/PPP49y5c8oyintcOTExEY899hiqV68Oo9EIg8GAiIgItGnTBpMnT1YCscWJiYlBdHS0w7iuXbs6TZ1y5MgRjB07Vlmfh4cHatasiSeffNJpipXCedB37dqFXr16wc/PD0aj0WE73XX27Fl06NBB2TadToeFCxeWGGRWqeRLki+++AJ5eXnK+A8//NBhenGOHz+O8ePHo2bNmjCZTDCZTKhXrx6mTJmCtLS0IuUXLlyIYcOGoW7duggODoZOp4Onpyfq1KmDCRMmuLXPjhw5gkGDBsHf3x9GoxGtWrVymkOzNMdUSQoKCvDll1+ia9euCAoKgk6nQ3BwMNq0aeP2EyKucuADFXNM25Zvb+TIkS6Xe+HCBTz33HOoX78+vLy8YDAYUKNGDUyePBkXL14ssf7Ojt3i/n8X3sbU1FRMmjQJUVFR0Ov1iI+Px6effup03+3btw99+/aFt7c3vL290aNHD+zcubNcqQvKe+66exwWZ+nSpbjnnnsQEhICrVYLb29vVK1aFf3798frr78Oq9WqlP3zzz8xatQoNGrUCKGhodDr9TCZTKhevTpGjRqFffv2FVl+4RQIR48exYABA+Dj4wN/f38MHToUSUlJAIC1a9eiXbt2MJlMCAoKwujRo3H16lWH5RW+fsjNzcWUKVNQtWpV6PV6VK1aFTNmzHD4kc4dqampmDFjBpo1awYfHx/o9XrExMRgzJgxOH78eKmWBQAbNmxAx44d4eHhAX9/fwwaNAgnTpwodp7PP/8cgwYNQs2aNREYGKh8Ho0aNcJzzz2HS5cuKWVt1wbTpk1TxiUmJjpNW3P8+HE89dRTaNu2LaKiouDh4QG9Xo/IyEj069cPv/32m9vb9d577ynLj4+Pd5jWqFEjZZr99aF9GqSQkBDlu9xZegx3r4ucSU5OxmOPPYbQ0FAYDAY0aNAAixYtcnvbynr9UhpCCMyfPx99+vRBWFgYdDodAgIC0KxZMzz77LNuLaO4tCLFXV9funQJTz/9NOrUqQMPDw/odDqEhoaiefPmeOKJJ7B161aH5ScmJirzTps2zeVyS3vuFK7/yZMnMWTIEAQGBkKn0ylpIyry+/NG6dmzJ9LS0rBhwwa8++67bs1j/3/Ax8cHf/31F1566SV89tlnDoHllJSUCq8vEdENJYiIKsCECRMEAAFABAQEiCNHjrg13+zZs5X5Cv9L6tChgzJ++PDhyvhTp045zNO9e3eH97ZXmzZtiqxv8uTJTsvaXtWrVxeJiYku17V27VqH5UVHRyvTpkyZ4jDtww8/FGq12uW6mjVrJlJTU53uB2evtWvXlljGfj+VZv0lSUlJKXHdXbt2FWaz2eW+a9OmjVuf0/bt20tc18iRIx3mKbxvTp06JYQQYtGiRco4o9FYZHtbt26tTJ88ebIQQogDBw4Ik8lU7PpXrlypLGPKlCnK+OjoaGV8UlKSCAoKKnY5n376aYn73v4Yc/aybev8+fOFwWBwWc7Ly0v8/vvvDsu2P8caNWpUZLtty3al8H6fMmWKiI2NVd4bDAaxYsUKt+a99957leG5c+cKIYQ4d+6c0Gg0AoDo379/kXXZW7RokTAajS63v2rVqg7nthBC9O7du9h96+3tLfbu3etyn9WvX194enoWmU+n04n9+/cr85T2mCpOSkqKaNKkicvl2B+Drs6Lwtth/39DiIo5pu2XX1I9//77b+Hv7++ybHBwsNi1a5fLz8HVsVvc/2/7bQwICBA1a9Z0uu4vvvjCYb3bt293+pkbDAbRtWtXp9tXkvKeu+4eh8Vx5zsoJydHKT9+/Phiy+p0OrF69WqHdQwfPlyZHhsbK/z8/IrMFx8fL+bNmydUKlWRae3bty+2zp07d3ZalwEDBjjM5+r4FkKIw4cPiypVqrjcLg8PjyKfRXF+++035X+Y/cvf31+0atVKed+hQweH+erUqVPs/o2IiBDnzp0TQhQ9z529Zs+eLYQQYuHChSWWnTZtmlvbtmfPHof5Ll68KIQQIj093eHa4+WXX1bmsT8GBg8e7HS8bV+4e11UeP74+Hin35uSJLn92ZX1+sVd2dnZ4p577il221zVxf7/mLP9ZuPq+jonJ0fEx8cXu+5nn322yPJLqmdZzh375VevXl0EBwcX2daK/P5055iyfxXep6Vhv5zC1ys277//vlJGpVKJpUuXitzcXHHs2DFRq1YtZdr9999f5noQEVUGps4gogrRsGFDZfjy5cuoWbMm6tevj2bNmqFZs2bo2rUr4uLibsi6//jjD7Rq1QpdunTBb7/9pjxmv2nTJmzZsgWtWrUCAMydO9ehlUH9+vXRr18/JCQk4Pvvv4cQAseOHcPgwYOV1hxltWnTJjz55JNKa522bduia9euSE1NxbfffourV69i+/btePzxx/HDDz8ouarnz5+PHTt2AADi4uLw+OOPK8usWrUqZs2ahRMnTuCzzz5Txr/wwgvw8/MDACXHYWnXXxJJklCtWjW0aNEC4eHh8PPzQ0FBAQ4fPoyFCxfCbDbjzz//xKJFizB48GCX+8Sdz0mlUqFOnTpo1qwZQkJC4Ovri9zcXOzatQvLli2DEAKzZ8/G2LFj0bx582Lrfe+996JKlSo4ffo0cnJy8P3332PcuHEAgHPnzjmkc7G16vz222+RnZ0NAIiMjMRDDz0EDw8PnD17Fvv373f72Fi0aJHSCsXPzw8jR45EQEAAzp8/j8OHD2Pjxo1uLefFF19EQkICZs6cqYwbO3askm/W398fx44dwyOPPKK0BA4KCsLw4cNhNpvxzTffID09HRkZGRg0aBCOHj2KkJCQIuvZtWsXtFotRowYgapVq+LAgQOlTpsxffp05ZgzmUxYunSp2yk+hg0bhg0bNuDq1av46KOP8PDDD+PTTz9VWspPmDABixcvdjrvyZMnMWzYMKWVfv369dG/f3/k5+fju+++w7lz53DixAk8+OCD2LRpkzKfn58f7rnnHsTHx8PPzw86nQ5JSUn45ZdfcObMGaSnp+PZZ5/FihUrnK537969CAwMxNixY5GUlITvvvsOAJCfn48PPvgAn3/+OYCKO6YAORf+zp07lfd16tRBz549odFosGPHjhJbSpZHaY7pxx9/HH369MEzzzyjjBsyZAiaNm0K4Ho+87S0NAwYMEBpGRgXF4fBgwdDq9ViwYIFOHLkCJKTkzFw4EAcOnQIer2+SL1cHbvutmS9fPkyUlNTMWrUKAQEBODjjz9WPq+3334bY8aMUcqOHDkSmZmZyvsHH3wQcXFxWLBgAf7880+31mevIs5dd4/D4ti33m7WrBn69OkDs9mMM2fOYNu2bUWevvD09ESnTp1Qp04dpRX15cuXsXz5chw6dAj5+fl48skncfDgQafrO3XqFAICAvDMM8/g5MmTSmvTI0eOKC0Xhw4dik2bNmH9+vUA5JbBW7duRcuWLZ0uc+3atXj44YdRpUoVLFq0SHkk/ddff8W8efNKfPTcYrFgwIABOH36NAAgJCQEw4YNg4+PD3777Tds374dWVlZGDx4MI4dO4agoKBil5ednY1Ro0Yp/8O0Wi1GjRoFPz8/zJs3z2k6MZuQkBBUq1YNcXFx8Pf3hyRJOHfuHBYsWIDLly/j3LlzmDFjBj755BPl2uCPP/5QWg/7+fnhhRdeUJZny+Wv1WrRuHFjNGnSBEFBQfD29kZmZiY2bdqEtWvXAgBeffVVjB49ukiu/MLq1auHwMBApXX133//jfvuuw+bN2+GxWJRytn/X7DvELrw01mFuXtdVNiRI0dgMpkwYcIEWK1WfPbZZ7BYLBBC4J133kH37t2LXa8z7l6/uGvy5MlYtWqV8j4mJgb33nsvvLy8sHfvXixfvrzUdXTX2rVrceTIEQCAwWBQPuuLFy/i+PHjyvkGXM+dPXPmTOWJgm7duhXZhxVx7hw7dgySJGHQoEGoV68eEhIS4OHhUaHfn7eaMWPG4KeffsKWLVtgtVrRr18/h+lqtRr333+/y6driIhuWZUZ5SaiO0d+fr5o0KBBsS0DOnXqJA4fPuwwX0W0aG7ZsqUoKCgQQghx+fJlh5Y0H3zwgTKfff1iY2MdWmdNnz7dYZl///2303W526J5wIAByvgePXoIq9WqTFu1apVDC5szZ84o04prnWJTXCvF8q6/JElJSWLJkiXik08+EW+//baYNWuWqFu3rrK8UaNGKWXL+jnZJCYmip9//ll89NFHyroiIiKUeaZPn+7WPpk5c6YyvlGjRsr4//3vf8r4pk2bKuOffPJJZfzrr79epF5XrlwRV65cUd67ah337rvvKuMfe+yxIsvJzMxUWoCVpKTj8KmnnnJoFXPw4EFl2oYNGxzmnTFjhjKtcKtTV62PXSmuJd2CBQtKNe+yZcvE008/rbzfsGGDCAkJEQBEnTp1hBCuWwhNmjRJGV+vXj2Rl5enTDt8+LDDfJs2bXKoR35+vtiwYYP4+uuvxf/+9z8xa9YsMXLkSKW8Xq8X+fn5TveZSqUSe/bsUabZt7pu3LixMr60x5QrhVsQ9u3bVzmnbE6cOOFyH5e3RXNZjmn79dtaVdqzb9EVHBzs8NTB1atXHVr6fv/9907r7+rYdbdFMwDx0UcfKdPee+89h2np6elCCCE2b97sMN7W6k8I+TO0b6Hrbovmijh33T0Oi1O/fn1lni1bthSZfurUKWGxWBzGWSwWsW3bNjFnzhzx3nvviVmzZhV5auj06dNK+cKtI23fs1arVYSFhSnjtVqtMl9qaqrQarVOvysKXz+89tpryrS0tDQRGBioTGvXrp0yzdXxvWTJEmW8TqcTCQkJyrS8vDyH1pr263Llxx9/dKjfV1995bA/7bfL2fd9VlaW+PPPP8UXX3wh3n33XTFr1iyHJz/i4uIcyhfXUruwI0eOiJ9++kl8+OGHyverfatR21MlJbnvvvuUeZ566ikhhBAvvfSSAOQnBQD5aaK8vDxx9uxZh/1h/+Rbcdc+7lwXFT62fvvtN2XaxIkTlfH+/v5ubVd5r1+Kc/nyZYdW7k2aNBGZmZkOZez/j1d0i+ZffvlFGdejR48i9cvNzRVnz551GFfc03tClP3cKfy5ffLJJ0WWXVHfn0IIsX//fjFr1iy3Xz/99JNby3XGfrtctWgWQt4/jz76qEN526tu3bpi8eLFZa4DEVFlYYtmIqoQWq0W69evx4wZMzBnzhyH/IE2a9euRffu3bF//354eXlV2LpHjx4NjUb+d+bv74/AwEAlz6OtBUZWVhb27NmjzDNo0CAYDAbl/fDhw/HKK68o7zdv3ow2bdqUuU72rSZ///13l/llhRDYunUr7r///jKv62asPycnB+PGjcPcuXMd8nQWdvbsWZfT3PmcALl14fDhw0ts0VPcuuyNGTMG06dPV1pF79y5E02aNMHChQuVMiNHjlSG27Vrhw8++AAA8NJLL2HZsmWIj49HfHw8WrRogXbt2kGtVpe43jZt2kCSJAgh8MUXX2D79u2oXbs24uPj0bRpU3Tq1Mlp68Sy2Lx5szLctGlT1KpVy2F7YmNjcerUqSJl7TVo0AA9e/askPoA8r5r06YNwsPD3Z5n3LhxePfdd2G1WvHggw8qx8eECROKnc/+eN+3b5/TVq82mzdvVjpv/P777zFx4kSn/69s8vLycOnSJYSFhRWZ1qpVK9SvX195b5+n1P6Yrqhjyn47AeDll19WzimbG/XkCHBjjmn7bUpOToavr6/Lsps3b8bQoUOLjC/vsatWqzF69GjlfeF8s1evXoWXl5dDS3IAeOSRR5RhPz8/3HvvvUouXHdVxLnr7nFYnHbt2mHv3r0A5BaLrVq1QvXq1VG7dm20b98e9erVcyi/evVqPProo0oLRlfOnj2LqKioIuOjo6OV71hJkhAdHY0LFy4AkI8z2zw+Pj4IDg5WcrAWtz0PP/ywMuzt7Y2+ffti9uzZAKC0iC2O/bGYn59fbJ5tV5+FvcLrtD92Y2Ji0LZtW6UVcWHvvvsupkyZ4tB6vrCy5KVNSEjAsGHDSqy/u9+vnTp1Ulqj//333w5/x44di7feegs5OTnYuXOnQ57fiIgI1KhRo9T1d0dERAR69+6tvC/L+VCYu9cv7ti2bZtDnxbPPvssPDw8HMrcyP/jzZo1g16vR15eHn7//XfUqVMH9evXR40aNdCoUSN06dKlxNbshVXEuePv71+kHxeg4r4/gVuvA/L09HQMGDAAa9asAQA0b94cvXr1QmJiIr777jvs378f/fv3x9tvv43//ve/lVxbIiL3MdBMRBXGx8cHs2bNwptvvokDBw5g69atWLt2LRYvXoycnBwAwOnTp/HLL7847ZitrAp3lGYfZLIFRVNTUx3KBAcHO7wvHBxxdeMgCnVCZ99pmb3SdBBzIzr5qOj1P//8824FUFztD8C9zwmQb+jceWy0uHXZCwwMxJAhQ5QOhb766iuEhIQojy3r9Xo8+OCDSvn7778fTz/9ND788EPk5eVh8+bNDjdG0dHRWL58eYk3K82bN8e7776Ll19+GZmZmfj333/x77//OtRr4cKFRTrwKQv747XwsQ3Ix7ctWOXq2K6Im/64uDicPHkSAHD06FG0b98ea9eudRpociY2Nha9e/fGsmXLlCCKr69viY+8l+V4//fff/HII48U+8OJjatjzd1juqKOqcLbWdoO51xx9//ajTimK+J/VXmP3ZCQEIcfHgv/UOHqeyQ0NLTY9+6oiHPX3eOwODNnzsTJkyexcuVKZGZmYvXq1Q6duHXo0AErVqyAyWTC+fPn0b9/f+Vx9uK4OpYKB7Ls61x4mv2PKcVtT3Hf6zk5OcjLyyv2R6iK/t60P168vLxgNBpd1s/e4sWL3QoqufsdaK9///4OP7qXd9n26S92796NK1eu4J9//gEg/2Dx119/YevWrfj777+V47jwfBWtuPOh8P+6ilimu+eYTWX/H4+MjMScOXMwYcIEXLp0CQcPHnRIcePp6YmvvvoKQ4YMcXvdFXHuVK1a1WnAuKK+PwHgwIEDWLlypdt1jYqKKtV+KK3p06crQeZq1aph06ZNyv+7mJgYTJkyBYD8o/KYMWPg7e19w+pCRFSRGGgmogqnUqlQr1491KtXD2PGjMGuXbvQuHFjZXpZem0vTuE8soV7wQZQpJVccnKyw3tbyxQbW87jwi2BbQFzAMjIyCgyn/38tovpTp06oVevXi7rX9rcfu6o6PXPnz9fGe7UqRO++OILxMbGQq1WY/DgwQ6tg11x53PKyspy6PX+gQcewKxZsxAeHg6VSoXmzZtj+/btJa6rsAkTJiiB5h9++AGRkZHKTVn//v2Vz9tm1qxZeOmll7B582YcPnwYR48exdKlS3H+/HkkJiZi/PjxLnu7tzdx4kT85z//wdatW3HgwAEcO3YMq1atwrFjx3Dp0iWMGDECCQkJpd6ewuzrX/jYBhyP78LbamMymcpdj5deegk7duzAJ598AkDuUb1Dhw5Ys2aN2zfTEyZMwLJly5T3o0aNKtLaqzD7bWrQoEGxgWlbrtKFCxcqAQIPDw/8/PPP6NChA4xGI1asWOHQIs4Vd45pm4o4pvz9/R3eJyQklJgn1hX7/232/9cAOVemKxV9TNt/dlWqVCm29XrhlsY25T123f0cnX2P2H8mFy9eLPW6K+LcLc1x6Iq3tzdWrFiBs2fPYuvWrTh69CgOHjyIX3/9FdnZ2Vi/fj3eeustTJ06FcuWLVOCzJIkYd68eejbty+8vLxw8OBBtwI+xeV/L9xK313JyckOP2rZ7zuDwVBskBlw3L+enp5KkMcZd35UsD9eMjIykJOT4xBsdnX9YP99Gx4ejkWLFqFRo0bQ6/X45JNPMH78+BLX7cyRI0ccgsyTJk3Cc889h6CgIEiShODg4FL/8F27dm2EhIQgKSkJFosFH330EbKzs6HVatG8eXO0a9cOW7duxcaNG29aoLkizocbuUxn/8dt30ulVdb/4w888ADuu+8+/PPPP9i3bx+OHTuGtWvXYteuXcjMzMTo0aPRp0+fEr97bSri3Cnu/3hFXZNt377dod+AknTo0OGGBpr/+usvZbhx48YO//ts/RkA8md79OhRh3FERLcyBpqJqEJ8++23yM3NxdChQ4ukxfD09HR4X9yj0TeKh4cHGjRooNxk/fzzz5g2bZrSis0WhLSxPVpv67DKZtu2bUrQdtasWS5bx7Ru3RpLliwBIAcfHn/88SIX7Onp6Vi5cqVDR4r2NzOuWosVvuFxVq6s63fl8uXLynCfPn1QrVo1APKNvatHf8siLS3NoROhQYMGITIyEgBw6NAht1piOdOkSRO0bNkSW7duRXp6OmbMmKFMs0+bAcidVPn5+cHX1xc9e/ZUHsnv3r07Bg4cCABFHqF35vz581Cr1QgJCUHnzp3RuXNnAHD44SUxMRGXL19GQEBAmbbLpnXr1koAfseOHTh06JDyCH7hG3zbsX0jSJKEjz/+GDqdDu+99x4AeX926NABa9eudetx4K5du6JmzZo4fPgwVCqVW0EV++2/cOECHnrooSI3s7m5uVi4cCE6dOgAwPGYjouLwz333KO8/+mnn0pcZ2lU1DFVOJ3Pa6+9hp9//tnh5jQxMbFI6ztn7P8P79q1C/n5+dDpdDh06JBDoN9eWY5pjUajPCbu6n+V7YeqpKQk9O7d2yF9BACYzWb89ttvaNu2bYnbdSMVDgb99NNPmDp1KgC5tbHtf25p3Crn7v79+xEfH4/IyEiHVEpPPfWU8ti67Ri1P3d8fHzwwAMPKAGvij53SuO7775TOsBLT093OI7dCdDY79/MzEw0btxYOcZthBBYs2aNW//LCq/zhx9+UFK0JCQkKCkmCrPfv7bvLkBuOVvcj7olXT/YLxcAHnroIaUV+Jo1a8r8dFXHjh2V4PiHH34IQN52o9GIdu3aYdasWVi3bp1DGpDC+7U47lwX3U5atGjh8H9x1qxZ6NOnj8OPEGX5P37kyBGkpaXBx8cHFy9exNy5c53Oc+XKFWRkZCjpa2zfK1evXlWC4FlZWTh8+DCaNGkCoOTPoKLPHXsV9f15K7K/3t29ezcsFovSqrvwNhV+IoKI6FbGQDMRVYhTp05h2rRpmDhxItq1a4eGDRvCz88PycnJDq1zJEkqU4/fFWHSpEkYMWIEAODkyZNo0aIF7r33Xpw6dQrff/+9Uq558+bKhbePjw+qV6+utAyZMWMG9u7di7S0tGIDrP/973+xdOlSCCFw6NAh1K1bFwMHDkRgYCCuXLmC3bt3Y+PGjQgNDXVoLWH/yPDOnTvx1FNPISoqCjqdDk8++WSRMoCc1/aee+6BRqNBv379UKNGjTKv35X4+Hjs379f2QdJSUmQJAnfffddsfltSys4OBi+vr7KI8dPPfWU0sJmzpw5yM/PL/OyJ0yYoPROnpubC0B+hLRbt24O5ebPn48pU6agY8eOqF69OsLCwpCVlYUff/xRKePOjyUbNmzAsGHD0LZtW9SqVQvh4eGwWCz45ZdflDI6na5Cbh7GjRuHTz/9FPn5+bBarejQoQOGDx8Os9mMb775Rinn5eWFRx99tNzrK8n//vc/aLVazJo1C4CcMqd9+/ZYs2ZNiWkOJEnCggULcOLECXh5ebl1UzphwgR89tlnyMvLQ3JyMho0aIDBgwcjPDwc6enp2LdvH9avX4/MzEwlj6t969h9+/ZhyJAhqFu3LtatW6c8ylpRKuqYql+/Pnr06IHff/8dALBkyRI0btwYPXv2hFarxZ49e3Dw4EGcOHGixGU1bdoUv/76KwD5KZNmzZqhZs2a+P33312eZ2U5piMiIpTcrO+88w4uX74Mo9Go5AIdMWIEZsyYgcuXLyMvLw8tW7bE4MGDERsbi5ycHBw8eBDr1q3DlStXlIBDZWnRogXq16+v5DKePn06Tp48iSpVqmDBggVlyv96q5y7Tz/9NP755x906dIFUVFRCAoKwvnz55Ucx8D1Y9T+3ElNTUXPnj3Rrl077Ny5E4sXL75hdSzJSy+9hMOHDyM6Oho///yzw3fTmDFjSpy/T58+iI+Px5EjRwAAvXv3xn333YeaNWvCbDbj6NGjWLduHS5cuIC1a9ciNja22OX169cPQUFBSgB33Lhx2L59O/z8/DBv3jwUFBQ4nS8+Pl5JW7J8+XKMGTMGERERWL58ebG5pu2vDVJSUjBy5EjUrl0bkiRh/PjxqFatGlQqlfIkx0MPPYQHHngAFy5cKHVucXudOnVSrvNs+9z2o1Dbtm0hSRIyMjKU8jExMaVKF+HOddHtxN/fH6NHj8bnn38OQG5lW6dOHfTv3x/e3t44ePAglixZ4lb6EvsfM9LT09GkSRM0a9YM69atc/nDwdGjR9GqVSs0a9YMDRo0QHh4ODQaDVatWuVQzv47KSIiQnkacc6cOTAYDPD29kbVqlUxYMCACj937FXU9ycAjBgxQrkPqGgnTpzAp59+6nTaH3/8ofzQ0qxZM+W6u3379ti3bx+A6+nGevTogdOnTzv8UBAZGVnkB1gioltaZfRASER3Hvvezot7Pfvssw7zueoVWwghOnTooIwfPny4Mr64HriFKL53bPveq5294uLixKlTpxzm+fzzz52WbdiwoQgKCnK5rg8++MChZ3Jnr8I9w+/atUuoVKoi5Tw8PBzKNW7c2OnyFi5cWK71u/Ljjz86nT8sLEx069ZNeW/f63lZP6c33njDZe/bTZo0cXpMrF271qFs4c9QCCHy8/NFaGioQ7kXXnihSLnXX3+9xOP4/fffV8rbH/v2+9PVPrN/TZ482a39X9K+tK1Pr9e7XJeHh4dYsWKFwzyuzjF3Fd7vs2fPdpj+4osvFjleDh065HTeZcuWlbg++/KFz7eff/5ZGI3GEve5zeXLl0V4eLjTMsOHD3d5PBW3z1wdC6U9poqTkpLicB4Ud04Xd15cuHBB+Pn5FZlfr9eL9u3bV9gxPWnSJKflxo8fr5TZuHGj8Pf3L3HZ7n4ONsWdN64+q5L22/bt24Wnp6fT/da5c2flfWxsbEkfpcN+rchzt7htc6VHjx7F7nuDwSC2bdsmhJD/l9arV8+tc8d+n9tPs/+uKGl7XH1XFL5+6N27t9M69evXT1itVrf2z6FDh0SVKlVKPBad/Q92ZsmSJU6/h728vBy+x+33x7Fjx4SXl1eReTQajRg2bJjDOHsXLlwQJpPJaX1TUlKEEEKMHTvW6fQuXbqIiIgIp/u5JEeOHCmyvCVLlijT69at6zBt1KhRRZZR3LHhznVRcfMXd53pSnmuM92RnZ1d4jnnTl2ys7NF1apVi8wrSZLo2rWr0+Vt2bKlxON74MCBDvV9//33nZbr3bu3UqYs505xn5tNRX5/3kiFvzdcvez/v128eNHp52f/0uv1YtWqVZW3YUREZeCYfJSIqIwmTpyIn3/+GePGjUPz5s1RpUoVGI1G6HQ6REVFYeDAgVi+fDneeOONSq3n+++/j1WrVqF///4ICwuDRqOBp6cnmjZtihkzZmDXrl1FWtr85z//wSeffIIaNWpAq9UiMjISTz/9NDZu3FhsTrkJEyZgx44dGD16NKpVqwaDwQAPDw9Ur14d99xzD95//31s2LDBYZ6GDRvixx9/ROPGjR06pyps0aJFGDBgAPz9/V3mCizL+l154IEHsGDBAjRo0ABarRYBAQEYMmQItm7divDwcLeW4a5nn30WH3/8sbK/Q0NDMWbMGKxfv75IGpbS0Gq1RXo0L5w2A5BzNr/yyivo2rUrYmJiYDKZoNFoEBYWht69e2Pp0qVutaJq27YtXnvtNfTu3RtVq1aFl5cXNBoNgoKC0KVLF8yZMwdvv/12mbensAceeAC7du3CmDFjULVqVRgMBhgMBtSoUQPjx4/H3r17lUdOb5YZM2YoqQUAOa1Fx44dceDAgQpf13333Yd9+/bhySefRO3ateHh4QGDwYC4uDh06tQJr7/+Og4fPqyU9/f3x99//42BAwfC29sbRqMRzZo1wy+//FLhLZ4q6pgC5A73Nm/ejM8//xydO3dGQEAANBoN/P390aJFC4wbN86t5YSGhmLdunXo1q0bTCYTvLy80KtXL2zZssVl/tSyHNOvvfYannzySURERDjt6Mm23AMHDuD5559Ho0aN4OXlBZ1OhypVqqBNmzZ4+eWXsXPnzgrrNKs8mjZtis2bN6N3797w9PSEp6cnunTpgg0bNqB69epKudKkiLoVzt1nnnkGTz31FFq2bImIiAjodDro9XrExcVh+PDh+Oeff9C8eXMA8v/SNWvWYMSIEQgICIBer0fdunXxxRdfOJzvN9svv/yC6dOno2rVqtDpdIiJicG0adOwcOFCt3Pq1qxZE3v37sXMmTPRokUL+Pj4QKvVIiIiAi1atMB///tfbNy4Ee3bt3dref369cOff/6J9u3bw2g0wtfXF/feey+2bduGevXqOZ2nWrVq2LBhA7p37w6TyQRPT0906NABf/31F7p27epyXaGhoVi2bBnatGnjMrfuhx9+iOnTpyM6OhparRZVqlTBM888g2XLlpU5N3aNGjUcWh1LkuSQ5qddu3YO5Uubn9nd66LbidFoxMqVK/Hjjz+iV69eCAkJgVarhY+PDxo2bOhWZ5C25fz111/K95jJZEL79u3x559/YtiwYU7niY+PxzvvvIOBAweiRo0a8PHxgVqthp+fH9q0aYP333+/SAqc8ePHY+rUqYiLi3N5nFT0uWNTkd+ft5qQkBD8+++/eO2119CyZUv4+flBrVbDZDIhPj4eY8eOxZ49e9CjR4/KrioRUalIQpSx+10iIqLbzI8//oihQ4cCkG9+3Q20ExEBQH5+PjQaTZGOYjMzM1G3bl0lTciYMWPwxRdfVEYV7xpz5sxx+LGQtzRERERElY85momI6I6WmpqK3bt34+LFi3jxxReV8e50MkdEZO/gwYPo168fhg0bhtq1a8PPzw8JCQn49NNPlSCzu51YEhERERHdaRhoJiKiO9ru3buLPKrbpk0bDBo0qJJqRES3szNnzrhMA6XT6fDpp5+iQYMGN7lWRERERESVj4FmIiK6K0iShNDQUNx7772YOXNmkUffiYhKEhUVhUmTJmHdunU4ffo00tLSYDAYEBsbi44dO2LcuHGoWbNmZVeTiG4yd8775s2bY+7cuTehNkRERJWHOZqJiIiIiIiIysidDic7dOiAdevW3fjKEBERVSK2aCYiIiIiIiIqI7bdIiIikvG5YSIiIiIiIiIiIiIqFwaaiYiIiIiIiIiIiKhcGGgmIiIiIiIiIiIionJhoJmIiIiIiIiIiIiIyoWBZiIiIiIiIiIiIiIqFwaaiYiIiIiIiIiIiKhcGGgmIiIiIiIiIiIionJhoJmIiIiIiIiIiIiIyoWBZiIiIiIiIiIiIiIqFwaaiYiIiIiIiIiIiKhcGGgmIiIiIiIiIiIionJhoJmIiIiIiIiIiIiIyoWBZiIiIiIiIiIiIiIqFwaaiYiIiIiIiIiIiKhcGGgmIiIiIiIiIiIionJhoJmIiIiIiIiIiIiIyoWBZiIiIiIiIiIiIiIqFwaaiYiIiIiIiIiIiKhcGGgmIiIiIiIiIiIionJhoJmIiIiIiIiIiIiIyoWBZiIiIiIiIiIiIiIqFwaaiYiIiIiIiIiIiKhcGGgmIiIiIiIiIiIionJhoJmIiIiIiIiIiIiIyoWBZiIiIiIiIiIiIiIqFwaaiYiIiIiIiIiIiKhcGGgmIiIiIiIiIiIionJhoJmIiIiIiIiIiIiIyoWBZiIiIiIiIiIiIiIqFwaa6ZYlSZJbr3Xr1mHdunWQJAk///xzZVcbc+bMgSRJSEhIUMaNGDECMTExDuUkScITTzxxcytXSitWrMDUqVOdTps5cyYWL158U+tjLyEhAZIkYc6cOaWe9+DBg5g6darDZ1SS+fPno06dOjAajZAkCbt37y71eiuifh07dkTdunVv2Lorg7Pz43ZSnmPRHefPn8fUqVNv6DFHRER0O7ld7xMAKPVZt25dZVcFkiQ5XOvf6Lpt3rwZU6dORWpqapFpHTt2RMeOHW/IeitKQkICevfuDX9/f0iShIkTJ7os6+peyXavuGPHjhtXUTfd7dew5b0HiYmJwYgRI0o9X3Z2NqZOnXpL/A8guhEYaKZb1pYtWxxevXr1gtFoLDK+cePGlV1VB71798aWLVsQFhZW2VUptxUrVmDatGlOp1V2oLk8Dh48iGnTprkdaE5JScHDDz+MqlWrYtWqVdiyZQtq1Khxy9Tvdvfyyy/j119/rexq3LLOnz+PadOm3bIX6URERDfb7XqfAACNGze+a+u2efNmTJs2zWmg+ZNPPsEnn3xyQ9ZbUSZNmoRt27bhm2++wZYtWzBp0iSXZW/ne6WKwmtY57KzszFt2jQGmumOpansChC50rJlS4f3QUFBUKlURcbfaoKCghAUFFTZ1aAKdPToURQUFOChhx5Chw4dKmSZ2dnZMJlMFbKs25VtH1StWrWyq3JXysnJgcFggCRJlV0VIiKiUrld7xMAwNvb+5atZ2XWrXbt2pWy3tLYv38/mjdvjv79+1d2Ve5qvIYlurWxRTPdUQoKCvDiiy8iPDwc3t7e6Nq1K44cOVKk3J9//okuXbrA29sbJpMJbdq0wV9//VXi8q1WK2bMmIH4+HgYjUb4+vqifv36eP/995UyzlJnFOe7775DrVq1YDKZ0KBBA/z2229Fyvz999/o0qULvLy8YDKZ0Lp1ayxfvtyhzNSpU51+2bqqz/z589GqVSt4eHjA09MTPXr0wK5du5TpI0aMwMcffwzA8fFE2yNWWVlZ+Pbbb5Xx9o+6Xbx4EY899hgiIyOh0+kQGxuLadOmwWw2l7g/YmJi0KdPH/z666+oX78+DAYD4uLi8MEHH5Q4rzv7as6cORg0aBAAoFOnTkr9XT0yNmLECLRt2xYAMGTIkCLbunTpUrRq1QomkwleXl7o1q0btmzZ4rAM22fz77//4v7774efn5/L4Kq79du+fTvatWsHk8mEuLg4vPHGG7BarQ5l0tPT8fTTTyM2NhY6nQ4RERGYOHEisrKyit2HEydOhIeHB9LT04tMGzJkCEJCQlBQUABAPo66d++OsLAwGI1G1KpVC88991yRdYwYMQKenp7Yt28funfvDi8vL3Tp0kWZVvixtdzcXDz//PMOdR8/fnyRFjCFH/m0KfwoW3Z2trIvDAYD/P390bRpU/z444/F7gsAOHfuHP7zn/8gKioKOp0O4eHhuP/++5GUlORyHleP4jk7TxcuXIgWLVrAx8dH+TxHjRoFQH6EtVmzZgCAkSNHKseD/Tbv2LED/fr1g7+/PwwGAxo1aoQFCxY4rMP2f+CPP/7AqFGjEBQUBJPJhLy8PKSkpCjbp9frERQUhDZt2uDPP/8scd8QERHdLm7kfUJKSgp0Oh1efvnlItMOHz4MSZKUa1ln6SlOnjyJBx54AOHh4dDr9QgJCUGXLl0cWoK6e82TkpKCcePGoXbt2vD09ERwcDA6d+6MjRs3Fr+DnNTNdt3v6mWzevVq3HvvvYiMjITBYEC1atXw2GOP4dKlS0qZqVOn4plnngEAxMbGOqQ3AZynzrhy5QrGjRuHiIgI6HQ6xMXF4cUXX0ReXp5DOVtKQnfuq5w5ffo0HnroIQQHB0Ov16NWrVp45513lGtr2345fvw4Vq5c6XBf5ExJ90oAkJGRgccffxyBgYEICAjAwIEDcf78+SLLKumerTh3+jVsafbPnDlzEB8fr3y+c+fOdWsfAvL/jv/7v/9DaGgoTCYT2rZti3/++adIOXfOvYSEBKVR2rRp05T9YjuHjx8/jpEjR6J69eowmUyIiIhA3759sW/fPrfrS1TZGGimO8oLL7yAxMREfPXVV/jiiy9w7Ngx9O3bFxaLRSkzb948dO/eHd7e3vj222+xYMEC+Pv7o0ePHiVeRL711luYOnUqHnzwQSxfvhzz58/H6NGjnT7+5Y7ly5fjo48+wvTp07Fo0SL4+/tjwIABOHnypFJm/fr16Ny5M9LS0vD111/jxx9/hJeXF/r27Yv58+eXab0zZ87Egw8+iNq1a2PBggX47rvvkJGRgXbt2uHgwYMA5HQG999/PwDHxxPDwsKwZcsWGI1G9OrVSxlve9Tt4sWLaN68OX7//Xe88sorWLlyJUaPHo3XX38dY8aMcat+u3fvxsSJEzFp0iT8+uuvaN26NZ566im8/fbbxc7nzr7q3bs3Zs6cCQD4+OOPlfr37t3b6TJffvllJeA+c+ZMh2394YcfcO+998Lb2xs//vgjvv76a1y9ehUdO3bE33//XWRZAwcORLVq1bBw4UJ89tlnTtfnTv0uXryIYcOG4aGHHsLSpUvRs2dPPP/885g3b55SJjs7Gx06dMC3336LJ598EitXrsSzzz6LOXPmoF+/fhBCuNyPo0aNQnZ2dpELvdTUVCxZsgQPPfQQtFotAODYsWPo1asXvv76a6xatQoTJ07EggUL0Ldv3yLLzc/PR79+/dC5c2csWbLEZVoWIQT69++Pt99+Gw8//DCWL1+OyZMn49tvv0Xnzp2L3Fy4Y/Lkyfj000/x5JNPYtWqVfjuu+8waNAgXL58udj5zp07h2bNmuHXX3/F5MmTsXLlSrz33nvw8fHB1atXS12PwrZs2YIhQ4YgLi4OP/30E5YvX45XXnlF+VGmcePGmD17NgDgpZdeUo6HRx99FACwdu1atGnTBqmpqfjss8+wZMkSNGzYEEOGDHH648moUaOg1Wrx3Xff4eeff4ZWq8XDDz+MxYsX45VXXsEff/yBr776Cl27di1x3xAREd1ObuR9QlBQEPr06YNvv/22yA//s2fPhk6nw7Bhw1zO36tXL+zcuRNvvfUWVq9ejU8//RSNGjUq0z3GlStXAABTpkzB8uXLMXv2bMTFxaFjx46lflTfdt1v/1q6dCm8vb1Rq1YtpdyJEyfQqlUrfPrpp/jjjz/wyiuvYNu2bWjbtq3SOOHRRx/FhAkTAAC//PJLielNcnNz0alTJ8ydOxeTJ0/G8uXL8dBDD+Gtt97CwIEDi5R3577KmZSUFLRu3Rp//PEHXn31VSxduhRdu3bF008/rfSnY0spEhoaijZt2jjcFzlT3L2SzaOPPgqtVosffvgBb731FtatW4eHHnrIoYw792yu3A3XsO7unzlz5mDkyJGoVasWFi1ahJdeegmvvvoq1qxZ49a2jhkzBm+//TYeeeQRLFmyBPfddx8GDhxYZD+6c+6FhYVh1apVAIDRo0cr+8X2I9X58+cREBCAN954A6tWrcLHH38MjUaDFi1aOP1hjOiWJIhuE8OHDxceHh5Op61du1YAEL169XIYv2DBAgFAbNmyRQghRFZWlvD39xd9+/Z1KGexWESDBg1E8+bNi61Dnz59RMOGDYstM3v2bAFAnDp1yqHu0dHRDuUAiJCQEJGenq6Mu3jxolCpVOL1119XxrVs2VIEBweLjIwMZZzZbBZ169YVkZGRwmq1CiGEmDJlinB2Sheuz+nTp4VGoxETJkxwKJeRkSFCQ0PF4MGDlXHjx493ukwhhPDw8BDDhw8vMv6xxx4Tnp6eIjEx0WH822+/LQCIAwcOOF2eTXR0tJAkSezevdthfLdu3YS3t7fIysoSQghx6tQpAUDMnj1bKePuvlq4cKEAINauXVtsXWxsx9fChQuVcRaLRYSHh4t69eoJi8WijM/IyBDBwcGidevWyjjbZ/PKK6+4tb7i6tehQwcBQGzbts1hfO3atUWPHj2U96+//rpQqVRi+/btDuV+/vlnAUCsWLGi2Do0btzYYRuEEOKTTz4RAMS+ffuczmO1WkVBQYFYv369ACD27NmjTBs+fLgAIL755psi8xU+P1atWiUAiLfeesuh3Pz58wUA8cUXXyjjAIgpU6YUWWZ0dLTD8Vm3bl3Rv3//4jbZqVGjRgmtVisOHjzosoyzY9HZOS9E0fPUdl6kpqa6XP727duLLN+mZs2aolGjRqKgoMBhfJ8+fURYWJhybNr+DzzyyCNFluHp6SkmTpzocv1ERES3ulvhPmHp0qUCgPjjjz+UcWazWYSHh4v77ruvSH1s13mXLl0SAMR7771X7PLdveYpzGw2i4KCAtGlSxcxYMCAYpdZuG6FZWVliebNm4uwsDCRkJDgtIztejAxMVEAEEuWLFGmzZo1q8h9kk2HDh1Ehw4dlPefffaZACAWLFjgUO7NN98ssp/dva9y5rnnnnN6bf34448LSZLEkSNHlHHR0dGid+/exS7PxtW9ku2abNy4cQ7j33rrLQFAXLhwQQhRuns2Z+70a1h394/tnq1x48bKvaAQQiQkJAitVut0W+0dOnRIABCTJk1yGP/9998LAGU691JSUlyez86WkZ+fL6pXr16kDkS3KrZopjtKv379HN7Xr18fAJCYmAhA7oDiypUrGD58OMxms/KyWq245557sH379mLTCjRv3hx79uzBuHHj8PvvvztNLVAanTp1gpeXl/I+JCQEwcHBSn2zsrKwbds23H///fD09FTKqdVqPPzwwzh79mypf9n8/fffYTab8cgjjzjsA4PBgA4dOpS7U4LffvsNnTp1Qnh4uMPye/bsCUBudVySOnXqoEGDBg7jhg4divT0dPz7779O57kR+6o4R44cwfnz5/Hwww9Dpbr+r9TT0xP33Xcftm7diuzsbId57rvvvgpZd2hoKJo3b+4wrn79+spxA8ifQ926ddGwYUOHz6FHjx5u9SY+cuRIbN682WGfzZ49G82aNUPdunWVcSdPnsTQoUMRGhoKtVoNrVar5LE+dOhQkeW6sw9srQsK9+I8aNAgeHh4uJXmprDmzZtj5cqVeO6557Bu3Trk5OS4Nd/KlSvRqVMnh1Y7Fcn2SOHgwYOxYMECnDt3zu15jx8/jsOHDystpOw/5169euHChQtFjnln+7958+aYM2cOZsyYga1btyotj4iIiO4kN/o+oWfPnggNDVVacQLydff58+eVdALO+Pv7o2rVqpg1axbeffdd7Nq1q0ir6NL67LPP0LhxYxgMBmg0Gmi1Wvz1119Or83cZbFYMGTIEBw6dAgrVqxAdHS0Mi05ORljx45FVFSUsj7b9LKuc82aNfDw8FCesLSxXR8Wvh4s6b6quPXUrl27yLX1iBEjIIRwu9VraZV0PJb3nu1Ov4Z1d//Y7tmGDh3qkPojOjoarVu3LrGua9euBYAiTyQMHjwYGk3RLs/Ke+6ZzWbMnDkTtWvXhk6ng0ajgU6nw7Fjx8p1/hLdTAw00x0lICDA4b1erwcAJahky0d1//33Q6vVOrzefPNNCCGUR16cef755/H2229j69at6NmzJwICAtClSxfs2LGjQuprq7OtvlevXoUQwuljWeHh4QBQ6sfbbfugWbNmRfbB/PnzHXKplUVSUhKWLVtWZNl16tQBALeWHxoa6nKcq+29EfuqOLZluVqf1Wot8jiVq8frSquk4waQP4e9e/cW+Ry8vLwghCjxcxg2bBj0er3y6NrBgwexfft2jBw5UimTmZmJdu3aYdu2bZgxYwbWrVuH7du345dffgGAIsFck8kEb2/vErfv8uXL0Gg0RTrVlCQJoaGhZfocP/jgAzz77LNYvHgxOnXqBH9/f/Tv3x/Hjh0rdr6UlBRERkaWen3uat++PRYvXqxcKEdGRqJu3bpu5Y62nctPP/10kc953LhxAIqeb86Owfnz52P48OH46quv0KpVK/j7++ORRx7BxYsXK2ALiYiIbg03+j5Bo9Hg4Ycfxq+//qqkvJgzZw7CwsLQo0cPl/NJkoS//voLPXr0wFtvvYXGjRsjKCgITz75JDIyMkq9ne+++y4ef/xxtGjRAosWLcLWrVuxfft23HPPPW7/0O7M2LFjsWrVKvz8889o2LChMt5qtaJ79+745Zdf8H//93/466+/8M8//2Dr1q0Ail4Puuvy5csIDQ0tkhc4ODgYGo2myPWgO9fHrtZzs+4f7Ll7PJb1nu1Ov4Z1d//YPr/i7i+L42p+jUZT5DOsiHNv8uTJePnll9G/f38sW7YM27Ztw/bt29GgQYNynb9EN1PRn2CI7mCBgYEAgA8//NBlj8ohISEu59doNJg8eTImT56M1NRU/Pnnn3jhhRfQo0cPnDlzBiaTqULr6+fnB5VKhQsXLhSZZusswrZNBoMBAJCXl6dcqABFv6Rt5X/++WeHlggVJTAwEPXr18drr73mdLrtoq04zgJctnHOLiKB0u2rimCrh6v1qVQq+Pn5OYy/mT0jBwYGwmg04ptvvnE5vTh+fn649957MXfuXMyYMQOzZ8+GwWDAgw8+qJRZs2YNzp8/j3Xr1imtmAG4zCfo7vYHBATAbDYjJSXFIdgshMDFixeVFhSAfFHuLGdz4ZsCDw8PTJs2DdOmTUNSUpLSurlv3744fPiwy7oEBQXh7NmzbtXbnsFgcFovZzcF9957L+69917k5eVh69ateP311zF06FDExMSgVatWLtdh+wyff/55p7kKASA+Pt7hvbPPIDAwEO+99x7ee+89nD59GkuXLsVzzz2H5ORkJYccERHRna689wmA/ETYrFmz8NNPP2HIkCFYunQpJk6cCLVaXex80dHR+PrrrwEAR48exYIFCzB16lTk5+cr/Xq4e80zb948dOzYEZ9++qnD+LIErW2mTp2Kr776CrNnz0b37t0dpu3fvx979uzBnDlzMHz4cGX88ePHy7w+QL4e3LZtG4QQDtcvycnJMJvNFXZdHxAQcNPuH0qjvPdsd/o1rLv7x3bPVtz9ZXHs54+IiFDGm83mG3LuzZs3D4888ojSZ4/NpUuX4Ovr6/ZyiCoTA810V2nTpg18fX1x8OBBpXOHsvL19cX999+Pc+fOYeLEiUhISEDt2rUrqKYyDw8PtGjRAr/88gvefvttGI1GAHLLgXnz5iEyMhI1atQAAKV34L179zoE4pYtW+awzB49ekCj0eDEiRMlpjGw/2Xdtm77ac5+Ve3Tpw9WrFiBqlWrFgm0uuvAgQPYs2ePQ/qMH374AV5eXi47DCnNvircYqAs4uPjERERgR9++AFPP/20cvGTlZWFRYsWoVWrVmX+4aEi6tenTx/MnDkTAQEBiI2NLdMyRo4ciQULFmDFihWYN28eBgwY4HCBY9tm+x82AODzzz8vc70BoEuXLnjrrbcwb948TJo0SRm/aNEiZGVloUuXLsq4mJgY7N2712H+NWvWIDMz0+XyQ0JCMGLECOzZswfvvfcesrOzXX5WPXv2xHfffYcjR44UueAtTkxMDJKTk5GUlKTclObn5+P33393OY9er0eHDh3g6+uL33//Hbt27UKrVq1cHg/x8fGoXr069uzZU+RitKyqVKmCJ554An/99Rc2bdpUIcskIiK6HVTEfUKtWrXQokULzJ49GxaLBXl5eQ5Pg7mjRo0aeOmll7Bo0SKHlHHuXvNIklTk2mzv3r3YsmULoqKiSrlFwNdff41p06Zh+vTpRdKa2dYHuHc9WJpr3C5dumDBggVYvHgxBgwYoIyfO3euMr0idOnSBa+//jr+/fdfh/uMuXPnQpIkdOrUqUzLdac1dXFKc8/mzJ1+Devu/omPj0dYWBh+/PFHTJ48WTleExMTsXnz5hIbQXXs2BEA8P3336NJkybK+AULFigdH9q4e+4Vdx44W8by5ctx7tw5VKtWrdi6Et0qGGimu4qnpyc+/PBDDB8+HFeuXMH999+P4OBgpKSkYM+ePUhJSSnyC6S9vn37om7dumjatCmCgoKQmJiI9957D9HR0ahevfoNqfPrr7+Obt26oVOnTnj66aeh0+nwySefYP/+/fjxxx+VL8tevXrB398fo0ePxvTp06HRaDBnzhycOXPGYXkxMTGYPn06XnzxRZw8eRL33HMP/Pz8kJSUhH/++Udp+QkA9erVAwC8+eab6NmzJ9RqNerXrw+dTod69eph3bp1WLZsGcLCwuDl5YX4+HhMnz4dq1evRuvWrfHkk08iPj4eubm5SEhIwIoVK/DZZ5+V+BhXeHg4+vXrh6lTpyIsLAzz5s3D6tWr8eabbxYbvHV3X9lyDH/xxRfw8vKCwWBAbGysy9bSzqhUKrz11lsYNmwY+vTpg8ceewx5eXmYNWsWUlNT8cYbb7i9rMIqon4TJ07EokWL0L59e0yaNAn169eH1WrF6dOn8ccff+C///0vWrRoUewyunfvjsjISIwbNw4XL14scqPUunVr+Pn5YezYsZgyZQq0Wi2+//577Nmzp/Qbbadbt27o0aMHnn32WaSnp6NNmzbYu3cvpkyZgkaNGuHhhx9Wyj788MN4+eWX8corr6BDhw44ePAgPvroI/j4+Dgss0WLFujTpw/q168PPz8/HDp0CN99912JPwhMnz4dK1euRPv27fHCCy+gXr16SE1NxapVqzB58mTUrFnT6XxDhgzBK6+8ggceeADPPPMMcnNz8cEHHzj0bA8Ar7zyCs6ePYsuXbogMjISqampeP/99x1yXVetWhVGoxHff/89atWqBU9PT4SHhyM8PByff/45evbsiR49emDEiBGIiIjAlStXcOjQIfz7779YuHBhsfs6LS0NnTp1wtChQ1GzZk14eXlh+/btWLVqlUMLk+nTp2P69On466+/HFqvExER3SnKe59gM2rUKDz22GM4f/48WrduXWKQb+/evXjiiScwaNAgVK9eHTqdDmvWrMHevXvx3HPPKeXcvebp06cPXn31VUyZMgUdOnTAkSNHMH36dMTGxhYJjJVky5YtGDt2LNq0aYNu3bop6TBsWrZsiZo1a6Jq1ap47rnnIISAv78/li1bhtWrVxdZnu3e4v3338fw4cOh1WoRHx/vkFvZ5pFHHsHHH3+M4cOHIyEhAfXq1cPff/+NmTNnolevXujatWuptsWVSZMmYe7cuejduzemT5+O6OhoLF++HJ988gkef/xxpaFKabm6V3JXae7ZnLnTr2Hd3T8qlQqvvvoqHn30UQwYMABjxoxBamoqpk6d6lbqjFq1auGhhx7Ce++9B61Wi65du2L//v14++23i6QEdPfc8/LyQnR0NJYsWYIuXbrA398fgYGBiImJQZ8+fTBnzhzUrFkT9evXx86dOzFr1iyn988ajQYdOnQoU/81RDdUpXVDSFRK7vQmvXDhQofxznrSFUKI9evXi969ewt/f3+h1WpFRESE6N27d5H5C3vnnXdE69atRWBgoNDpdKJKlSpi9OjRDr0u23rGte9N2VnvvQDE+PHji6zDWc/RGzduFJ07dxYeHh7CaDSKli1bimXLlhWZ959//hGtW7cWHh4eIiIiQkyZMkV89dVXTnt3Xrx4sejUqZPw9vYWer1eREdHi/vvv1/8+eefSpm8vDzx6KOPiqCgICFJksNydu/eLdq0aSNMJpMA4NBLdEpKinjyySdFbGys0Gq1wt/fXzRp0kS8+OKLIjMzs9h9bOvN+eeffxZ16tQROp1OxMTEiHfffdehnKvP1t199d5774nY2FihVqtd9oZs4+r4su3HFi1aCIPBIDw8PESXLl3Epk2bHMrYemlOSUkpdtvdqV+HDh1EnTp1ipR3doxlZmaKl156ScTHxwudTid8fHxEvXr1xKRJk8TFixfdqscLL7wgAIioqCil92d7mzdvFq1atRImk0kEBQWJRx99VPz7779Oe7B2df46q3tOTo549tlnRXR0tNBqtSIsLEw8/vjj4urVqw7l8vLyxP/93/+JqKgoYTQaRYcOHcTu3buLnEfPPfecaNq0qfDz8xN6vV7ExcWJSZMmiUuXLpW4D86cOSNGjRolQkNDhVarFeHh4WLw4MEiKSlJCOH6WFyxYoVo2LChMBqNIi4uTnz00UdFeuz+7bffRM+ePUVERITQ6XQiODhY9OrVS2zcuNFhWT/++KOoWbOm0Gq1RXqp3rNnjxg8eLAIDg4WWq1WhIaGis6dO4vPPvtMKWP7v7R9+3aH5ebm5oqxY8eK+vXrC29vb2E0GkV8fLyYMmWKyMrKUsrZ6u2qF3oiIqLKdCvcJ9ikpaUJo9EoAIgvv/zSZX1s36lJSUlixIgRombNmsLDw0N4enqK+vXri//973/CbDYr87l7zZOXlyeefvppERERIQwGg2jcuLFYvHixy/sR+2uKwnWzXT+4etkcPHhQdOvWTXh5eQk/Pz8xaNAgcfr06SLLF0KI559/XoSHhwuVSuWwrg4dOjjcTwghxOXLl8XYsWNFWFiY0Gg0Ijo6Wjz//PMiNze3yHa4e1/lTGJiohg6dKgICAgQWq1WxMfHi1mzZhW59rXdp7jD1b2Sq2uywvvexp17Nlfu5GvY0u6fr776SlSvXl3odDpRo0YN8c033zg9J5zJy8sT//3vf0VwcLAwGAyiZcuWYsuWLeU69/7880/RqFEjodfrBQBlOVevXhWjR48WwcHBwmQyibZt24qNGzc6PT8K34MT3SokIYS4MSFsIqLSi4mJQd26dfHbb79VdlWIiIiIiIiIiMhNqsquABERERERERERERHd3hhoJiIiIiIiIiIiIqJyYeoMIiIiIiIiIiIiIioXtmgmIiIiIiIiIiIionJhoJmIiIiIiIiIiIiIyoWBZiIiIiIiIiIiIiIqF01lrNRqteL8+fPw8vKCJEk3dd2bNm3CBx98gN27d+PixYv4/vvv0adPH2W6j4+P0/mmT5+Op5566mZVk4iIiOi2JIRARkYGwsPDoVKxTcPdojKv74mIiIjoxnL3Gr9SOgM8e/YsoqKibvZqiYiIiOgmOXPmDCIjIyu7GnST8PqeiIiI6M5X0jV+pbRo9vLyAiBXztvbuzKqAEBuvVy4RXNhQ4cORUZGBpYtW1bq5R/v0QPmlBSoAwPLXEfJakXosWMAgIvVq0OwZRARlZcQEHl5sKSlwZqbC1itUHl4QKXTASoVJIMBKqMRkkoFqNXyOI0Gkk4HlckESauFytNTnq5SQaXXy+VNJqi9veH3wANQ6fWVvZVEVEnS09MRFRWlXO/R3eFWub4nIiIioorn7jV+pQSabY/TeXt7V/qFqMlkclmHpKQk/P777/j222/LVE9PjQYiIACaoKAy108ymxG+fTsAIDcgAEJTKR8ZEd1mhBAQubkQeXkQZjNEXh6s2dmAJAFCQNLpoI6Ohr5aNehjY6GvXh3aiAiojEZoAgKgrVKFjz4TUbnwf8jd5Va6viciIiKiG6Oka3xGLYvx7bffwsvLCwMHDqzsqhARuSSEgMjJgTU7G5aMDKCgAADkFshGIySdDprwcBjq1IE2IgLasDDo4+Kgr1kTag+PSq49EREREREREd0JGGguxjfffINhw4bBYDBUdlWIiOSAcl4eRH6+3Eo5NxfWzEwIqxUqkwlqT094NGsGQ61aUPv7w1C7NvRVq0Lt7Q2V0VjZ1SciIiIiIiKiOxgDzS5s3LgRR44cwfz58yu7KkR0lxL5+bDm5MCakQFLdjYkSYKk1UIyGCBpNFD7+cGjdWuYGjWCvmZNmBo1YkCZiIiIiIiIiCoFA80ufP3112jSpAkaNGhQ2VUhojuYEAIiOxvW7GwlsAwAkCQ5sGwyQeXtDX3NmvBo0QLGBg2gr1YNal9fuUM+5kAlIiIiIiIiolvAXRdozszMxPHjx5X3p06dwu7du+Hv748qVaoAkHtSXLhwId55553KqiYR3aGExQJLejqs6ekQeXlyQNlggNrTE2pvb+iio2Fs3BgaPz9ogoOhj4+HNiwMkkpV2VUnIiIiIiIiInLprgs079ixA506dVLeT548GQAwfPhwzJkzBwDw008/QQiBBx98sDKqSES3OSGEnD85NxcoKIA1N1cOKgMQBQXQBARAFxMDU7NmMNatC33VqtDXqAEV88ETERERERER0W1KEkKIm73S9PR0+Pj4IC0tDd7e3jd79TfN0XbtIPLzoQkOruyqEFEFU4LJOTkQBQVKB30wmwEAklYLlYcHJJ0O2vBw6KKjoatSBSoPD3i0aQN9tWpMe0FEd6S75TqPHPFzJyIiIrpzuXutd9e1aCYiKg1htULk5UEUFMB86RJEfj4ktRoQApLBAJXRCLWHBzRVq0ITGCi3Vo6Lgy4iAob69aEJCGDaCyIiIiIiIiK64zHQTER3LWGxKK2QbekthNkMCCGnulCpIMxmqEwmSFotNIGB0FetCkOtWtDFxsJQowa0UVFQ+/qydTIRERERERER3dUYaL7FSRYLgnfvBgAkN2wIoVZXboWIbgNCCMBsllNamM0QFsv19xYLRG4uIASgUkHSaiGp1ZCMRmiCg+UWyHo9NP7+0MfHQxMUBE1QEHQREdBGREDS8N8mEREREREREVFhjJjc6oSA54ULAIDkBg0quTJElUNYrXKQ+FoKCwgh50S+FjiG1QpYLMC1lBYA5PQWWu31QLJGA42/PyQPDxhq14a+ShXo4uKg9vGBysMD2shIqD08KnlLiYiIiIiIiIhuTww0E9FNJaxWOT2FxaIEiYXZ7JC2AkIo4yFJcj5kne76S6WCJiwMmsBAqP38IBmNUHt6QhcVBZW3N1Qmk5zuQqeDLiJCnu7lxdbIREREREREREQ3CKMuRCSnmrAP/Fos199bLBBWq9xq+FprYfu/wjbefty15QGQA8W2/MXXyklaLaBWy62OVSpIajXUvr7QBAVBpdfL07RaaCMjoY+OhtrfH9rQUCWNhTI/8yITEREREREREd0SGGgmKgNhC6oWnXD9b6FhpeM5+3KF57EbJ2zjrgV5hW3YNt0W/LVY5GmF1217bwv0XmsZ7LLeKpXc4lelgmQbvpZyQmVLQaHTASoVIEmQVCpApYLKaISk18tB42vBY0mjgcrbGxp/f7nF8bWAsspggMrTU05hca0VsqTXQ2U0QuXtzcAxEREREREREdFtqlIDzcnvv48cg8H5RGcBMVdBMsAx0Fao5aUyzdYy053lO5kuXAQEiyzDblzBhQvOg4vON6LoOFurUAD558657gywpGWXtWxp5nNjuihcrnCA1Pa3cMDRVQCycPDU9t7+b+Fl2gdg7etReFmFg7WFt6+4OknS9aCpLchrC97at/AFHMs5W45KBWg0UOl0kDQauTXvtaCtpNdD5ekpp5O4lovYFhyW1Gp5/LV5JL1eCRbbpitBZa0Waj8/ZVkqgwEqDw+oPD3lQDI7oSQiIiIiIiIiomJUaqA58++/5aAZUPbgpzO2gKb9cp0FiV3M6+46XE669td65gxUmZkQeXnyiGJaa7pqySnZAuMApKQk94OdxSi21WjhoKeLIKjTZUgStHXrQh0ZKbd6tc13raxkawmrVsvjbKkTbIHRay1kJZXq+jS71riSfctcu2UXO962XCdllG0oFHR1CAqrVI7bWng9duMdymk0DttkCwyrfXzkbStUpyJ1vLafJLVaXpZWy9a+RERERERERER0y6rUQHPURx/B28tLfuMicOkuyUlgUwnglXJZFeXSPfdACAFVYKA8wpZCwZbuID8fsHWKZjbLwzaSBGi1UNnqD8DXxwfQ6a4HIjUa4Fp6AyWdgf38hV/2wVtbYNOurFt7qHArXfvAqNEInzffhDoiopx7joiIiIiIiIiIiG4nlRpo1oaEQOvtXZlVKBMhBERODpCbC5GXB2tGBkRqKqxpaUBBAcwJCRCZmVBpNDCbzbBmZwNWq9wi1RbgVauh8vFRAsUqb2+ofH0hGQyQPD3l/LVRUUBBAbJ9fCBptfAJDYXKy0ueR6OBysMDkrc3JA+P67lzr6U4YOtXIiIiIiIiIiIiulnYGaATIicH1itX5AByZiasqamwXroEy+nTMJ88CfOxY3Kg2WK53hlbQQFQUCDPD8jTVCroGjeGYcAASCYTVH5+clBYo4FkNELy8YHK318exxy4REREREREREREdJu66wLNIj8f1qtXIdLTYc3KklslZ2fDfOwYCvbtgzkxEeLqVTmvstl8PaXFtbzPkloNyWSSc0vbtSJWabVAoTy6BUePwuOJJ2Do0aPyNpiIiIiIiIjoLpJ/7hxSFy6E2tsbfkOHQmUwVHaViIjuCndkoFlYrbAmJ8N84gTyt22DJTER1qtXYb18GZsSE/Hx2bPYm5WFJLMZs6Oi0NPTE8JiUTqmO6ZWY8aZM9iclgYrgJpeXvi6SRNEGo03f2Py8oDHHpOHP/8c0Otvfh2IiIiIiIiIbhMXp05FwcWLAABrTg6Cxo+v5BoREd0dbttAsxAC1suX5deFCzAfP668rMnJENdaKouCArnTPLUaklaLbLMZdb298WBUFEbt3w9VQADUYWFK6opTWVno9/ffGBYVhWfr1IG3RoOjmZnQ23XKd1OZzcC338rDH3/MQDMRERERERGRC0IImFNSlPfmpKRKrA0R0d3ltgg0i7w8WJKTYTl1CgX79qFg925YTp+WO9/Ly4MoKJADypIEyWAAdDpIBoPcuV6hwGz3ay8AwP79cr5ku/zIrx05gq7BwZhau7YyLsbD48ZvJBERERERERGViyRJ8Bs6FFe++w4qgwG+999f2VUiIrpr3FKBZmGxwJKYCMu5c3LL5PPnYU5IgPnwYYi8PIisLDmgrNVCMhggGY2A0QiVXg9oNA75kcvCKgRWJyVhQtWqGLRtG/alpaGKyYSJ1aqhV2hoBW0lEREREREREd0ofoMHw7tnT0g6nRwvICKim6LSA80Fhw6hYMcO5P/zDwr274fIyIDIyZE74QPkoLLRKLdQ9veXO+G7QVLy8pBlseCDEyfwfHw8XqlZE2tSUjB8xw4sbtUKbQICbti6iYiIiIiIiKhiqL28KrsKRER3nUoNNF8ZPhymM2dgzcwEAKgMBkheXlAFBcl5lW8y67W/94SE4PG4OABAPR8f/HP1KuYkJjLQTEREREREREREROREpQaazUeOQPL3hyY0tNxpLypCgE4HjSQhvtAvnzU8PbHtypVKqhURERERERERERHRrU1VmSvXVKkClZ/fLRFkBgCdSoVGvr44fq2Ftc2JzExEGo2VVCsiIiIiohvr9ddfR7NmzeDl5YXg4GD0798fR44cqexqEREREdFtpFIDzZUh02zGvrQ07EtLAwAkZmdjX1oazubkAACeiIvD4vPnMTcxESezsvDVqVP4PTkZo2JiKqfCJhOQnCy/TKbKqQMRERER3dHWr1+P8ePHY+vWrVi9ejXMZjO6d++OrKysyq4aEREREd0mKr0zwJttd2oq+m/dqrx/+eBBAMADkZH4qGFD9A4Lw9v16uG948fxwoEDqObpidlNmqClv3/lVFiSgKCgylk3EREREd0VVq1a5fB+9uzZCA4Oxs6dO9G+fftKqhURERER3U7uukBz28BAXOrTp9gyw6pUwbAqVW5SjYiIiIiIbi1p157+83fR2CIvLw95eXnK+/T09JtSLyIiIiK6dd11qTNuO3l5wPjx8svuYp6IiIiI6EYQQmDy5Mlo27Yt6tat67TM66+/Dh8fH+UVFRV1k2tJRERERLcaBppvdWYz8Mkn8stsruzaEBEREdEd7oknnsDevXvx448/uizz/PPPIy0tTXmdOXPmJtaQiIiIiG5Fd13qDCIiIiIicm7ChAlYunQpNmzYgMjISJfl9Ho99Hr9TawZEREREd3qGGgmIiIiIrrLCSEwYcIE/Prrr1i3bh1iY2Mru0pERES3NCEE9s4/jOQDlxHTLgLVu/O7k4iBZiIiIiKiu9z48ePxww8/YMmSJfDy8sLFixcBAD4+PjAajZVcOyIioltPwsaz2PP9IQDAhd3J8K/qi4CqfpVcK6LKxRzNRERERER3uU8//RRpaWno2LEjwsLClNf8+fMru2pERES3pLz0fMf3GfkuShLdPdiimYiIiIjoLieEqOwqEBER3VbiOlfBqQ1nkHL4CqLbRCC0fnCFr6Mg14z9y87AarGiXr9o6EwM49GtjUcoERERERERERFRKehMWvR8qyOEEJAk6YasY/0HB3Fio5zOKvloOnq+0uiGrIeoojDQfKszGoFTp64PExEREREREd0mrLm5kHQ6SCpm7qQ7040KMgPA5VMZyvAVu2GiWxX/09/qVCogJkZ+8YuZiIiIiIiIbqAC5OMXfI0vMRMncLBcy7ry3Xc4NWgQEh95BHknT1ZQDYnuHrV7RSmB7Nq9oyq5NkQlu+taNG++fBkfnTiBPWlpSMrLw9ymTdErNFSZ/sTu3fjp7FmHeZr4+uL3tm1vdlWJiIiIiIiIbqpVmI81WAwAOII9eA3fQg9DqZdjycrC1QUL5OG0NKT+8gtCnn66IqtKdMer17cKqjQNhLAK+EZ4VHZ1iEp01wWasy0W1PX2xtCoKIzYudNpmS5BQfigQQPlva4yWxLn5wMvvigPv/YaoNNVXl2IiIiIiIjojpaOq8pwLrKRh9wyBZpVej3UXl6wZMiP+2sCAiqsjkR3E58wU2VXgchtlRpoFvn5EFbrTV1nFx8fdPHxuV6HggKIvLzr7y0W6AAE2+fYEcKhzE1VUAC8/bY8PHUqA81ERERERER0w3TBABzETqThCrriPnjDt0zLkTQahE6bhtRFi6ANDobfsGEVW1EiIrrlVGqg2ZKUBItaXZlVgPXqVVjsgt0iJweb0tNRc80a+KjVaOXhgedCQxGkKf2uUlnyIC2ZDRxcU/YK5uVfH/7wJUDPQDMREcwFQPpV4EoKIETp55cASJI88NwHQGRsRdeQiIiI6LYUiijMwByYUQAtrt1/WnKBC8sAWIGwfoDavY7qDdWrI/S5525cZYmI6JZSqYFmvy+/hLenZ+VVoEEDeE6aBP/OnZVR/VatwlCTCVXCwpBw7hymfvIJhuTnY9vcudCXtjXxSyOgObAWOFeOR4TMdi2+N64ENOwQkIjuYMIqB5HNZiA/13GaWgNoNNf+agGtTn6pNXLQWKWWh1UqOZAMSR4vSYCkAlTXAssqlfzeRssf8IiIiIjsSZCuB5kB4MQHwKWN8nDGEaDWK5VTMSLCjm/2IWHjWQTXDkCbSU2hZpyIbiGVGmjW1q0Lrbd3ZVYBmpgYaOvXV94PsxtuBKDloEGIjo7GH6dPY+DAgaVbuJ8H4BkD+AeXvYIFZgBH5OHIWEB716XVJqI7jbAC2ZlAbo4cTDYXyK2SJUn+a/SQA8Y6PaA3Al4+QFg0EB4DeHoDHl6Atx/gEwD4BQIe3tfLl+HpEyIiIiIqQdYp58NEdFNd3J+Cg78eAwAkbDiL0PpBqNGDT2fSrYN35CUICwtDdHQ0jh07VtlVISK69RXkAzlZ14PHtpfVAuTnyUFmq1UOFuv0QEA0ULU24BsABIYBfkGAfxDg6QMEhMjliIiIiKhyhfQEEr6Uh0N7Vm5diO5iKrVj62VJJbkoKbOYrRAWKzR6hv/o5uCRVoLLly/jzJkzCAsLq+yqEBFVPnMBkJcjv/LzAXO+HDi2tUaWVHJw2D6thVoN6AxASCRQpRrg4w/UqA9EVQOM7EGZiIiI6JYX3g/wayo3GjBFVnZtiO4Y5nwLNDr3+y4LrhWA+g/UVFJnxHaMwuYPduL8rmREtQhD88caQJLk4PO5f5Ow/vWtsORb0eLxhqhxD1s+04131wWaMzMzcfz4ceX9qVOnsHv3bvj7+8Pf3x9Tp07Ffffdh7CwMCQkJOCFF15AYGAgBgwYUIm1JiKqYELIQWOLBRAWOSey1QpYzHLrYyHkabYykgRAXA8aG0xAcAQQHgsEh8stkT295TQW1evJrZKl4n9dJyIiIqLbiDG8smtwW8jetQvJs2YBAIInT4apadNKrhHdTFaLFVs+2oWLe5IR1TIczcbUVwK/AJB+IRMJG87CO9ITx/6+jJN/JyEg1gt9XmsCg5frvmPyMvJx5WQq/GJ80HBYbTQcVhsAcGrjWRxfnQgAOLL8JCKahCCymdxQcu+Ph2DOtQAA/v12/w0JNAshsPHt7UjcdA7BtQPQ+ZXW0BruulAj2bnrPv0dO3agU6dOyvvJkycDAIYPH45PP/0U+/btw9y5c5GamoqwsDB06tQJ8+fPh5dXJT2+rVEDD3S4PkxEZGO1AAUF11oVX0tPYb3WmZ7FbJe6wnotWGw3rxDXO9dTqQFIgFYrvwy+1/MjBwTLaSyCwoCgcMDLVw4wV6kmd6pHRERERESKy19+CUtGBgDg0ldfoYqLQLMQAllbtkDk58OzbVtI7GvkjpDw9zmc+FMO/B5edgIRTUMR0TgEAJCfXYBV/7ceual5yMmwIDtfB1OAEZdPZeDwH+fQ8D7ngeCc1Fwsn7QW2ZdyYPDVo/f/OsEjUH4ytHDbHvtUGqYA4/XhwOvD5/5NQubFLES3jYDBW1+u7b2wOxkJG84CAJL2XcLJNacR3yuuXMuk29td95+sY8eOEEK4nP7777/fxNq4QZKAAOYoJbprCCHnOc7LkYPFebnX8hvnA/b5t2yd59lSVEiSHDBWqeR8x74B11JXqAGtXg4Q+wfLneiZPOVAso+//F5nkMt5+sitktkSmYiIiIioTFSenteHPTxclrvy7bdIXbQIAJC9bRtCnn32hteNbryigd/rw9mXcpCbmgcAUGskFFwtAK4Fg01+rgO+F/emIPtSDgAgNzUP53clo3q3GABAdJsIxPeOw4XdyYhsHoaIJqHKfC3HN4LOSwtzrgUNhtYCABz/KxGb39sJADi07Dj6ftgVak3ZGxDpPHWF3mvLvCy6M9x1gWYiogplazFsaz1sNsvvIeRWxrZpwLU0Fdc6wyvIv94C2XotNYUAACug0cnBX61WznccHAHE1AC8/QG9QQ4UmzzlwLC3H+AbKAeObS+t60euiIiIiO4K+VeAlHWAIQwIaFXZtaG7SPCkSbj81VcQQiBg9GiX5XJ271aGs+2G6fYW3TYSF/el4OLeFES1CEd4wxBlmle4J4Jq+SPl0BUYfbXoNLwmLp3KRki8D6p3ct0vmH+cL1RaFawFVkhqCQFVfZVpkiShxdiGTufTe+nQanxjh3FJ+1KU4fSzmchNzVVaR5dFYHU/tHi8IRI2nkVI3UDEtGMO97sdA823OosV2HlMHm5SHVDzUXWiYlmvBXIhruUctlzPOSyEYw5iW9DXXGA33S7FhCTBId+EbdAWOLbNo1LJP1VLkpyKQpKu/XQtXZuG68NqDWDQAr4xcqtjjUbOb2x7eXrLQeTAMCAwFNBo5TJERERE5B6rGdj/LJB7UX5f9QkgpEfl1onuGtqwMIS+/HKJ5UwtWiDvxAkAgEeLFje6WnSTqFRSkeCujVqjQvfX2uHSsavwDDa5HeD1ifTCPW92wIXdyQipFwj/ON8y169Kq3CcWHMaEEBQTX8Y/Y0lz3SNEALn/02CxqhBSO1AZXx8rzimyyAFoxe3OqsV2H4t0NyoKgPNdGMJ4RiUtQVs7XP92rfStW/Jq6SkEQ5/5PlRaNq1ZSvzFVqHxWKX/1eyW5hUaFShNDhCyBPVdkFelfra61rQWKORW/xqtPJfg1FuEaw3yOMMJsDocS1/8bWcxRqtnH7Cls9YpZLHqTVyygm98fp7T+/rwxqNPJ9KJb+0esBoYmoKIiIiohupIPV6kBkAMo4w0Hw7sKWGu0v4P/ggDLVrQ+TlwdSsWWVXh24StVbtEKR1V2B1PwRW9yv3+qNahKPvB12QmZyNsIbBUKncP+c2v78TJ/46DQBoNLwO6t0fX+760J2HgWaqeC4DjoXeuE6VXdLEEoqUMG/h1qhKoBMAbMHPQssqEjS1C4oK4Rj0tF++rbxtuMh0Z+ULBXmLbJZ9na4N2wdlbUFYqfB8RRZk91nZTVOpr7fOVamut+q1tdJV2f6qCo2D43z280hS0ZfBJAd6VepreYR1csoIW2oILx85YGsf2LUN25ar1V0P4tpyFBtM8jJU15Zp9LieTkKllt8z2EtERER059IFAN71gPR9gKQBAtpUdo2oJIlzgPO/AoYIoPZ0QF80ECfM5lurw7zUXcCxt+Xh6k8Dvo1KvQhTgwYVXCm62109kwkA8IvydFnGL8YHfjE+pV524ubzyvCZLecZaCanKve/9KT7AJ27VXAj8OiuClxUsaR8ICURSL9YcllXzNbrw4n7Afsk7fa/+BbTwWGFcvUrs7P1uwrkuRvgK1zOPlgrj4ASmC0yvvCwXTmNF6C51imDEhAFHAKj195en6ZU6vp42/y2QKtttGQX9LQFUZWWtSo4pFlQFZqmvRZMtQVc1WrHOqls76+tR62WW87qjddSNhQKEKs18ss2TgnUqq7XyxY0ti1bCDnvr0Yj18O2XFvLXrXmWt0011v02tbB4C0RERERVTZJAmpPA9IPAvogwBhe2TWi4uReBM7JneIh5wxwfjEQ+6gyuSA5GRdeegkFFy/Cp29fBI4ZUzn1LOzUF0BB+vXhRp9Wbn2oUljMVhz47TRyUvNRp08VeAYaKq0uuxaewj9z5SfiW4yojob3xVbo8kPrBeLsP3J8K6ReUIUum+4clRtotgWo7lT5J4CmKsAzv1Cw0gVnZfKtwO/XhlvlAzqVXaDRft5CeWQdppW0Xjcq51BEOB9fuF6ScJwGZ+OdrUMCoAIktfxWZQugXgsKOwSGVdfKSo4Lkez/SnZ/r5Vt+J783pb/1hZsVavlcUrQufDLPpCrklvKqjXXA8iFt5WIiIiIiG4+lRbwZWvR24LaKLc8F2b5vdbbYXLa0qUouHBBGfbp2xfa0NCbXcuibI2XCg/TXWXHvOPYvSgBAJCwNQVDPqu8JygOrTqrDB/+/VyFB5rbP9sCp9afgcagQUzbiApdNt05KjfK+/YCwNu75HK3q/XtAGs+oCvHLz05ZiiR5jaNAGMlfGSiQO5QQ5ivDRdATjFhBYTl2ssMxyizrZWxraWsTg4cS2o5cKzxkh9p0wUAKoN8YaEElNXyOLXpWllPQO0BqA2ASgclCC2p5fe2CxNJuhactg8qa6691PLFpkonv2wthImIiIiIiEor6ySQOFe+R4n9D6Dzr+waFc+SC+SlAIYw+R7rVqL1AeKfAy78BpiigPD+DpPVPtcf8Zd0OqhM7nWgdsNVmwQkfCUPx9wirayp1KwWK/YtOY3MS7mo0zsKvhGl+9HgyuksZTjtfDYsZivUmvLFG87vTsLlY6mo0iocPpFeTsuc3XER+Zn5iG4TAbVWbqQXWNULGck5AICAqs7nKw+NTo3q3WIqfLl0Z7nFvmHuUOVp4erQErgcqQmEAGAFrHlyoFhY5EAxhBwktuZfK3MtcAwVlGCxpJGDtJJWHtZ4yhdUag85GKzxBHSBch4ttQFQ6eVfdNW2ckb5wstWVuPNVr9ERERERHT7OvIGkCu3soUwAzVfqtz6FCcvBdj3DJB/GfCKB+rMvNaA5xbi30J+OeE7YACsGRnIP3sWPr17Q32rNFYzRgC1plR2Laicdv50Ev/+dBIAcGpTEoZ+0w4qtfuB4to9I3Fu12VYzFbU6hlZ7iDzuX+T8NeUTQCAA78cRf/PusPgo3cos2/hEeyaewAAcHLdGXSdKrei7jS5LoJ+OwNJAur0qVKuehCVFQPNtzNxLUgMq5wbSgkeW+VfrG2dwimpLqRrLYD1AOw6fFP7yL9sq01ykFgfBGi9AH2I/OuyxhPQ+suPMGm85fcMFBMRERER0d3KnOl8+FZ0aaMcZAaAjCNy7mrfhpVapdKQNBoEjBpV2dWgO1TauWxlOOtKHgpyLdB7OA8WCyFwasNZWPItiOsYBbVWjehmQXjw63bIzyootgM+d106ckUZvnoqDevf3IZ6g+MR3jBEGX9+V5IyfGF3sjKsNWjQ6H7X6TIsZisunUiHZ5ARHv56l+WIyoOB5luZ1QyocoHPGsjDliQg2yKnrxDXUleodNeCxaZrLYa95ICw1gfwrH49WKzSy62Sdf6APlRucay0UmbQmIiIiIiIyG2xjwEnP5Kf3qwyvLJrUzxj1PVhlRYw3AL5jYuRhHM4gB2IRU3EIr6yq0N3uNq9InF6ewoKci2o2T0Ceg+ty7I7vt6HQ0uOAwDO/nMBnV5sBQDw8NdXWOC2SqtwHPj1GDLOZyDjYhYu7E5GyqHL6PdJN3iHyYHsyGahSNp3CQAQ0dS989lqsWL5yztxYf9VaA1q9J7RBCHxvhVSZyJ7DDRXFltrZFt+Y2u+/DJnXC8jqeQAcQ09IHnKLZHVJkAfDJhiAFM04FlNLmOMAgzBlbY5REREREREd42gDvLrduDfDKjxDJBxGPBvXSmBZiEEsjZuhDCb4dm+PSSNYyhCWCzIT0jApcP/YPXWqTjvewXft9dhYv501Gsz+qbXl+4eITV90fqxeEiShPguxXdwl7T/ktPhiuQX44P+n3bDzjn7cOKv01CpVbAUWJFxMVMJNNcZUAP+VX2Rn1mAyOZhbi037Xw2Luy/CgAoyLXgxIaLDDTTDcFA881gNQPWXMCSA1iy5bQWKjXkTu2udVan0sktkb3ryQFjvxaAzk9ukawPkocldWVvCREREREREd1uAtvLrzKw5ubCkpoKTUgIpDI+DXv588+Rtnw5ACD7338R8vTTyjRhseDClCnYf3EVNNuPw9svH94WCzK9TNh3+QvUbTkCkpr3wnRjrH59DxL/SQEA5GWaUf/eaJdlo9tE4MqJVGX4RjEFGNFkRD0kH7yCKydSkZWSjTXTtqDF2IaocY+cGiOsftGGhgWHD6Pgn3+gqVMHuiZNHKZ5BBhg9NEhJy0fABBY9RbJdU53HAaay0MIIC8ZMKcD2YlAQaocTM6/ChRcldNS5F+QWylLOjm3sWcNwBgJ+NQHPOLkVBYaT0AX4LyTvPx84P335eGnngJ0t1inDURERERERHRHyj9zBueffx6WtDR4tGiBkBdfLFOwOWfvXmU4d98+h2kF585hhf9yHKmZiJZHc2BWCWgtEryuSKh2NgRQla9zNbq9mI8dQ86CBZD8/GAaMQIqk+mGrUsIgdPbr7dMPv1PSrGB5nqD4hFSNxDmPDPCGsiBXqtVYM/cPZDmfYpAVRJ8+3aBxxNPlPlHGRtTgBH9P+uGlc+sw+XjqRAWge1f7VUCzYVZzp9H+gsvAAUFwM8/w3vmTGjr1lWm60wa9HuzGY6tuwD/Kp6o2u7WTqFDty8GmosjrEDOOaAgDbBkAvlX5B57M44AuReBnEQ5iGw1ywFmQA4UCwAwA5AAv+ZAzKNyq2SPWDmoXBoFBcD//Z88PG4cA81ERERERER0U2T88QcsaWkAgKxt21Bw5gx0VaqUejmmJk2Q/e+/kDQaePfq5TBNHRCAhJo5uOynQVJtLSJOaBGqiUbNrNaIHTe+3AG7G0EIAWt6OlReXpAYCK8wQgikT5sGce2YgyTB8/HHb9j6JElCREN/nN0ld5YZ0SigxHmCazmWObryJM599isiT+3EZUmCVloJXdu20DVqVO76qbVqeEd44coJeX8YfV3ngbacPSvHjwBACJhPnXIINAOAb4QHmg2rVu56ERXnrgs0b9iwAbNmzcLOnTtx4cIF/Prrr+jfvz9gyQPSdgM5Z4DcC0D6ATw2ZSm+WHYB/3s8HBMH+Mm5lCEBEHKqC5X2Wid8nnKKC1Wh3Zl5FIgeDgR3vvkbSkRERERERFQO2ojr6QFUJhPUfn5lWk7u0aOQ9HpACGiCHR/5V3t4oHmLJ/Bb9lfYO8MIvVcvpOk9kYLz6II0NCzPBtwAqeZkHJ8yCca9F+EdFY/wN96A2ptpCCqE2QyRnq68FVev3vBV9nipIU5uSoLBS4sqTYNKPX/O1VxYr8WChBCwmq3ysV5Bmj/WAGqtCvlZBWg4rLbLcpo6daCOioLlzBlI/v7QtWxZYXUgKo27LtCclZmOBjUjMbJ/A9z36GtA4lzgn/lygLkgXe6QDwKLN2dj28FUhAfqALWHnO5C0hRNbUFERERERER0m8g9dgzmCxdgbNIEag+PYst69eihdNTn1a0b1F5epV6fMJuRe/CgEozN3bcPuO8+hzL9Ap5A9YA2yEMuEnAEf2IRAGA2ZmEm5sIDpV/vjZCFDHy5ZzRq7P0HEiTEnrHCe/16+PTtW9lVuyNIWi1MI0Yge84cSN7eMA4ZcsPXqdGpUaNTeJnnj+8Vh8SNzXEp6wIifFPh81h/aGs7DwjnZeQj40ImfGN8oNG5l3fc4K1Hm4lNceLvi9g69ySCa3ij8ZC4Ii39VR4e8Pnf/2A5fRqq8HCoSji3iW6UOy/QbDUDmceA/BQgPxUwp11Lc3EOyDmLnh7J6NkzBzBnyuWvbAXSgwC1AdAFAWojzl3KxROfbMLv77ZA72f+kVsuq7SVullERERERERE5ZG1bRsuvvYaIAR00dGIfO89SBrXYQFJkuDTu3e51ilpNDA1a4bs7dsBAB5OWloWJCfD89VvYEhKgvZBf2CAPN4CM8wocG9FWQlAxiHApwFgtAscpqyTYwLBXeSUluVwDgm4HJgNIUmAEMhCepEW2lQ+xoEDYejXD1Crb1raFCEEtnx9FGd2XEJU00C0Gl3D7XWb/I3o/3kPmPO7Fhs8TjuXgZXPrEd+Rj784nzQ860O0OjdC8mlnc/CX7P2QVgFTm9PgWegAfFdi3ZGKOn10FSv7tYybQ78ehS7vjsIj0AjOk9pDZ+IW+NHHbp93Z6B5vwr8hdF7kUg6yRgyZbHZR2T017kXwWseXKOZVz75yCp5GCxpJPTXphiABwGjBGA6XoSdKtV4OHpu/HM0DjUieMJRkRERERERHeG7J075U7tAeQnJsKckgJtWBjyz5zB1Z9+gsrDA/6PPAK1Zyn7FipB6AsvIHvnTqh9fWGIjy8yPXXhQuQnJAAAqs1OQEyXOFzwvoQeGAxviw/S/lgJkZsL7x49nHcOl3UK2PdfwFogp7ds8CFgCAYu/Aac+lwuk/wH0OiLoikvSyECMVBHR2Hv83kI3ZSKmrX/A48WLcq8PHKuuB8/boTEf1Kwb0kiACD1XBbC6/khpkXpfkAoqYVy4qZzyM/IBwBcPZmGS0evIrSeez985KYXQFiF8j77an6p6uZKfnYBds7eDwgg40IW9s0/jLaTm1XIsunudXsEmgsygPR9wJUtQNoB+VdKaz5gzZGDycICSOpreZMNgNZX/iupS53q4s15J6BRS3hykPOePImIiIiIiIhuR8aGDZG+apXcojkqCprAQADAxVdfRcGFCwAAkZuL4MmTK3S9kkZTbEBWZTQqw1qtByZr34EKRgghcOHlF5G5aRPU3t7I3rkT4TNmFF1AxiE5yAzIDdGyjsuB5qzj18vkpQDmdEDnX+bt8IAX/g/v4kirPYhoFYsIxJR5WeUmBFN7VhD7IC4AWC3CRcmiDq8+h/1LT8OvigfaT6gNrcF5mM0/zlcZ1hjU8ApzP7VFcLwPqrUPxfENFxEQ44Wa3Yu2ZraXl1UAnUlTYqtslUYFjV4Nc64FAKDz1LldJyJXbq1AsyVX7kAv5zyQfwkwZwCpu4D0/fKw7YtD6wNovQFVcLl+jSxs5+FUvL/wFP79pt0t2bMtERERERERkbvMMGMhPsdpHEMrdEP71r2hefNNFJw/D1Pz5pC0copI8+XL1+exGy6t/HPncPHVV2G5dAn+jzwCn379nJYrSE6GNTMT+rg4AIDfAw/AkpqKgosX4TtokBJ4vvTJJ7g6fz6smZnQhoc7BKQd+DQA1EbAkiM3PPOqKY8P7Ahc2iDHEnybANqydWZoI4QVPpI/mqOT+zNZ84G0fYA+BDBFlmv9AIDME8Dh6XKMJOZRILRX+Zd5l4tpGYxaPSJxesclRDUJQGwr91ozZ17KxYYPD0IIgcsJGfCN8kCTB6o6LRvZNBSdXmqJS0evokrrcHgEOmmZ74IkSejyTH10nFgXaq3KZTkhBFa/sRenNifBN8IDfV9vCpOf644JNTo1Or3cCvvmH4FHsAkNH3Ld2SCRuyo30Hx2IaC5IgeWsxOBvGQ5d7I1F4AkZ70QVvnLQB8KqPQ39Be7jXuuIPlqHqrc95cyzmIR+O9HB/HeglNIWNTlhq3bJYMBWLv2+jARERERERHdGoQAznwPZBwGAjsAId0qu0YONmEVNmEVAOAMTqAG6iO0Vi0YatVyKBcwYgQuffklVAYD/MrRAdvVn35CwblzAIBLX30Fr+7doSp0H5v5999InjULwmqFd/fuCJowASqTyWkr6qytW6EOCIA1MxPm1FQEdu3qfMXGCKDBR3I6Ta9agM4fuceOoeDsVZjqvwO1Lg/wrF6ueEKadQUuWb6ESvJAmHoKDJIbuXCFFTjwktziWlIDNV8G/JqUuQ4AgDM/yKlDAeDUl0DIPXKqUCozSZLQ/onSB1mtFgEhrrd+thRYiy0f1SIcUS3K3vFgcUFmAEg+koZTm5MAyClADq8+h8aD44qdJ6x+MMLqM884VZzKDTQfeQPwUF/Ln6yXX7oAuWO+SvhH+fA9kejaLNBhXI9J2/DwPZEY2SvqptcHAKBWAx07Vs66iYiIiIiIyLVL64Cz8+XhtL1yMNMjxnV5c5acwsEYWaFP57pSAMdcrvnIc1rOp2cXeLWvB8kUAWjLXi+1x/V0ACq9HpK6aN7ajNWrIaxyQC599WoEjhvntFzmxo2wXL0KSaWCoW5dmFq0QN7Rozj14IPwHTgQfoMGOc5gCJZfkHNRX5g2DRAC2ogIRH7wAVRS8Tl0iyOEwCXLlxAwwyLScMX6A8LVU0qeMe+SHGQG5JSfVzaXP9CstetLSuPBIHMl8g4xovnw6krqjPr9oyu1PkZfHVRqSUn94RFQfGPFzEu5SDuXheB4H5cpP4hKq3KPJI9YwNN1M/4bITPbjONns5T3p85nY/fRNPh761Al1IgAH8ecNFqNCqH+esRHV2xnCERERERERHSbK0i3eyPkdAau5FwA9j8DFKTJqR3qzJQ7rL+B2qInDmEXzuA4WqEbqqBa0UKZJ4CDL0FlzkRCQDDer3EVHpIPHsPLiELxrSEBOQ1GfkICDLVqwe/hh2HNzob50iX4DhmipOawp4uLQ/a//8rD0dFOg8y5x44hadYsCCFgycqCd8+e0EZEIG3JEgDAlblz4dWpk5JjurDsXbuUTg8Lzp1Dwfnz0MfEyNOQCUCCCe7nyJUkCSrJGxYhtyRWw8e9GXV+gCEMyJXzX8OrAlITRI+WW0oXpANRD5Z/eVQuje6PRaP7b40+vrxDTej2fAMcW3sBgdW8UaNzmMuyKSfSsey57SjItSAgxgv932leYoeGRO6o3EBzJfzytuNwKjpN2Kq8n/zhQQDA8J6RmPNSw5tenxIVFABffCEP/+c/gJMvaiIiIiIiIqoEwV2By5vk1BlBHQDvuq7LXlovB5kBuXzmMcD7xuZENcCICXhVeb8HW3EQO1EbTdAALeWRSb8D5kwIAJmXl8OQVw+phgL8hnl4HK8Uu/y8hAScf+YZWHNzoQkORuT775fYkaD/ww9DExgIS1oavHs5zy9sTkkBhEBBYiIsKSlIX7kSxkaNlOmSWg1o5HCG+epV5B48CH3VqtCGhgIALFeuIGffPqhMJni2aQNteDisubnY8fZYJBz7C+e7B6P1sLdLlWs5XP0KLlu/hxreCFSNdm8mlRao+yZwaaMccPZv5vb6XNJ6AdUrtrNGqhhCiErv7yumRTBiWpScCuPU5iQUXOsE8HJCBi6fykBIvO8Nrh3dDe66tvEdGwdCbOrjdvlKyctsLz8feOIJeXjECAaaiYiIiIiIbhUaD6DeW3Lr2ZICTCa7x+pVekB/c/OinsIRfIWZEBDYjN8xGbMQi3g5vzHkLpLyNFqc0J6DFTo0Rrsiy0jBBezFNkShKmqgHnL+/RfW3FwAgDk5GXnHjsFkFxAWQiDl/feRuX499DVqIGzKFKhMJvj07u2ynkII6KtXh75mTeTs2gWVyQS1vz9Ebi4MdepA5ObCd+BAaHx9YUlLw7mJE2G+cgUqgwER77wDCIGMtWsBlQrmK1egDgqCSqdD6q+/4tK2NdAjH7E/ncXGVl+heZz7gWa9VBXh6uID707p/IBw550i0p3hal4BXtl7Aqezc9E7PBD/qV4BnT7eYCE1fZVhg7cOPuHud05IVJy7LtBMREREREREVKHcacUY0Aqo8QyQcRQIbAfonad9uFFScB4CcjoJAYEUnJcDzWH95KeNc85iZUgBstQnoQGgKRQuyBTpeOPcUKQXpEAbGIQnvN5BXK1akFQqCKsVKg8P6KIdc9TmHjiAjL/+kocPHkT66tXwvfdehzLW/HzkJyZCGx4OSaPBhZdfRu6hQ9DFxcE6shfO7/oDUsE++J84Df9LsTA2bAiPdnIQPPfoUZivyOksrLm5yNm9G4b69VFw4QJEVhYkAJl//gnzM89AUquhgx4F1/JU+6mCKnoXl0rusWMwX7gAY5MmDrmt6fazeOd+nEi4AMnLG8sE0DM8EFEexedHrmzRzYLQa1pjXDqZgbjWwTB46UqeicgNDDQTERERERER3QyB7eVXJaiL5ghFFVzEaYQhGnXRXJ4gSUBYX1hhRRJWycFnABlIc5j/5JaFuKKRU09aLl/G8Vo7ULvWfxD+5pvIO3oUxiZNoPH3d5hH5ekJSBJEQQHyz5xB8jvvIGf3bgQ+/ji0wcGw5uTg3DPPID8xEWo/P/gOHozcQ3LnefknT2L9+Fykdw5DbkoSNCIXD80DcnbvhjkpCdrQUOjj4qDy9IQ1MxOSRgND7drQx8TAo0ULpK9cCZXJBE1wMCAEvHv2RPXje3Fq/wpYAzzR+nxvIObG7nNXsrZvx8VXXwWEgC46GpHvvQdJw/DM7ch85gzU338HS3RNQJJgqFMHRvXt0UFjVONARDW+uT940Z2P/8mIiIiIiIiI7nAmeOA5vI+rSIEfgoq0WFZBhU7ohzl4GwICffGIw/TAE1YEBhhxKTAHmjyg9qWqgAdgqFkT+qpVIazWIuvUx8QgaPx4XJwxA+akJFhSUmBOTobIy0P4zJnIPXAA+YmJAADL1asoOH1aDnxf68gvN8yECw0MMCdbEbZObrms8feH2s9PHg4IQOS77yJnzx7oa9SAPk7uvDBi1ixogoJQcO4cfAcOhCU9HRemTAGyshB1KRBIEUh//QPonwS8u3Ur8z5Nw1VkIR1hqAIJ7ufmzd6xQ9nG/MREFCQlQRcRUeZ60M2RfiETek8d9Hatfy0nT6LHmeO4otHhrIcXeiEWgQa2Dqa7FwPNRERERERERHcAIQQy/vgDBRcvwrtbN2jDwx2ma6BBEMJczp+DbIQjGiqosRo/oxvugwpy68ygLr3x6JR1SPA4jaiIlgiIS0Xykg+QE+ONiyvmI+iCDoHjxsG7Rw+HZXr36IGrCxYgLzEBeXnpsOYkQ5eeDADQRkRA0ulguXoVltRUqAMDEfL000hdvBiWK1fQa2csFtc+D21wdQys0gp+DxbAq3NnqPR6ZfkqDw94tGoFtY+PMk7t7Y3wGTOU9+dffBH5CQmw5uYi79AhaEJDYU1PR9rixWUONB/GbnyOV1GAfDRDJwyH+x30mRo2RPrKlXKL5shIaINvbr5uKr3NH+zE8dWJ0BjU6DylNULryqlXtA0aQBcQgIdPHoDk7w+fFmPdWl5GUhb2/3wEOpMW9R+sBa3h9gjPiWs/kFR2p4d067o9jmQiIiIiIiIiKlba0qW4/NVXAIDMNWsQ9eWXUOncb12Zi2xoIHdAn4dcWGBRAs3a8HBU/3g24lJTkbZlA4788D+cj8nH8vhDsI40ot6+IAycO7dIoBkAfPv3R+LRNVCdyENqjAG/jTyCkTiC2LB4BD/1FM5OngyVhweuzpuH0JdfRsGZM7Dm5sLw62U8bhyKYw+GYEHLXxHc2IChZy9Cey4GCO+P9D//wqWPPoKwWuHZsSM8O3aEsV69ItssqdUAAHNqKqzZ2cg7cQIqgwE5+/cj98gRGOLj3do/l778Ehl//gl9jRrY/IIeBcZ8AMB2rMUgPAYT3Mu17NGqFSLefBMF58/D1Lw5JK3WrfmocuRl5OP46kQIIVCQa8bRlaeUQLPK1xc+H34Iy6lTUMfEQOXlBQC4nJeP385dgpdGg36RgdCoHNNprJm2GWlnMpCXmY+rCWnoOq1tuepoTU+HZDBAKsX5Xlqnt57H3+9sh6RWof0zzRDRJPSGrYtuXww0ExEREREREd0BbGkoAMB85Qqs6elQBbqfg7U3huEcTiEVlzEAo6CFYwBUpdMh/fhBfL/nSWz9TzKy/AQ8r6qhtxqwr/4l9Dvig/RVq5B/+jS8unZVUln49O2LHa2W46Q4gP1Bx6DGSaThOfz3/HPQbdoEldEIta8vIATyjh6FJTMTBefOoSApCamXTmBON3+oA3xwPms3gixBuDcxCgCQunAVhNWKvKNHkb1jB5LffRfa8HCEvvACfAcMUOodOHYszr3wAqz790MTEQHz+fPQxcVB7e0NS5pjLmpXco8cQdrSpQDkPNExq2rg32ur8EcwjDC5vZ8BwFCrFgy1apVqHrqx8i1WvHkwAftSM9EmyBdPxkdBkiRoTRpYzFZc2J0MSQKqtHR8UkDl6Ymk2oF4P+M15FzNwRiPMfh0jwans3MBAFfyC/BoNcfUKJlJWUhNTEdGUhbSzmYgomkozHkWpBy+gtj2kYhtH+V2vbNmz0buL79A8vCA17Rp0Lr5w0lp7fh6H8y5FgAW7Jy9n4FmcoqB5ludXg/89tv1YSIiIiIiIiq9nAuANRfwiK3smtwwXl26IGvDBljz8uDRogXUAQGlmj8UkXgFn7mcnnfiBM68MR0HHr4Eda4FhlRAZZZg8AmGp9UTfo3bIuXjjwEAGWvWoMpXX0Ht6YmcffvQMbkm9rXeAwAIQjhUGblIfub/2bvrODuqs4Hjv5m57uuu2exuko2HCEQI7i4pUopLaSktUChtsWKFQoHi1tIi5aW4Q5CEhIS4bWQt6757XUfeP27YJMSNBJgvn/1w7p0zZ869c7PyzDPP+QOefjPxpiaMmoa5pAT7tGn0PPVUclFARSFijRBZ0YJt/ChETSahykTXrSPw2s1EVqYg2u0oPh9aIoFgMCD39ND14IM4DjsMw4ZyGsbcXFLPOw+ltxdUFS0SAUHAPmECtrFjd+q9ETb8PZ6IKkS8MYo7x3Mm0+mgBRGBL3mXKRyHhLRL77lu/9M0DUEQ+LKrn296/QB82tHHlEwPY1JdiJKI2WnCkWFDMokEOkID+9YvaOelN1Yyd9DHeI9eQZrZyH2B++gPXzvQpzEU3eKYI2YM4d3ffIYgCrhy7Cz5dzVyRAag5Zt2UkrceApcO557NEr09deT7VCI6JtvYvz97/fo/dgWs9NIsGND26XXodZtnR5oPtAZDHD88ft7FjqdTqfT6XQ6nU73w9U1E2ofAjTIORlKLtnfM9onrMOGUfDMMyj9/ZiKi/dKHVXZ6yVeV4e5rIzA558jNnaR0iYQHCIgGCRyujxMHXU5B2fNQJv39sB+aiiE3NdHeP58Gv9+J/20cPq7Kcx84BASQpzMDgNOv4YgSVirqjBVVOCcPDkZDFaU5CCahr0pyNTnHKyuMJNnqWLavHqi6zrp+8iKomiQmYJx/CjUmkbk7m7U/n7iskzb735H/sMPI1gsKH192CdOJPDRR0TXrCFlxgyy//hHRItlp98Hc3ExjnMvZtkt/yFoLqPnPTcnTB7Pgqq7WM9aAHrp5HR+nJ+tHyNNUQj+9a/Ev/4aQ1UVlst/tdl2q7TxooE7zzEQCLalJj83/rYgr9z8JR3BCJlzbDQ7zLgOVVBEhRPy0nmntQeDIHBc7pYXfIafWUHrwg46VnQjSiK2VAv+1uCGiUGkP7pTgWZMJgSPB83rBUDch/W+p1w/nkXPrUAQBcZdPHyfHUf3w6YHmnU6nU6n0+l0Op1O9+PW+RGgbWh/8KMNNAMYPB4MHs9eGUvu6aHlN79JZgyrKlo8DsEIpzxoZ+6MBFJ2JidJF1Ga9WsAwuPG0f/aa2jRKIIo0nL11SiBAI32GmQhAbU+qvxHMdl9JnlFeXhLbydWX0+iuxu5u5t4TQ1SSgpIEqLNhur3g6Yx+qUQB81cReHTT+Od+RSBLxegRRWCmX5Wj6pl0c2DOPyzaVQ8sR5hTSPG3FwSnZ3Eamroe+klotXVGPPyyLv3XgSLZbPFBHdFonIKDeUbS2R0rfXRWLWOCCFMWGimbq+877rvR2LJEuJz5wIgr1jBuNXLODmjkpVPrCM7LmKx5MLEZN3tKTeMZ8m/ViEaBMZemAyyBrtCqHLyoohVzsHT3kWGGOc3zqsYm5bPcXnp2CSJVPPWa3Afftsh1HzUgMFsoGBiDp/86Su86/3kT8gha0MN6B0RRBHXHXcQfeMNxPR0rGefvadvyza5chxMv3nSPhtf9+OgB5oPdIkEvPhisn3uuaAvEqDT6XQ6nU6n0+l0u8Y+CAKrN7RL9+9cfkDCS5ci9/cjiCJydzeCJGEeMoSMRIJLj74R2/DhGDbUgO7/3//ouv9+5J6eZGBa0zCkpKDGY8hlQbCa8VY6iLlEKhgBJjDfcgsdf/kL0YYG1O5u1HgcE5B57bV03HknkdWrIRoFUUTx+ei4807SL72UWEMf8aYmWqoSrDhOolZcyZqjl1M1cShnX59HVrsVQ2oqst9PtLoagERLC8FZs3CfeOI2X2+srg7vG28gOZ2kzJiB5Hajog4siJgx2IU7x4avPYzJZiBjvI0APhpYgwkzZ3LZPj8nP3aJtWuR167FNG4cUm7ujnfYjq51Pr55oQazw8ghl1diS9n8AoOwYeG+b4kuF/kf9NM9P4ggCXx6zzIueu1wJIOIK8fBtBsnbNY/a1g6w8fmEpzfTMjl5urDbuJUWzbB1jBdsV7yK7dfusZoMTD05MEDj0965AgSURmjZddCdYbiYhzXXrvjjjrd9+AnF2ietbSX+16qY9EaH+29Md64exynTN1YwPzWZ9fyyqdtNHdFMRlFxla4ufOyCiYMS9k/E47H4cILk+0zz9QDzTqdTqfT6XQ6nU63q4ovBksOKGHI/oGWJtQ0iPeC0QPivv9TPrJ8Od0PP0xkyRJMhYUYMjORbDbUSARTeTmOiRMRrVYA/J98Que99xJfvx7V70cwmVDjceRoFNFmQ8n0sOI4gcjUMq4UzkPTNHqfeYaep54i0dqKYLGAIKD092OcOBHXscdirqyk+YorCM2bB4kEmqIQWb4c/yefUPDMM4RmzeID4wN0WDoJh8I4nLl0ub3MvWc0Fy88BefY8ajhMGogQHTdOtA0Eu3tW3+x8X4Sq96k6ZpHiK5tBUGgfuk7vPWPNPySl+M5l2M4C7PdyKkPTqBrrY+UQge16Utw4KKMKkREjPxw1lVSUIgRxYZ9f09lQGL1avw33giqSuTll/E8+ihiaupuj/fxXcsI9W6ojyzAkb8fudl2Y0UF9iuvJD53LobhwzEffDBrfv8ugc4IAKqsDdwI8a1X1ncwb9FyRgT7ueDIKZx476Ec3hPG7Dbz1f0LeObtLwl2hsmoTGXoKYOZcMWoXZrzrgaZdboDzU/uExyKKIwsc3HhcQWcfvOiLbaXFzj4x2+rKM21EYmpPPjfeo66dj61/51ORsoP54eGTqfT6XQ6nU6n0/0kaBr0zQM1DmmHbD0IKxog96St79+/CKLtkD4FjO59O9fdpcqw+hbwLQdLNlTdC6bdC8BpsowaiSB9J5vzu/pefBE0DUtlJVo8TsHDDydLUnR0YMzNRTRtXAwsVluLaE8GLLVEAk3TQBAQzGZEt5vBn/kZ4R+H9u8EzvPm0Rv5nO5HHkHu6kINhVD7+xGsViz5+aRecAGCKNJ9//1ITifGnBzk3l6QZUSrlURbG3JrK3JXF8cvKcHZIyCvqaOtoonqw5qYNzZOwVGjOJtjIS0NQ3Y2Unc3ktNJaO5c0i/7TtaxKsPK3xNfsAohtAaDU0QO2PmyYjn98QpEq4V3+TdTOR4bdsx2IwVjklnc2RQgYcCKDQGBPIp365x83zpo5hH+iI8+JnMsM7hqf08JALm6GlQVAC0YRG5qwrQHgeZ4KLGxHZS32sdy3HFYjjtu4LEtxYTZYURJqORUpSAZxYFtS/sCvDBvKUpTE6uBgrvv54gH7sWRaadzVQ/N89oJ9URIRGRC3RHqZjbucqB5T/U3+pCMEq5cx/d6XJ3uWz+5QLPdKrGs1s9z7zYDMH9V/0BGc0JWWVbr5/2vu6hvC+O2G5g6OhV/SGZ5XYDDx+mBZp1Op9PpdDqdTqc7oDT9C1r/l2z3z4fyG3Z+365PNywSCHS8CyP/8b1kC2+VpkDXZ6DJkHkEiJvczRqoTgaZAaId0P055J2+4zEjbRBcB64qMKcTq6+n/U9/QvH7cZ98MumXbF6rOkQAEQkrNqQNdZ5Fux1TRQXm0mTJEXNx8RaHcR56KMGZM1ELC4nJMqLDgeh0IjmdCKqK5nSCohCrrqbnmWdQvF40TUNLJFAjERAENKMRLR6n+4EHMD34IInOzoHjiRYLiteLYDQiOZ2YBw1CtBswRl7i+HldfOKB6mkKKNAVbqDatjGpzFJRgRoKAQy8JhWV//EM9VQzMTGKadF2LNm9GFNVNDmOaDLgcZcjmJPBdAs2jJj4rmzy+RV/YRULKaOKUobs+JwcAL7kXXz0AfAVH3AkZ5DGvltEbmcZx42DV16BaBQxKwtDWdkejTf5qiF89fgazHYD4y8YvMX2rhofPXUBCsam4cxIZuePO6+MBf+uRTKITPv10M36hxUFLRweeBwJhdECAYTUVKwpFgRRwGQ3EvdFoa8LT3EUTVEQNllUcF9a8p9VrPjvWhBgwhWjqDhOLxOk+/795ALN28toDkcVFq/18adfDGZkmYuu/hjn3bYESYSRZTux2qdOp9PpdDqdTqfT6b5f3iWbtJfu2r7+lRvbkVZIeMGcvjdmtevqn4DOD5Nt31KouGnjNlMGCIZkEBqSZUB2JNwEy38LagyMLhj5CL633kLx+5OHeOstUs46C8mV/Fv3M97iDZ5FwsCF3EDVVVchWq2okQip55233UNZhgyh4Kmn6HroIXqfew5iMaTUVIpfeAHR6aTzrruILF+OaLMlg8+ShBqJIIsigsGAJkkIsgyqirphX8uQIURXr0byeMi87jpkrxdBUbBNmoSpqAgTX2A9Ih9FVEioPiRNRBFUFEmljKqBuWX8+tf0Pv88WiJB2i9+AcA3fM6XvANAs6mWUa483N6l5F/hJtKdjiG9mPOOehRn+CH6TXCE6WKMbL2MZRnDKGAQS5jDKhYxjLE7Pjf7mYeNn3EzVqwHSPkMQ1ERnkcfRWlsxFBZiejYs6zc8um5lE/fep3njtVe3rlpAaqiYXWbOPOxg7G6TIw5q5SKI/KQjAIW5+YXFyakuZlWksfXPd2M6OlgyuAiVLeHf9e30RiKMv6KYeQt6CL46htkWnspjvQT+Z8H21ln7dHr2FnrPmhINjRY91GDHmjW7Rc/uUDzsZMyOXbS1q/UuR1GPnloIu/O6WTsxbMJRxXS3SYUNRmE1ul0Op1Op9PpdDrdASZlPITqk+3U8bu2b+qkZHawpoJzyG6Xo9grAtWbtFdvvs2aA5V/gt7Z4KiAtIN3PJ5vRTLIDJDwQ2AthoyMgc2iw4G8oZ6yaLHwIa+goSGT4BNeY6T7fjJ/85sdHkaTZQKffoqmqsgdHVirqlCDQYw5OVjKywHIf/hh5J4e2m68EbmrC8njIe/+++n+xz+IrFxJoqkJTVUxlZSQfumlqH4/SjCIN9ZBzxlViMcPpphylEAA7+uvE/r6a1ImBBFNJtIOH8S4j/uYo0ToKDcw3XwK5/ArXuZRFvAFg9KGcsl1N2HGMjDnODF66CBCCLeQStfQO3CL2Ui9c3DkWCH3FKj5CzNinckA/zABXKCGw0RWrcKUn48xZ2Ow/zFupY5VAJzGJRzGyTs+P/vR4ZxKgjhdtDKNEw6oOs1SZiZS5r7Prm5b0YeqJAswR3xx+huDWIcn//3bU7d+N7skCtw4fQLqmErU/n6koiLebunmtaYuAJbYBJ6+rJyO6mXUpITw9DpxtLXt89cCoMgqsbhEd1MMT5aR1JJkGaBYME6wM4Sn0IVk3DyzWvX5CD37LMRiWM87D0NBwT6fZ3etny/+vhJV1pjyyyHkDt+P33N1+8RPLtC8M6aPSWPpP6fS441z23Pr+HB+NwlZDzTrdDqdTqfT6XQ63QGn8FxwDU3WaE7Z1UDzBBj5MES7wDMSBHHH++wr6dOg6d/J4HCkAxb+HHLPSGY3h9dD9glQds3Oj+caBqIp+b4YnOAoJ+XscaBpxDs7UXub6f7zDFSyyL7lAdKKsggTBCCNrIFhonW1aNEY1mHDBp7TFAXF70fyeOh+9FECn35CH13EzZBuSMXg8SC53fQ88QTOY47BXFyMMSOD/AceILJ8OabiYkwFBeTceis9Tz+NIEmkX375QPC28ZJL6J39Md0ePzxey3OT2rj0i2MIP/sKaiyGMSeHYMdwlOMkLFE/I375KPfnHoKIRDpZ1LCSOSSzw1ezmHl8yjROGJi/CTNB/IQJYgqoiItWI4/8DYa80wExWbak7U00QNBk8C5GNQ2i9brriDc3I5hM5N51F5aKChIkBoLMAGtZttVAsybLaLKMaLFsse37ZsDACZy7v6exV7zS8QoLAwsZ5xzHjOwZO71f/ug0lvy3ATmu4My0kla6/ZrlmxLdbkR3MpDrTWys/SxrGrUmH/ec1UOktx2nauEf0+7g+6iWvOilOkIhAVUViPhlxl82HF9rgI9+/yVRX5z08hSOunsqBtPGYHPosceIz50LgNLUhOfxx/f5POc8sZq+xuT3mVmPVDPjqcn7/Ji675ceaN4Ku9VAWb6B/AwL3d44TpvEq591cNPP96w+kE6n0+l0Op1Op9Pp9gHP6N3f11aU/Nrf8s8C90hY/zwEVkG8H9bcDuZMECRofB5SJ4J166UAtmAvhhF/31CjeTiY0xCA1PPPJ9G0lsjLRyBlxdGUeoIfv8QJl57HqzxBLsWczVXUs5pHW64k0LGW494r5pCCn5Nx5ZXI/f203XgjibY2bKNHk+jooJMWumkn6jSx7Nd5nDprLKF580i89x7B2bMpfPZZRIsFye3GMWXKwBRNhYXk3nHHZtNuu/lm+v71L1BkMkSIpZk45Lz59NGOtqIGNA25v5//u6qL1qpcwMU4GvkFZw6MsWn2cvKxdbPHocYaTnxZJHVhHL+xmZbovRhSZ5L/8MM0/d9TLKx5gcLMdRS6zKRaCzENHYHvvfeIVFcjOZ1o8Tjhb77BUlGBESNDGMNqFgMwnC0vdkRWrKDjjjtQo1HSLrwQz6mn7tw51G3XIv8iXux8EYC14bUMtg1mrGvnSpdkDnZz+sMT6W0IkDs8FbN966VRvtXf6KP6jRpsaVaGn105ELA9Pjedr7t9tEZiHJOTRp+6AmVQAcb8LGIGifpshew9e5k7pf7zJoLrWjF4O0CCwF/+QvOIc4j64gD0rOunt6afrGHJsim+1gA939RjDcQxO02oXu/3MEsQRGGrbd2Phx5o3oaErDLjlsWomka6x0QssZ8yms1mePXVjW2dTqfT6XQ6nU6n0/04OSvAVpAMNEMywPwtTSb0vyuJVtcTkyeTdfM9SBuyKjelofES/2ApcxhkG8Y5608k/NxzGHNySDnnHGJr1iDEqjHYVTQZBEkhltfBM9xNgjheeumlg7d5Aa+vCdWo8tExTYx89AsyrryS4Oefk9hQDiC8ZAmOyZOJtH8JgD9VJvVvM+lsqsbmyETyeFD8fhS/H9FiYQ1LaaKWVDIpS1QgfPgNmqLgOvZY3jK/xKr2Dznq0TcxKgqCBigQyjJh64oTURrprFJQkEnk+ukclocajSKYzbQI9Zu9B4WUcTqXsohZlFDJBA7bfPstsxBXdGNo6ifVKeKJdBAf0UL/iy/S+M7TGKKttMVlvvodTHk1jP2Le9Den4PS14eppARTSQmWoRsXirucP7GSb3CRstUFAftffTW56CHQ98ILuE85BUHQg2x7KqJGtvt4Rzx5djx5Oy4boqoan/7pK0I9EXprvcx7bAkHXzOWkTOGkG4x8cSEISRUFaMo0hwFs2AmZgaH5KDcVr5Lc9odDbNb8NV1E+3yocUNjC5pR1tRh+ew8wf6GCwSzuzka430R/ngui8w9g2lpHY1WZUSaddcvM3xFVlFMmz9bg9/W5BgZ4jMYembZUtvy5RfDmHWP1ajJFQmX1m5i69U90OwfwPN4ZbNf3B+D4IRhdrW+MDjzu4+li5fS6pLIs1p4M6XOjluvIs7XuykviPOhEobr82KcuYkIbmYwi7QNBVN6Qa5ec8mferEDY12kLfbU6fT/aRpyfqCaBu+NmlrCUDZsF1BQ92wXUQ0jUXYn7eJ6nQ6nU6n0+k2KjwfEv0Q64bB10Hf1xBej9LfCj3zsGSC6PsY37uTST13y/IHa1nG13wMwArlaz5+4xNGz0sGpCNfv4nB2IQcspBxVD6oYUSLjd7JE0iQDNYqyDRSgwMXksOJGgphjUhYhiQDqIaMdJK/YwoIkkTq+eeTekoh76kPMPSOFaAaafP0UtCuYPN4cEyZgiEjg6XM5SnupI5qFGTOfCyVyZ9mYMHKms7PmHl5A5kNfciSiiSAqIEApHUYMBgcrB3chyIo/N9fDQQKFVK9dRhWqVgsbiZXXgrfCS1MDUyn4t5viDfNwndKKp7TTgOSZT/EviDGhASqBnGZTo+X8qwskCRURUBRAUVlTUKmJORDaniL4oQDwWpFjcXIvfNOrMOHDxzLgIFRbLtutiEtbbO2HmTeOya6JnKI+xAW+hcyzjWOSe5JezymHFdomtuKxWMmd1QW0UCcxa/U076yD1SFqC+GKAkse3E1xZPzcecnS24YxeTfUwWWAh4qf4i14bVUOapIN+37xUV9zX6sbhO5g60kmnqoyG5DzMujcPogpllt9NR4KTokD1taMrPf2+wnHkwQdxWxcvS1GM8fQt4RQ7cYV9M05j60iLqZTXiKXRz1lylY3BsTINuXdTHz1jmoskZ6RQrH3DsNUdr+35WpRU5OuW8XSxzpflD2a6BZcw1Dc2z/9oS9bUFtJ4dd+enA4+c/6uf5j/q54PhSHr9xJNXtXh68sYFYXCUz1UIgYWfW0xMYOjQNbRePpUS/RI7cg9b19736GnQ63d62rV/0NrmtZ6D93f9/dxcBEDd8ba3fjo+17aeEHbS3NrdNn9tkTsK3zwkYHBdhsOu37+l0Op1Op9PtCz76WM86CikjhZ0IOhldUPnHjY8zpiX/P/fC5O+amoZkTqDaN2RiNr8C/fPBPQoKf45J2KRshKJgCCYAkKxRXPnfIDksgIC/9kgyLp4BznKKHJl4+AQvPdhxMYQxDGcCQqZM94q3mfZ+OlqWQPB/N2PPWUXBxSECTROwTDqd+tweZHI5mMsJpt+GJRAj5tBQfjadwstux5CdjSAI1FFNhBBRwsmpdfUSwIAFK/E165B7fPSWWeiekELeZ30QV8FuR/BHsE4Zx1fXr6YrN053uYw9YsLcEKf4sxCD5wVInPA/uPxk0DSoexi6v8D7WYzIUkCQ6H3+eeyTJ2PMzEwGx887jzWPzsbiE/BmCzRNFJlw8a/oVAuoe+xTzIYYLZP8lLabWfmbfDL/s4L8ehmTaMRcUY5heMUufQbSLr0U0WpFCQRIOfvsXdpXt20G0cCNxTfu8ThaLIbS1oaUk8NndyygY3k38YjK0FMH09eWoHV5HwnVSLSlD0FOYPPYkn9SSVv/2y7PkkeeJW+P57WzSqcXsu6DBiCL7KFu8k4eh/WIwxAkiaJD8ik6JH+z/mllKThz7QTaQhisBvInbH2uvTX91M1MJlx61/tZ92EDI87emIXcOKcVVU5GynrW9hPsDOPK/T4qUusOZPs10BzL7yPm/H6nMDwV5n2SvNI48ci53HtrJdMOSSXFY0TJ7kexxElLN/H6C2PIzPj2Sk2cgKcHk2nXMv5kLR2UzmTS4O6SNaQPkysFK8eYwbDrVz53PkB+oFxV1b7z/21t37Kvto3nN++jbGfs79fGWXznvd/tUyF855EFk1CIsM2g53f2FTZp71SAdGt9dmI/YQfbt3hO3Ea/be3/7fPihgVdhI1fGzJ3BUzJFaS3CMpu+hqEDYFjSKZIiMn3UvhOn832EUEwg2D8zrYNx90ic3hbgevvHmPTTd8Gsjcd+9vXJmy+TRA3BMkNG17vt9ukZH/BjGQ9bsu3T6fT6XQ6nU63x7z0cg/XEMSHDQc38CDpu1mxVaq4DFNfPXJnOwnXSbhPOAF8y6E5WaOWYC04BlOadjAn8wuWMIcy0zAOKZHxr3wXS64BY0bKhhIOGuaSLMg5HgAncBMP00wduRTjwgPAiU868X+UTvibb+gKf479eoj25WIdMpi0lK9plZbwdreXxoxM8ikl9IexGF/8grT1KsHSFiodJoyCQKy+nsr/LKHL0UXnxSKq24JcYMfypYKs9ZE5O8b4fyqsHtFF6xlFFC1U0QIhAsVmPrhCQy5cw/il+azKNRJduxhHsw9FVan8CKxxE8H3PqT9siZyAkHo+pSYoBBRWyBmBktW8ndicePv4SlnnYWvaBb/Up5GNcCoL8zMyp5H37xK3p10HwCx1GaKf/EAicZFmMdkYHw3QnRqBS8+bybI6RzOaZzKhTt37ux20i+/fLfOu27fUgMBfNddh9rWhpCVTXfLVPw+E50NMTqbV2NyWXFlW7GZEqRYu8lx9hDs62L4jRfhyjkwgqquHAenPn004d4Izmz7DrOKTTYjxz8wne41fbgLXTgybFvv5zQhiAKamoxcWDybl3PNGJK2IcAN9kwbtnTrFmPofnr2a6BZNWaiGnc1o3nT28KTtK0GHjdtb3xuwcoujjtl7sDj39+6BoBzZhTxhxuG8O5HXQBMOGJjH4D335zKlMkZbB7QFNheMDSk9RK0y6h7cFuMENIYfKUXgJr2dDT7DrIpvycbA5cbn9kabZPXLmwIgAmbBN0231fY0GvjY22z7RtG2SQTc/P9tzanLQOC4oaA4fbnv5Pv706f2+2N/92A5eY04bt9txWYFdA2CRQLiGgCFEnPIIkutvZebPP4mwQk9du6dDqdTqfT6XS63VPLKoL4AAgTZB0rdjvQTNokjMd9ihGwihv+jlaim/dRY2iaxrTWCRzmPgrJ6YTLIO38nyOIUVj2G+TW1WB0YzjiehLt7SheL+bKSuyCk0pGbTac4vWihsOo0SioGnJUwCu24YyEcMtGErKXI4MyLwjDcD+9muI2geohIhmdRsyvLmbdkmsY8cB/aL3+eqT6eqa4XIxSJuI7shTHh//D391ArDeOxehk8ntDOfhVI4IooqRlEA+G+fwila6pGViGDmXp0VauOD3GulaBmpEqOauhdAH4SiW6h1mQBANINhosIR4rXIvTG2bi+ypi51q6zh+GvW4R9lUWHIccgmAwcMJBd1D72ifkfdGHkpdKONhN1XO/xLS8k5WDT6LRdSZ/7r6blr9eQWqfBWGcwNe/thB0JN/zmbzOYZyCm5TdO5+6A0Ji0SLUDTXHtc4OitP7aKpPBw0sbgvat5UIoxGq8toYlNENtOKZ4Nnnc2tf3kXDF82kDvJQefyg7fY1Wgy485w7PbbJbiJv7Pa/F7lyHEy5/iBqP23Eke1g3exelrzZxrhzBzFocjaDphdidhjxtwYpnpK/UzWadT9++zXQ3OxcjcO1Mx/ETYLK2rayXXf0OPlc0bGwKjZik3Dxpv1aWBkbto059NJI73bG3vJYcSEVGY1kJuTWgp6bEtC2klkpKgrQA4DPUopqkbax/3dt7xb67/bbMtsTjICJ5Efk2+xJIxrShiDkt89v/bVsfR4iYEmOI3wb7P3u9k2P951b/b+bvbkhYKwJ3+2/ab+tbbPzfdcG35+6WLtPx08QI4CPBHEUZFRUVBS0Df+pGy4OqRtS+zd9/G1fGRkNFZkEZ3EF2RTs0znrdDqdTqfT6XTfhyIGY8JCnChGTJSwayUXtiB+J1Er5SDIPBz65oF7JKRNofaR2wjPnYdLdZFz++1YKisRrVbACmMexVheB/ZiQovX0Hn33WiKgv3gg0k5+2zk3l5so0YhbEgI8/xsBsHVy8FqRpY1XjXHcJeJFJi8pEVEUls11NQEBc+uIW2uAc96mUNfj1Az3Uiu3w1vzaYxcCmhuXPRVBVtfZwMRxoljjEsiLWR5o2gCBoxJYSxsxNjXh7x+nrUYBDR4cBcWohlWDYIAqo/hBKOk10jkL0EEEU0VGx9CvlTTiOTXBQ1wAcBP8IyH2PukDHXxzFgIPv5ldS//xsyjAWYS0rIvfNOXOnpTF84mL7mhZiaIxQvWohJkagsMlDof4+SS39Gan4WCUspMu0ApGdUAksBsGDDgp7B+UMnFRaCKIKqgiAw7g9H433JT93sLswuExmDXRx540jU9fkoD3yGFgLTxImIWVn7dF6hnjCf3TYXJa7CJ40YbUYGTS/c5XGCXSFm3jqXQHuQ4WdXMnLGlotVbk/x5HyKJ+fz5cOraF3WCcDnD6ykaHwGBpNE/kE5cFBywcDlr64h6o0x5OQynFk7XmRR9+O0XwPNdmECDsHMzgVDN7QECWGzwC2btYXNgqZbe35jf2HgVvitBR33PHP4JR5jvqgSEnb/bTYbVV7b0L7H2E/MqC/Ypds/BASMmBC/LR8BiEgYMGDAiPhtBvRATvrG/286Bt/Z9m2e+bd7zuQNzuXX39fL0ul0Op1Op9Pp9pkMcriBB1jHcgYxjBx2PVC0XYIAZb9B0zR6n3ySz949gvfHLEYcb+OEd0qwf/QRlspkTVVNVdFkA6JnJACBzz5DUxQA/O+8Q3D2bJS+PjRFIWXGDOxXX8gjFY/R8koMX08O415T+XRaPT2VZrLiZi5Z4CNvDcQbRbK9Mmo0Qdii4EEkb4VGXnMELRGh46PXWHhsmKEzNRxhMDU1EXj/Q1KX+DAEZeIuA6EMA26bnby//pXW668n0daGISWFo+eXMfPkDHqXz+XQpyG6sg7VBJgNiJqAgAFzEMRrnqdHGwmJBBa/gtlmRPBHEVQNTZEx9agYbHGibSuJrlyJGgiQ//DD5DfayWUcIKCFE2CUcDlEPBlWvs79L58b38f1iJML55xFftpICisrEfkPPXQwnZMxY4G++dD4LzClQNm1YN73i7/p9h5DaSnO224jsWgRxtGjMQ2t5Lg7NNZ+2kbEF2fI0XlYnCbIHIr6zDNoXi9iXt4+v/M33BtNBpk3CLQHd2ucla+tw9ccQJE13vvjYhb8t4XhJxcx4RfluzSOqm6ScLmV3MslL6yi+o0aAFoWdHDa00fv1nx1P3z7NdCcb7gXl8G1P6ewTy3hfwjEKSRjt8cwIQPJf6wFlBLfv6dM9yMUI0IAH1HCJIgPBJJNWDBiwombMqpwk4KTlOTq0xiQkJAw4MCNCw8mLBgwICJtKNwhDQSPxYGSKZs/TvaSNhvPhHmHc9bpdDqdTqfT6XZb29vQNxdcVVBw7i6Uw9s92RTs1B173bTzBs8BcBoXbyyx4V2G1vBPgvOr8S7PxXXCmbiP23yNjfCCBfjee4/Z19TQnRkhkhrn/85ex/S65HHjjY20/elPKP39eM44g7QLLsBSXk5obrJkpKooaOEwsYYGBCAwcyb1BT20ntWAIShT8Uwjjm43aWOddIkxvBaRdYlDKH5qMVZBY/aDUY56WMDRqdI6wkiVMhaxtxktkWDe6WEWHaXi6ZSw+qBofTtq3WrCg8yQbUaRZLIiMiTq6HngBhyHH07ns4/hC/jIHHImv41fRcPNp6N4vQS0KAk1iuoWQQNrQIR4HDUapefJJxFEkXGNnbiPTEOwxjHLMrKkEksz4wka0BQFKS0NJRAgumYN1tGj6X3uOUSTiZy//AW5s5NEZyfSaYfxufleAPymAAun+xnMCABO5aKNb7ymwLr7QI1BpBma/gWDf7cnHxfdfmAaNQrTqFEDjwVBoPLILRfIEx0OcHw/dZnTyjzkjs2ibVEntnQrZUcU7dY4Jkfy7gRfZ4JoSCERU1j6v/WUHZpDWvHOl9o46LwyAh0Rgj1RDjq/bIsyGb6WwEA72BlCkVUkg54o+VOkRy33sW9Da7u//+bZoHsylk4XJkiUMFEixImhoWHGjJMUiqmgiMHkUEgWBaSSgYd0ssjTP3c6nU6n0+l0uv0r7oWW/yaDwvkzwLibCUuBNbD+6WTbvwpsxZA+eW/Nco+8wAM0kFxDKIiP3/LXZCBz7Z0kmmoRo61YHC28vXwF8anfMNlxGhUbgp/fEhHx5QgIRgm/00rT8FxSAO8bb6D09wPgfe01PKeeivu005A8HhKdnfS/+iqhr75CDYcxZGQgSBL2uJV2Ghn1SB1Vb0ZxRCGlyUneK0djNjg4vvwMtKxrUSJhchu6Eewi4QIDmV0GPMMrSJjTCc+fjyYJGAvy6TzJQvErTcTkEJKo4WhN0DvJRfHSMLI/RDgWJrruC3pqlvPIW0EidpVM5WHuM52OKT+faDyOFk9gCCtoYYVYqhESiWTJA1mmRljJZ390UzgvwREvJMi44k/4P/kEpb8fub0dKceOJogYSgtptrXw2aC3mPTIKkSzGTUWI7RgAXl33glAlAhmrMSIAOAhbTtnbtNMT3Xb3XT7RdPCbj5/YCWCKHD49cPJG7m9c7lt/et9rH67FnumjaozKjYLoiaiMoHOCK4c216rUyxKIoffcjChnjBWjwXJuHvjDj+rkpg/Ts2XnQgOGVESEQQBg3nnx+up99NTF+Cw64bjSLdstU/lCYPoWNaFElcZclKZHmT+CdMDzTrdj1ycGGGC9NCBBRsO3BQxmGIqGMxwCimjgpEYMe3vqep0Op1Op9PpdFtXcx/4lifb0XYYcsvujSOHNn+shLbebz8IEdiyramgxvk2mNlW5Oezg3qxGueykhXcyjOYVraS6OjAMW0a05cnqB+tIDlSyBGK0DaskyKlpg6MLdrtCBYLqt9PdN064vX1aNEojvElCNFGZMWFd1oB/z57IZ1yE0IwhmwWsHglmirt+IR+VF8zj3MbN9x8LeqcJRy+fg3i8jmIMQWT2ULc3YRot2MbPZrjelIY9FwDqy/NwxYbjlj3EapZQUyoOFriyP0RtKgCWjKz+otjugiaIeI2EpW6mBt+F+m+kaTMycRzj5fw4sWoBjDFBKSsTNR+L4EUlagphs8SZPkJFoYYhjH06quJVlcTqK7GV+nind/2oyUSlDgM1A9PJ5ZWTUnDfLK6kmER/9tvk33DDUhuNxasXMGf+ZJ3yCCXIzlj6ydNkJLlMpr+BcYUKLxg738wdHtk7lNriQYSAHz9zDrOeGTSLo+hyCqf/HE2UV8cgObFfbiKUrA4jdjTzSx9bT3B7ihpxU5OuvcgTLY9C7V11fj49O6ltMxvI73QxOTfjKH86BI0RUGpr0dMS0Pc5N/09hgtBiZdPYbxV6jMeXINvfUBhhyTjzvHtlP7d6z28s5NC1AVDVuKiTGn5xEPxBl8VDGOzI11mPPGZHHGP48jHk7QtqiTz+/8mvyDshl8VMluvQe6Hy490KzT/QgpyPTQQQAfFmzYcDCcCZzMBYxgIi48+3uKOp1Op9PpdDrdzot2bNJu3/1xPKMhfSr0zgX3cMiYvudz21SkHeofTQaHSy4Fx+Cd3vU0LuZf/G2gDSQX/yu5AoP2DAmvkdWSgKlQRTSbSRCn/d9Poz3wMobUVIy5ueQ/8TuM9t/hpZc8SqhkNAApM2aALJPo7MRz6qmIJhPt99xDeMECVpa20jShiTOyRVwxAXO5hyemevEbA8iyzKwLVDLqBVL6FeRJ5Sh+P7GaGqJA71cfU3Xf83DjjfRG54ECWiKEGokg2u3EGhowCwJDezMZcX8K+Q8+SPXTE2jMbSJkT5C+Psii41SWHg3HPADOLo1gKji6wRhNkHBC8PZbaZ+awooLUrlm1RjM8QhNxgYimWZMGakMei1BxB2gdaSB7nwZt2Ig5dxz6LjjDmI1NUipqcya3khXuhUpxcPqyjoKKEVAoGmCmbSmGEaTHUNWForfj+R2AzCYKgYnCkCygrid0En65AMmK163JZPdsNX2rpAj8kCQuasuSM2CIKLZhJJQcWVbUVVIKbDTuz5A6/I+SiZm7tGcP//bShq+aifqSyDHVBY8tYzBRxUTuP12EosXg9mM6447MA7Z+YX9JIPI1F8O3eW5tC3vQ1WSF7p6Vncz58EOLE4T9Z81ccpTRw9kLiuyCgIEO0LMf3wpAM3z2nHlOckaptct/ynRA80HONkk8u/nRw60dbpt0dDw0oOPfkREPKRxCMcwhikMZzwp6N/cdTqdTqfT6XQ/UPlnQf1jgAB5Z+3+OIII5dfvXN9oBxicEG5Klu0wpULxxWDYmMVHuAVqHwAlDMWXQtvrGzOva/4Go5/Y6alVcRD38cqWG7KPQcw+BvvBcAQdrOIP9NPN5K/y0R54GbmtDbmrC8FoZFb0f6Tbs/HRxyoWch+/5Xfcj81kJ+2iizYbNtHSQkv6MkxHdzBcEImpgFKCwePBEo9iw4HRYCWclaD+KCu2IUWccMRDrGu+gBgwZlEm9qYwHffcg++Tj9ASCSS7HQyGgbrXxuxsFL8fNRgEQUByuQhfdhjRj18mocm0l6t8cpWKqIisnaJSuBQmvQQRNwSzRI54wYzNGyP3tQY+PruPr60+xgZ6MdsNLL5xCL3DHQw5+goWWP/N0ikhohY/IziMor914P3kE2I1NaBpDPlSpOmMNKSyUnLjMUw17dRmtBK9Lh170E9hTzqZhx2PqWCTWtoNT0P728nPwNDbdumige7AMf23VXz97DoEUeDgSyt2awyz00TFCaUsf3kNvvYIqmQm7A1jcpgQDSLhnihgRzKIePJ2LlO4dXEnoe4wxZPzMNk3v7tYkVXEDQFcTdMwu8yonZ3JIDNALEbss892KdC8u/JHp7H4v/UoCRVRUDFZk2HEUHeEeDCO1WPB2+Tn45tnE/XGSC3zbLZ/uC+6z+eoO7DogeYDnGoUmf+LHS8cofvp0dBIEMdPP2GCaGhYsVPGMI7jHMYylTT27EqqTqfT6XQ6nU53QMg6GlIPTraNO7+A1W6r+wd0fgSiORlEFjbUMxWNUHrlxn7rn4FgcvF2ah8AS+7GbUpsr08rvWsVtwbHEk0fT7R+NX0pa5E7OtBkGTUUwrMuQuCgXmRDAgs2Ommhtms2Of9Xh2izkTJjBqLVCkCPtZ/0oe3EEwr5CNhECZPQgdzv5DTlflRmIyPT427HKHVg6o9jeW0+t415ksaH/ojFr2IqKqJ94ce0ZHeQ1iNjToRJOehwCh9/HDUaJbJqFa3XXguqihoMkujogKtPY/aR81hvb0QVNNRYBEXUePnvcSo/g9FvqRz5rAmzZKdgjYG6UTJRt4CrWyD//U7koixi9JC6PEBkTAGDT7oCG60YmEmlVsoF/6mi75lnUWMx1EgENI2irySm3NVP/Y0q07+uIOftZv76+w5kV5CvnhlJcaSYSY5rN77RiUAyyAwgb2jri/z9IKUUODju1jF7PM6Ey0fhyLShPbyUtpoYiZiG0SriyLRQdVIhrmwbReMzSCnY8WKB6z5sYN6jS5LtDxo4/sHpCJssSjr16qF8HlPoreunZJyHKb8ZjeixIKSkoG2otW4YNGiPX9POyCx3c/pDE+ltCCCJKnMfXIASVymYmIPFbQZg9du1RL3J73c9a/tIHeTBu95PVlU6BRNyvpd56g4ceqBZp/uB0NAI4iNEgAhhQMOEBQduRjKcMUymnBEMZay+eJ9Op9PpdDqd7sfn+wgwA8jBZJAZQIlAeD3YNwR1Ev7N+wqb/t4tJLOaa+5Pls4YdPXenVfPV1D7dyTA3vU5hoP/gP/9TKyShOLzIdjtTHmwjcJTonxxlJPu9EEYMWG541UCzR24ypuI/Pc/2E+6k7WpVh6/aCHntUk4DCqmEMQlM9p6A8FF9fTd+EvOe/llTqq6gAfmH8+o1+IY6aOh7h8MHfo45X97kkRbG5ahQ1lwbjGaL0JPvkokVWF0by+Bzz4j0d5OdPVqJKeTaIaZ9fa1vNp5Acdn38qkyosJ8j8kDATwso5lyAisO9aCWpnKhHsH41kbwlAskO82UXdYJ4Mj6dgNHeTIRYiIxB1DKOck/o8nWc9aXKQQ7+tm7co3KDOZkFtaQEwufCYAI+c5mXSzGVO5nRhQVutm9Qg/hrDCQX9ppKHhLMxDhmCfOBHHIRORjK6N59ucNXAamqnjee4jRoSzuYoRTACSmaeKz4fkciGIP827kTVN2yxg+mMz+Khi6mY2YbL6sGfbGXPhCKweC7nDU4mH4sRDiZ0ap31Z10C7r85LPJTA7NiY1Zw/Ko3z/33oFvu577mH2MyZSPn5mKfv5bI/25FS4BgIoGcNSSXSHyV1kGfgXNszNmZxm50mjr3vUCBZH1r306Of9QOcKKsM+agbgNVHZ6DqK3f+5CSI008Pfvpx4saBmyrGM5YplFBJAWW4Sdnf09TpdDqdTqfT6X4cJGuyTEa8L1lqI+sYCDWA0QP5Z2/et/jS5AKDSijZdpbDmKf2zbwizQNNxdtNuPo90i6/HFN+Pj1PPkls3WoyRleT15tgwrrBrJZHkJl9KVr7H7AVt2PN7UZUorD2XtaNOxIpP4eZQT+HB8MYxBSMfieR9nr88zXiNQHWn302xrnP4YrbUVEIEKaN9RTH+jGv9aPF4/jfew9V0OgoV3E3gaSpxNeto/O++0BRiDU2gqLQatDoqUync4iB13mGW3iKGVyFisqvOAkHLqJEMEkWDio7h6pTp9J48cXIsRjG1QkObytF+8JG0VUPEf98DqmFJ9FwcoDn+COufgNdbi+lcgVCbx8NmQpDC4eghsMkWpvR4jKi1YqpqAhDTg5pF1xA5113ccp7Q5hUMh7XmzHs1QuJdzUS/PJLQnPm4H9/CPl3347Q/jaYMzeedznEF6G78dtaiBqNvMQjjGACajxO+5/+RLS6GlNxMbl3343k2HFm674UI8oKviGVTEqp3OfHe/xVPx/ODVOaZ+DWK1JxOw+M2IWmafQ3+LCmWrB6LHs0lslu4vi/H0akL4KmaVhTrBhMEh0ruvns9rnIUYWKE0qZcPmoLfaV4wrznluHtzlESr4NBECDrKr0zYLM39W5qoeVr63Flm5l3MUjsJ1//g7nOeepNdTN7iB7aAqHXzccybhn5yIeihPsCuMucGFLs2JLs262fdjp5SgJhUB7iMoTBu0wwKxpGq0LO9BUjfzxOT/qixM/RXqg+QBniKlcecICAH4bPIa4Hmj+SdDQ8NOPj14ERDykcwSnMZXjqWCknrGs0+l0Op1Op/thi/UkA7qb1jveWXIYOj9IlrXIOmb7C7XtDkGCYXdB+zvJIGPuyYD4nezlDay5MPyve/f425J+KHR+gOJtxT+/ne4vPwXlUwqeeAL3scfSs34lkjWGITMbW9jL+JpFIB1H/4wZyPNuB1HEmJMDmkyFNoyP09LpnZjCx1oKg6K/g99cif9jjViLCgYRLRIhr9mG5+DDmPWzJfjSFIxOhTXS3+gKryRvcZzpL9tJNcu0jNZ45w8gAaFXNQ75SiPkawc1hiiIxK0i31zkQDSJtFDPbziVQavtnPp2OYdnW6g+FxKGBGasjGEq3tdfB1UlpgQRozL90WZy+tNxFAzCctfxLGMer2jnMfq+9ZTNVvj8SolAkYzTZ2DwpybksB9RbcOUlUD2q0ipFlLOPBPPaadhzMyk+KWX6Hr4YcT7P0nWkDYYUAIBEAQEUSS+fj1KzINh8HfKaSy/limx2VQYQ7w+fCgmS7J0QGTJEqLV1QBE162j+fLLMWRlkfaLX2AdMeL7+XxsQkXlIf5AE8myLhdwHQcxbZ8dr74lwftfhQGobZZ5/6swPzt2/wbaIRnQ/PwvX9PyTQcGi8QRt08mc0jaHo0piALzH19K68JObOlWjr5nKmverUOOKmiaxtp36xlzQdUWwdblbzSy6r3kxaKOapFjbp2MGpfJHZO1tcMAoCQUPrt9LomwDIDBbOCgS7b/eWpb0cfKd5oAaJjbydqZaQw9Jn+3X6+32c9HN84i5o+TMSSVo+6cgmSUNusjGURGnzdsp8dc+OwKVr9VC0D5cSVMvHL0bs9Pd+DRA8063QFCQyOEHz9eooSx46SQco7nHCZzLE7c+3uKOp1Op9PpdDrdnlv/HLS9kQwUV/4JPCN3bf+1d4NvabIdboJBV+31KWLNg9Ir9v64e8KaA6OfIvrVB3S+fxeJ9WsA6P773yl88kksw4Yh1t+FFP06mf1sdEPt30k54WmUaW8iNt6PIHdB/pmUm6ZxHbmskL9iQdN/eVO4kEHTOyldkgMdnQgmE6LTif/Ntzj+khN49ZwnUTUVT0OUtA8+pmiNmb4clVaLFznHRfXxJuRUIA7f/MzA4LAT4asEVhGiFpXCGisTlxbR4jHi+XctksNB+nwvrbE1VGipXPqpgDHkxBrQSFTdj9xpJypECNtlbLJAJNWAN1fDVFwMwH94CKW1gyEfKUgxOOP3CtGCOCX9GVjr+lDSutGiYRQfaIDa24caCmHMTK5hI/f0EPjkE5RAACUUwpSTg3XECOKNjQhmM1o8zvoLLsCUm0vOnXdizMgA/wqIdZJLEVpiPQd5nYzJvgEAQ0ZG8kKEppFoakKLRFD8fjrvuYfil1763j8qAXwDQWaAahbt00Cz3SogiqCqyccO2/5NjJrf46M9EmOsaKblmw4A5KhC3czGnQo0q6rG6g9biPrjDD22AKt7Y8ZxX52X1oWdAIR7ItR92og900b3ml6i/jjObDub5oXFQ3FC3REivo012xVZxZXnpMUa5rJlnyFrKtcMHsXYlM2DzkpCHQgyA0S8UdpW9mG0GMgoc2117uJ3khP3NJt5/awWYv44AN2r++ir95FRkbrVvk3z2qj9tJG0QR5GzKjcaqZyPBSn6evWgcct33TAlVt00/2A6YFmnW4/UpDpp5cQydpfVuzkU8pYpjCew6hklJ69rNPpdDqdTqf78VATySAzgBpLLrK2q4HmUM0m7dq9N7cfAsmCZdxRkLgDAMFsJtHWBoAxOxsyH4Cav0HXpyBZQFNBjSBllELGY2iaRmLtHKSvf0W+APXPzeNooZaikVH6ikTSf+4ksnAkotNGpMlGaP58vsmag3ypjJyIkBDAJJvIXhyh5SSVrlyJ9GAcg81Bz0iQIjJR0clj0+K4VuZw+HUtGBICQ5UqjomeQtf5z1OXFkeUezB3xzHkGpG8EXLXx1GVOMa+GEr3MrrCIs8+LRM1wLA5JrJVF4XXX07fS7cRXhsgbUothy41kL8CbH5QTALGpjgmoQNNFIk3NSFooMVBMIFoMRJvaEBGJk4Mi92OlkgQW7MGNA3JYqHo3/9G6esjsmoVPU88gSAIJNrb8b/zDmkXXUTUlkVY9GNWRUqEIZTY7wbKATCXlpJ1ww2E5s9HSklB2bBgm5ZI7Je6xU7c5FNKC/UADGHfZoxmpRn43fluPpobYVCBgeMm23a80z7ySXsvD69NZg6/azJyRKqZeF8yyJtSvHPJWwv/U8uS/2sAoGFOF2c8Mmlgmy3VgmQSUeLJqLojO3lXhtllxmAxYM+w0fJNByVT8vG3B/nwhi+JemO4C5ykFNjxt0cYfkoRriwrTy/9hu5YBIDH61bwzLjNA80mm5FR5w9l2YursaZaiEQNvHPTQgAOvrSC4ScVbTH37CEeDjqvLFk6Y1gKg6fv2WJ8nqKNAW2DRcKRufVzG+gM8eU989EUjZb57VhTLZQfXbJZn9Vv17LgmeX4WgKY7EasHgt5Y7ed0a37YdIDzTrd90xGpo8uwgTR0HDhYRxTGcMUqhhPIWVISDseSKfT6XQ6nU6n+6ERjclyFLENi2FZ83Z9jMwjoe3NZDvj8L02tX1F7ulBdDgQLbtXHzayYgX9r76KISOD9EsvRbLbSb/6avpffBHRYsE6ciRrWU4nzYwUJ2G1nEy8+i0kUyvGURdhsCWDUZqm0XnPPYQ+fBpRiuKelo29rhXTKAUprmJP2HCXp5E6wkakrgklLUrr0lxW5ocoppxO1qMZg+R2uOgqDmMOg61fIeSI8qsvL+Bl5xKW5q7DKQisL2qkdniI2M1GRsx3kmksx/Tmm2j1LWT7JYKlboyjs0ntdCFHO0jpMhCJBVFNAj5ThLa0GCGrhqSKrDzewPSnciic9Si9r6wFwcj4JUaicYlIqojNr4JBw57pREs4UPwhtFgMTQPRBKgCmjkb+aoTeWD+CSSCPiqnXMCUY44h0dyMYLEgeTwkmpqwjhiBlJpK3/PPoyWSC7tJKSn008MtlmsZm9lGqS9OesH1DHGWb3aeHJMn45g8mXhzM51//Suq30/apZful/qzIiLXcDfLmUcqmQymap8fc+pYK1PHWnfccR+r9oUG2p3xBONvnYR3VhvOHDtlRxYTVRQ6I3FyrGZM0ubZvqG+GJ/ctZTqD1swmCXcuTb6GoOoioq4oa8tzcrhtx5C/edNpJZ6KDu8iLalnbhyN5YKsWzIgF4/u4WoNxnk9jUHOOquUWRVpQ98JizSxpCcVTLQWd3DrHu/QYkrHPzrMRROymPEWZVUnVGBKAo8d+bMgf51szq2GmgGGHN2KWPOLt2Tt3FA8eR8NFWjt9ZL8ZR8rClb/z4W88fRFG3gcaQ/ukWfpS9WgwauPAcWt5mJV46i8ODd+BmgO6DpgWadbh+LEyNCCC+9fFvx30UKZQzjOM5hGOPIo3g/z1Kn0+l0Op1Op/ueDP0LtL8JxhTIO33n9tE06PkC4l7IOwvSpyZLb9gK9+FE91zXAw8Q+PxzJKeTnDvvxFxSsuOdNqHG43TccQdqJIIiaih2IzkXX0nahRdiHjQINRSi/jArz3IzAJ/yOpf8w01iTRqQhnllO/kbklmV3l5Cc+cCGmpcIdYcIl2zEWjPQsptIts6GIPFAAYnvXkqUqSfdoOKXFJOKh48pnQ6rKtYcKyXiGbgkH8pZNVC9zgz4swlHNVkoONKCz5jB1aPFcntonmqhHvqOIa+YqC9TKE7x0LGVz04fB5Kr7+JlKoJNF5wQXJhwR4/ikWkp9zA4iMUNIOCDKRGneQW5JII1RPpjaI1e0nxqYBAW5lGKEtAdmpEU/sYWm6i63Ul+YIFA6osYB01isFffMF7b19BxYtLAOiZ9QCGX/wfljlzSHR3o8XjCPZkZqrB4yH75pvxv/8+xsJCLCceya1cQXbTFwzuiGHFjtj8EqRfvdVzZioooOCRR3bxk7L3WbExgcP29zR2m6ZpzH16La1Leykan8GEX5TveCdgcoaHzzv7UTSNKreDkuIUhJJkqQdvPMF1i2vojMYptFn465jB2A0bk7yW/a+BzrU+rG4TPXV+7Olmqo4vHAgyfyt7eAbZwzMGHueOyuKgS0fQuriTvLFZ+DoTvH/GTMJdAQxKFPuGLGhHtn2zCw+/KhvJE3UrUDSNS0urWHTLIiJ9yQDt/CeWUTgpGYQVxeQ+2UNTaF7cA0BmpWcX39HdVzK1gJKpBdvtk1bmoXR6AfWfN+MucG6RzQxgz7ThXe9HQCBnZCZFh+x+7WjdgUsPNOt0+0CCOP30ECaIiIgDF6UMYTSHUMpQhjGONDL39zR1Op1Op9PpAJg1axb33XcfixYtor29nTfeeINTTjllf09L92NlzYHSXSzK2fJfaH4x2e6dBSMe3Pvz2ssSXV0EPv8ck8ePZO3B//6bZPzy2h3vuClZRo1GaSz08+qMGtTcBs4hn0OFE3FOS9bcbQ/+hcrObpo9bvrMXUTCMl2sx0sPYqiFNMJYsSG6XIhuN3IoF0FtwVJWgP3YM3F5DdhGDMY2tBC8i9HqniZijFFzWCGfXTmYDEMBJ3IKPbTzUZqGVtmHur6WnmERlPkCZcpQRIeV7D4zlz5VxYrsWtZckke9O0gQH8VUUGEdzCtlr9NWGKX/wjhHP9mEcs6ZZIyejtLcjOL1ormsrD04QbjQQqYxi+7xVuzrI1zVci2pNxzMI8FTmXhLEIdPxZAAUybklkL/GPj8UAmPCmO/CiJYHIhysq6taLWSefXVKP39mF74gnDAi2CxkLnMiLNkCIarrqLjlltAkuj4858peOwx5O5uEu3tpF50Eaa8PNppIoCXsX4Rs6KhSDKZEQFUebcXotTQqGYxRkyUM3yzbbP5gLf4J25SuYw/ksVPM+OzYW7XwKJ2/c0hckekUjAmfYf7jU1z8ehBFXRF41R5HJsFduf1+OiMJusNN4WjLOsPcHCGZ2C7wZIMOttSzeS70znhrnEUjErWdI4r6hYZ0JsaclIZQ04qQ1U1nj39U9pX9BMNJDCbNcZPzWTcL4biyNi87ESu1cHtVRvLctTYjANto23jZysRlYn6Exxx43DWzWzHaDVQftielcTYVNuSTpb8exUWj4WDfzVmq1nLiqzyzZNLaVzRT6Qkl4lnDmJI6cba1YIgMPm3BzHx6jEYTFu/Q3v6Hyex/JU1GK0GRp07ZK/NX3dg0QPNOt0e0lCJESVKhDABEiQQEXHiporpTOV4KhhJNgV6vWWdTqfT6XQHpFAoxMiRI7nwwgs5/fSdzDDV6b5PgWQtXSLNEFgN2cdD5hH7e1bbJTmd2IqDuAYlF+0z5MwE7RoQvnO7/tdf0/vss4guF1nXXYcxN3dgm2izkXbBBfxH+wMJlwFzbi5v8U8O5cRkB99KplTPpFBbT8hkZPao4+HSI+m4fyZoIisvc2LmQ47gNLREAtFgQO4NYswZQv/yVOR3/40ai2HKz8c8eDCuc2fw3/YaWnODNPZGsQplHMqJmLFgxkYexXSkg0twc/SyTFKCrSTmVmO99FIsgwdjWbWKwoMuwDk4jMgsumlnbefnrPnP61SFJAbJCrPOVYnLIcztENUWAQJqOEyaNYtxH/ZApotEgYsRtlGMOfWP5A8tYTnzaTWV0DfSj63Dh2hUMDhBiEHKOJH0TCNKSOD2iWEMmTLj3zWTX2/Gak2hWluE6bNq8nsy6O3tQ9XiZBw1BSMmgp2dSO5k3V7F76f/rbeo+egZ5h7Wg+NdB+ed/jrp6TlM7LUysk8kMwgGswdHybm7HWQGeIXHmMOHABzHORzHz4BkwtKrPIGGSpQw7/MSF3L9bh/nh0xV1O881rbRc0t5Ngt5NguaptHwdSeaBiWTMim0WzbcYwySIJBrNW+236gzSgh2R/G2hBh5avFAkPnhNU180tFHrtXMXaMGkWY2bXnQDbrVLj4/9C28mVGGfjgJu8ODKc29zQX0NjXp6tF889RylJjC2IuS5U76GgO884dFRP1xSidnccQNI/ZqORZV1fji7vnIkeTFmUX/XMnka8dt0W/tu3WseLue5WtiaHTybq2Zu27Op6LYxLJXVrP23To8xW6m3Thhm4FmZ5adQ64Zy9L/NfDOHxaRPSyFgy+t2C/lZXT7jh5oPsDJJpFX/1E10NbtXyoKYULIJIgRIUqycL8JC2Ys5FLMOKZRzkiGMgYPO17RVqfT6XQ6nW5/O/bYYzn22GP39zR0PwWaBtG2ZNkMwy4sGJYxDTo/gFgHGFOh9mFwDktmRx9I4l5oex1EM2LOiWSeYkfrEdAMGRiygIQXTBsDTpqm0XHPPclawUYjPSkp5PzpT5sN6Tn9dIq19XQLXwBga4vTdOtlGDIyyDqvCKfmoIwq4vEoo8NX0DsqlVn/GYNGMjBnwYYSDNJ85ZX43n0XNI1EezuC2YzS24sajxFra0FLxGh8YwarDm/Fa7SiihJHtR+O0rWaz5v/S9fBKWgZHtzhIGkxyPy4Fc0RRUk46XvhBQoeeoism27C+/rrjJsxi0W/XkP72H4ya/34olEckhtDwkDO6gSD5oGggdzZhWAyIblchKQwCTWIzw1OrBzcM5F0krffe2Y3c+iTNQiaiUiGCVNzhFgXOLNBbBJpPnwUS1iJ6JcxlEcZ9k6EPreTcHqc+PsvMvP3Ni6UVdwdGpqsYqpupf+VV7CNH4/3tddQYzHUWIzuhx+iy1hNeJSZldPMOIKPcW76Xfyss5ywsQOTW8KiGaD08j36mCzj64H2UuYOBJoFkn/z99ODFTsW9t+ievtb6eRsmhf30rqkl8LxGRSO23E283fNfWotK99NZkUPOSafqb8cys1VJazwBhmX6qLYsXlNaZPVwGG/3TzDfH0wwicdfQC0RWK839rL+aXb/r5zZ+BOuk+spTW/FzUrxknfnEtOVQoRRealpjUE5QRn5ZeTY7Vvsa8j085hf5y02XOrP2ol6k9mYdd/1YnvvDCevC333V2aqqEmFDRNo789QezTTkqP6CN3+OaB8URUpqPGT9SfDApHeiKsa0yQbYyx7MXVAHQs62b127WMOmfoNo/XudbL/H8mF3TtqQ+QUeai/LDcbfbX/fDogeYDnGoUmfXL4v09jZ8sDY0wQUIEiBAkQQIXKRgxYcfFSA5mHFMpYQjZFODCo2ct63Q6nU6n+9GLxWLEYrGBx36/fz/ORveDoamw+nbwLgKDE6ruBtvWF7PaQsZ0KPg5tL6a3BcN1Mg+ne5uWXtXMuMaoONdJKkPHIDWBcYRYPBssUu0uhp1w7+h6MqVWx32VOEifPQjyBrj/7yQRGc7ifZ2vJ9D2mgDFs2KxVxEpDGB09fEWRMu5RvjLIooZxJH4nvzZWK1tWjhMACCKCIHAgTcCboLVPyZnUwcN4+hhVGmCFFezYsRjJjh1meRl7RSnmWi6PV2Hn02AlYZwRTFN0PgiPtU8AdwhIz0/utf1N11E0pXD0bBSNFgOysz++kcYiXhMYEXDAYLpSvh7dtlxKjMmX8Gu2xEDYeJuSXCp9jwSDG6ZS/uE04YeP3Kw/+lzJ9P0BDE5DSCtQVN0Yh1wfp3VYa3dlF7sUp7fgK7DFEHOBeFiWkCvUUmrC3QlhZl1Y0y1oiBIz/rxfbNN6TMmEH+o48SX19P9z8eQ1MVlJhG0dcxGo50EshOBn4N9nJc3uUgArZiEPZs8fbBDGcJXwFQzoiB58MEUZDpp5swAcYweY+O80MmigLTf1OFqqiEeyOoioZk2LW/tZsX9WzRnpDuZkK6e6fHcBolHOsC2L7qRE634L46e7v9u5QuLE4jJQdnklli4/gTx1J0UAYP1Szh085mVFVjeVc3zx5y1E4d35Wz8WKD2W7A6tl2NvXukAwik349lk9uX4C/T8WYKvLBbUs459kpWN0bj1U6rQCTMAdRMtDmziCmCIwbakZUYwykiQOScfv/NuTY5pnqclzdRk/dD5UeaNbpNiGTIESQEP6B+so2HNhxchCHUsFIRjKJDHIwY0Viz37B0Ol0Op1Op/shuvvuu7ntttv29zR0PzThpmSQGUAOQNdMKL5o5/cv+jlEGiBYB1nHgL1038xzT0SaN2m3gSkN5FDy+XgP1P4NyjcphSDLGHNyiMsygsGAsWjLwLuCwrPcSx2rMAgGhltlIBkAUpVsGHkFhNfjX9hN96O3AzBoxAim3HnfxkEkKVmj2W5Hk2XMZWVoiQSNUjJ42jlYg2EBIh4Hb5dHiJk0+h0yvZ4QmV6JkCeG0StAXEawWkBTmXuMQso6K2WvxwgNsiOEu4h1t4OgIcfDjH0iTpdbYvVVOSx7OBvHV00IeRmsc9UixyI4Q2a+vlrmsEcSRI0JVl0PI4sDCAYDLkeERKaJbyvWxurqkFpb8RgMCGke4pkSaodMpB5cPdDibEbsl1GLQDPA+rGQs16gu8rKknPMmENxPr0iRjTFhCbLSJlBLkwZCYkAxo67MCr1BFJjKF4b2YZylo3wkzp0LEeZzktOoPB8MKWD7IOs4/b4Y3IBv2MY4zBgZCxTBp5vpg4RkVKS9WtbaKCCkXt8vB+qRCTBRzfNpq/Oi6fIxdH3TMXs2EqgVYlC6/9AjUHuqWBKAaDwoHRWvN20oZ2x5X5b0RdLYJbEgUUCHXE45J0OOvxRbK1xCub1Qem2g83n2M/hmeAzWIwWrhp2CUXmDJoX9zBnTj2dthDxoExbAj7/ZiXTr60a2K8rGueJmhZiisrFg3IpdSYDzFUnFKCpGt6WEJVH5WG2G7d16J0S7o9R80U7ziwrpQdnAdCTnsmbmSMJxIMcLfWTFUsQ8cU3CzQ7su1UHllIanOYTlnk8BkGcjIMgIGJvxzN2vfrSSlyMeTksu0eP3d4CkOPK6B+dgfZQz17tda07sCgB5oPcIKiUTa7F4DaKWlokp4tuzepKEQIE8JPED8GjNhxUsRgShhCPiUMYQxlDMPI3r1yqNPpdDqdTvdDddNNN/Hb3/524LHf76egYPsr0ut0mNJAsoGSzKrFuoufGaMTht+/9+e1N+WeBk0vJDNeSy6HzveSr9dWCKIJembD4OtgQ01SwWjEc9ppBGbORJAkPFtZhLObdupYBYAsyTT/ejSlfwtiSE8n5dxzwZaKZs6l95/nEmtoQDAaSbS2kv6ziZjcIUg7BM+pp5JoakJyOBCtVpxHHon7lFN49+8l9HhCdIy2cHiPiYRVRpVEVIMJQdboGWTAETZj781CLB/BISYDXwszkQxu0gw51N6UTXhMF4MfXYck96FkS9i7FTRBpfYwgYmfpzJdqcIxbDS9jz5K2LCW2vsktGFFJEIGPkldScBqYMWhMkf3yKiAaJQwJ6LcGD+WCusxXNR5aTJI7vOh+P0oNfWgamAUwCpiDYq4OjSMsohdM+Lui2FWDQTLU0g7/2zOevkT0tZ38+ydVkwmkUSfmbBdJrx0KZ6pJqRQPRoa2imdrG7MIs9xNuefcAUWkxvDtyETQYSc4/fax8SAgYkcvsXzhZThxEMA74aFAkdsZe+fjpaFnfTVeQHwNvppntdG2RHFW3asfxy6P0OLK9C3AmFMcrHQSZdUkDcyDU3TKBq/40DzSw0dvNzYgUkUuGlYCePSXCSiMi4kXK5kuYp4IL7dMYo/GsHJr/4Kd66dYTePIKHJfHzXMgbbjVSXRlENMKUtlXVNbYw7dxDOzGT5jkfWNrO0PwDAfasbeXx88mKDIAiMOHkn7/wAOqt70FSN7KotX68iq7z9+wX42pPfg6dcNYShxxbw2H/94LYSaY/xVcjF708yklKweXkOQRA4+u6p1M5sxJ5upfTQwoFt5UeXUH50yU7NTxAEplw5hClX6osB/ljpgeYDnDGqcM30eQD8NngMcbt+yvZEgjgBfIQJoKACKlYcWHEwlROo4iAqGU02+ft7qjqdTqfT6XQHLLPZjNls3nFH3YGjbz40/ScZ7C27ZiDj73tldMKwv0DXZ8mSGVlHfv9z2Nfyz4SMQ0EwgskD2SfAsqvBu5C44qMzJQtVqKWIwQO7ZFxzDe4TT0R0OjFmZm4xZArpuEnFR7JObMXg4yl8YvpmfbyvvUa8oYFESwtaLIYxK5WOm35JwQ0jENreQBx+H1k33DAQ4P7WWae+zKsrbiCnTqRo6G2E8ldgMz5Noz2CO27jaOV0HNNbkkHq9hg3LL+GOWOORUWlhEqe5i7mHu2lZmgOed0pDLutB8FgIGBWaB4U4bNpbZz6+jLSnv6GrECYmEPg/GcH88lfUvg69g4WQWPVhDiTn4HcVQJmFwSu1Xh5TJR6Yy1reYFK1zBKc3JQAwHiLS2gqsnAbxQwGECE/NUqFYttxDNV/INsdJ5XQl9aJsfYDuYwawb1/vcZlN7JF4kWUsMi4/4J3tqXMAoryTrNRJ/YQ4+5k3lnZeC3LeAWLsWxB+GSTlqJEaGQ7Wd3fpcTN7/n79SwggLKfrR/lypaiH71v2jESBHPxCBsvf6yM9u+WVkGZ45j6wNGWogu7CH0WgNIy3H85QzMhxyCIAg7FWCGZL30/2vqBCCuarzR3MW4NBeODBtVZ5Sz6vUanDl2hp06eJtjhPpizHuuBk3T6F0bZOlrDYyZUYocUyiMWThnTQaxhExunguzw4jFtTE7OaIoA+2wvGvlJML9MeY9t46m+e3IfX5MVpFhpw1m7IWb15uO+hMDQWaAzjU+hh5bgNkkYLRI5I5MZUSpgcOv3fp7Zk2xMPyMil2am+6n5ycXtZw1axb33XcfixYtor29nTfeeINTNrlq/Prrr/Pkk0+yaNEient7WbJkCaNGjdpv89XtGQWFPjoJEhi4Gu0ihWEcRCWjyKOEUoZQwCC9DIZOp9PpdDqd7sdJlWHdX0GNQ3g9NP0byn69F8dPJLN2jTtR99QxOPl1IJJDyddi8uzRMK3mEAG8DGY4UtM/Id5H2Ozg1awalg1yoHA9v+HugfIIgiBgHjRo2wPWt/GLb8awakQ/xUOPYhQHb9El0daGITMTqbsbpb8fc2Eqif4u1HAYKbicxMJz6MyswFhxG1nCxuBl4YijuW7E0WiaxlJhLl8SZCjncjRlVJhHMeiqSlo+PptAsY15h67F1X0NZ3ofweKZSBdtybs+VY2mrF5cihubaiMtu4ReZSlRl4JgteE1B9BiGgIC5v4EhW+0QsUCtNM0IikQDMLgryGeYqDDD17BQ9jQS64/SJ9Npc3azuQ77mDOzacTVBXSGhSsIQFBMmBISUF0OlFzrBz+QZSDPwiy6mSBjy/pYATFTONEPh35DO9Fmlhj66NgjZOzr4/gaA8QE+wEVmiknXMUXR3v0fg6jFDW0HBGDqET/KQJWwb9d8Y8ZvIiD6GhMYXjOJsrd2l/D2kcxKG7dewfim71MYLqLACiWg0Fhge22i99cArTbpxA68IO8vrmYbrvOvyDBuG8/noEi2Vjx9yTiXz0f8lMd3MWkZdewnzIIbs0JzmmkPtNkG5FJnKQi1zrxoupYy6oYvTPhyEI27/DXDQICCJoG2LGkknC4jQx/oLBLHqpjtJRGRQelEEiLDP0uAKMlo0huUsG5XFv9XriqsZV5bt2gWH2o9Wsn99Nx/JuREGlaLid9bNbtgg021JM5I9Ko2VpL6IkMGhKsnTGDb/w8OybAcxGuPIs13aPFQsmECQBk/UnF07U7aSf3CcjFAoxcuRILrzwQk4//fStbj/kkEM488wzufTSS/fDDHV7QkMluKG+cgAfBgx4SOMozqCUIWSQyxBG4yZ1x4PpdDqdTqfT/UQEg0Fqa2sHHjc0NLB06VJSU1MpLCzczp66HwYtuRDfwEN57w0dWg/Vf4SED7KPg9JdC6odMPrmw7p7k4Hmwp8nM5N3wwK+5AX+hoZGFeO5Ii6DINDssrIwXQNRAhRqWDkQaN4exeej7aabEMNhhr8Ilj8cRGCSDyebB/Vdxx9PaP58THl5KA4HgiMDeyFIBi8JWaTW0IDcV8M7wWbGOC+mf/l8Kr82MnjYiTgmT8YvePkn9xMnSh3VRAjhxMNB4qH8rDiNV4/5DF95F6LVCP0Xc776HGtSe4hqYZzrw/g8PtrDa1GnjqNz9mp8BUa6y1QOvztAWY2IIb0QDAbi9fUogQBRSwJHL3hTodcONEuUNpqQ3WZcYhiDBrKgkh43cIjhSCIugZln+xnytIBiAmNEw2xRyXNlYzbnYorHccajmMbWM0wSqaouZFVlHjbRziLLOjCPQmIFa0b4+PrUOBNfUvGlqcjZMqVDLsH07DJs1ctJbeimaFYE85o34Prrt35SduBrPkHbkII7l48HAs0JEnzJO0SJcCgn4mBjQK+bdr7kXaKEGc9hlDN8q2Pvjui6dQhGI+aSnStt8H1IaB0b27Rvt2/RwXnk5cn4rv4QFUh0drNyxr0s91WROyabo28bjzl9KmLlKahr1oBoRszYuSxmgBp/mNX+EOHHG6hcGsAVjmGojTF6kojflYJrQxb1joLMAFaXiYPOL2PhS3XkDPUw+szkez76jBJGn7H997/Sbef5ScN2et6bivoTAJidJqL9yUVSM4embdFPEASOuWU0HdVeHOlm3LnJ8hhlhUbu/vWOYyQr3mni66fXIhlFDr9hOMUTkhdjNE3b6vsT8UaZde83+FsDVJ1RwZCTdi3DX/fD9JMLNB977LEce+yx29x+/vnnA7B+/frvaUa6PaGiEidGEC9hQiSI4SKVNLIYz+GUMZTJHEsGeoF5nU6n0+l0um1ZuHAh06dvvBX/2/rLF1xwAf/85z/306x0e41oTGYwN74A5jQoOG/vjd3+djLIDNDxPuSfDaYfYFJH2xvJIDNAy393O9C8mNkDQcaVfEM8/3ZMwbUURBVSzMPoF8CIiaGM2eYYCeJ8zacYMDKyqwA1nLzVff6EDr7M/xNmCjmfazmIaQDJ7ZpGwWOPsVT5ik6aGdk3jKzi4dD+FuHmp0nE16AYDDSZvKz23sLJnS30Z8VpvvefuLvvp+XUfBLE8dJHAB8qCkH8NLAG723XEer/BtHiRbBY6NVivL34dlp6/MTH9WHpSzC4080hn6ZTnDOWl99KJSD4GPebpaQKAmpFBv2RMAWHTCD8pURsbQNjPrPRUhSmq03D/kUKL0sKF4kaqcEg5R/LXGYSWJplpNJ8DIabHuWxSZ+yangbXz+pkNoOdgGOv1NF6qph2NHnoGoavV/8iRSbTNQvkNXThs3nAUs7I9UsOuxN5FPGGpbywS0Wak40kr/eyiEHn4Rkt2MSLGT1OkkEA2i+EN3/+AepF1+MMXXXP8uFlA3U1N60dMZrPMUcPgRgHcv4LX8FkkHmP3ERa1iCiMRsPuDPPEEexbt87O/qfe45vG+8AUDaJZfgOfnkPR5zb0gRT6dTuQ8NhVRxxo53EMWBZrA9RLPPR2s4RGt1HdEInPXYIThu+jORF18EScJ23s59j6sPhLlhSQ2yppH9TSvDjVY8/TLe19v44otuat9t5Lz/nYgo7txaWf0tIRa/Uo8SV+mu8RMLJjDZ9n3Y7aDzy/j4rmWkD/ZQOmkQ+SNTGHT41us6SwaRvBHJz3Xz/DZ8rUFKpxVgS7Pu8DiLXqpD0zTkuMLS/2sgu9LNp7fMob/Bx+Bjipl45ejN+q98bR2dK3sAWPDMcoqn5GNNsWxtaN2PyE8u0Kz74UsQJ0IIH32oqJiw4MDFBA5nMCMooYKhjEVAXzhRp9PpdDqdbmcceuihaJq2v6eh25cypie/9jZL1sa2wZFc7O+HyJIN/lUb2huSVMLN0PBEsl1yWbKu9A4MYigrmA9APqWYXKNh3H+waTI3SDHqWEUuxWTGjCCvB3txcsdIG7S/BaY0/pVbw1IxuU5PY+lRTB0yhOjq1cw9tBsprQwVhZm8zkFMQ+7vp/V3v0Pu7qY/S+HFv6kk3EZmZczlFp7Cmnc+/ldepmakynKnii/o54i2EIOiURBUUg7pY/4Tl/PgSQ5sERODVlpZOz6CLMrEiQECeSkjONn9Z94K3IhRjlK8SEJ7aj55okTaGxr904toEFbz8dReZtoe49DINcy0vY8/C7LqNHq0NnxDIqy6ZAGnijba1iqMfFslQCnvaymEOxU6DatR4hqSqNHxFuSkGUmfmEZK4kxavI9RU+7DFJMQFJnuCg1XD3x2j8To2bkcdtn1PLbsPNoO0jglLODuFDCFRaYESmH15ZyASl5OBnNKRuEhnTpW0TqmB8OYQRzMzwgvXEiirQW1rwXBEEV1i8jefgLvvYd0/gm8zb9QUTiB80ljy3IacWK8y3/op4cjOZ1TuBAHHubyEenk4KMPN6m0sX5gnxYaBtp1VOOnHw0NBZkgPtpp2iuB5sDMmQPt4MyZB0yg2SEejFX4DyAjCTsuuWMoKMB2ySXEPvoI2e2gYd6GzF8B+tYHAZDS03Fcc80uzWONP4y84WdfcLST8LIYgfYImgqRgEL9N14S4Thmh5nF/V08UrsUoyDxu4oxVDi3rHPfUd1PIpqsmxELyXSu8WJNN1MfjJBuNpFqNm6xz96QOzyVC146FE1jICgeD8UJdcdxZtu3mm1cO7ORuX9fBMDa9+o5+fEjMZi2X07UmWkhFkxekHNmWVnzXt3AYo3r3m+g/JgSUks8A/1Fw8YLBIIoIOxkwF73w6YHmnUHJA2NGFHCBEn+ihNFRUFARETCip0KRnI4p1HEYAopw8Y2FgbQ6XQ6nU6n0+l0+0bu6cmyHNF2yDkRpB9otlrJFWBMSdaazjsj+VzdQxBYm2zXPAgj/77DYY7gNFLJxEcfEzgs+aRoAAw4sSTrK/fOgXX3JQu5Zh+XPPaqmyGezPyr9fSCPQXkEA3CUmbc9STxpiaK8x9mvakOgAwlGySILF6M3N0NQLSzlbSldjqmpRHCj5cejP1W4nMsFK+cgFDs5+iaSbRPnoUgdGIOahgVCLpkiMXxJ3xE5VRMEQ3RZkYQBEYzmQJKKRBLmeSYjsFfy4K1D9AdfB9EAbNiY6hzMp8VL0OVRBQtyqzga2TYBtH8qwz60+aTFXGz/jjI6Q7Q/XIbAVOCuBRjxJxmvjjLTeuqWoqI44zJJMwiNsFI9DUz8sdGeke/gyUk4QyYiNg0EnaR3MUq7k6w9WiMM5+CisryzHVktqusFzWMHo3lw7KxeF+hHAMRwoidH1GTNxpNhFMNF5FGNkdxJiZMND5yIxbParhQ5rMi6DKqyLEEVxpFXuEhqkkG47pp5zru3/yE98xmRfA5Vqatp8vpYB3LuYsXqKeaXjropYM+uriWe5jMsaxnLRoa0zhhYIhBDCWDHLppQ0GmgEEMYfPM0N1lrqggvGBBsl1evlfG3Fskwb5L/a0nn4z15JOxR2XKrplF9ScdOLLslB2VS1c0TobZuN3yFpqmIceUzeoij051YjdIhGQF0yk5nHF+Fl/fv5yaj1vQVLCmWTHaTAA8WruMnlgUgCfrVvDAqKlbHCNnWApGi0QiqmB2GMmsdHPL8nqWe4NYJJG/jBxEhWv7r1sNhRBstoHX0rq8j/aV/RSMTSOrwrPN/QRBIBaM09cYBEXhy7vnkQglKJmWz5Trxm/Rv3t170A71BUm0h/FmWUfeK+CnSEsHstm79dRfxzF4lfqMVokxp4ziPrPGgHwtQYIdoSY9ddvOPruqVg9yZ8DVWcMxtvkJ9QdZthp5Vjc+iLCPwV6oFl3QNDQCBMgQpgQARRkLNiwYieFTEqooJgKUsnERQplVJFGpp61rNPpdDqdTqfT7U+iAQp+tr9nsZEqQ/dMQExmcIs7+SevZIGiCzZ/ToltMm50p6cwhsnb79Dx4cbVwjo+gMJfDASZAcYFMvlCXQlygLE9EYSsNZhLq7iMW/mE1wh//Dljn5pNc2YzqZdcgiCKaKqKR8ogXpQM5AxmOFnkI6ZqdI9xsTI8m7Q1KrFj0zmm6A0S/TdjaF5AvU/gvUs7CcXiWGIiaT1mXB3g8KqoJpGynHza05vIIBeHlIlqc5PxhY9ASCBOFEMEUkMu0tokMlbHcfZA/dVGyIS4lKDunDy6bZnIgWpSfQoLpiYY9HoMIxrGhMwJsXayMg2kWCTUHpWQYmHNWI3qQ+MM+SqAc927FP/sl1y1/mC+Sp/HF+Z5HPG3fpxeEaPFiXGaDxGRg1f5GaGIRCwqQZNEd145bQmB8gBECBLthsPOXIRqFCi98QxGjTt34P02Z/hx5nYTT1MZkw7/LRZoD5vwjh6Ol3kD/bxsDMwBG+p6/5UMajmxw8sro0cQMvtJEKeXzoFu37YncBhlVJEgRjYFA9szyOGPPMZqluDCwxDGYGbvXLDJuuEG/B99hGA04jrqqL0y5v5mtBg448nD6FjTz6IvWvmXK4J3XjWTMzzcMLRom7WCP/7DbHzNAYom5zH1hvEIgkCO1cyjB1WwuC9ATFGxpjo4/vaDeF+QCPVGmfbrqoEMYbO0Mdu3T+7invX3UGot5czMMweO6cmzc/rDk+ha6yN7qAefQ+CrNd0EuyOYbAY+y+jbaqC5bWknvbVe0le8h2nx54iZmbjuvpuefhPv/XFRcrHO1xo445FJePK2HqgO9UZ547fzCfXFCPeEcLtVDEaBhi9bGPOLKuzpm99tUjQ5j7qZjaiyRuawNOwZye2qqvHZ7XNpW9SJNcXM0fdMw5WbTOpzpFvIrbQTC8QR0Kg4rpTe2n7mP7aUlGI3/pYg1W/UMPbC4fjaw7x780KC3VGGHJ3PoOn6eg8/FXqg+QCnGEXe+OuQgfaPhYJMmBARgkQIo6Jiw4EDFwWUMYIJDGIYwxmPA5ceUNbpdDqdTqfT6XQ7Vvt36Pky2Q5UQ9mu3Uq/mZLLoPZB0DQo2YuLHNpLwLc02bYVgcEKOSeyOPgv5qd4KbSdzK/r+zCqEiVRBxhmg7sKFx5OqD+MlkfeAiTizc3EVq8m5447iCxbRu7o0VxXnE8/3eRRgoTEGsNSHvxTNZH1Xo54IE78wQfoOc1D0Tn/hvFQ93mA5t4HkXpeJK2xn+FzMhj2Sj8NQ2Pk1osk1L/xt2ffYWqnxLHGK5Fch2My2SnsSkMNhTBkZaEtXEveMCfFX/UiSBKT7k9j5o0Cre2rOGpuDpMyj+Ch8yW+GLmU8KMxhtyicuGLEH7LQqoxh/xoPYKsINphydEaM080E9VC9KVFOPrfTtYcLnFmynW47riDg65cgE8V8JUYcVgzybAkF1g7obEMydqIFlPxmgRccUgvvhks3WhN39Dx3KNoYRVXyIzl5v8Qe3wa5tJSAKynHEHfvCWoioxmiZKwGWmttPMf6RFO4Re8wAOoqJzEzzc/j+H1QDJQHFT9OGMxpph/jgUrx3A2/+ZBVFSOY+OFmG9Lb6jhMIEvvkDyeHAcfDAZ5OyTdYVEi+WAKZexK7r7FOYui1KUY2BU5ZZZsHJc4cVn32Nhfy2G+hLMZ5Tx1VA4L5JNnm3LIH3Nx+vxNQcAaPyqle6T+8isTC6WJwkC/6pvx5eQMYkCfxtTznn/nLbFAne/Kx/DU/UriatRVisv0usLM8c3h9SuGOOeWYgWDGK/7DLcEybgzkkGbQONfqJ1QRJGSEQUxBUBqNx8bq2LOph561zUSARxdTtHDJcwd3URfe89WqxT6FrdiyqruAuc9DUGtxlobl7cS6gveXFMkSHil3GmGTG7TJidpi36OzLtlB9XitlhouqM8oGAen+9l7ZFyYsjkf4YdTMbGX1+slTJkhdWsfK1dQA0zW3luPunM+aCKhq+bEFTkiVIDNZkmHHVe80Eu5MX6FZ/1MLI04oGFh/U/bjpgeYDnGISmXn9oP09jb0iQZxu2kiQQEPDgYt0ciihkkpGUcloyhimB5V1Op1Op9PpdDrd7glUb2z7V0D7e8nFEDMPB2H79Ue34B4OY5/bu/MDKPw5mNJA9kN2soRCd8mJPK+8jia4WSUsI8Vm5eCeDcEhx8aSB6LDgSBJaEoyI1pKScE6YgTWESMAsAIuPAP9V/ANqkGg9IsIzmYFOaHQfPdtGFa2kn3TTUiCiKmvmFisiK70LGZeB5f/rIBRn3cTJ4Y3vZuTl8h45BhNXMPi/HxsvxrHoN+3oHi9mAoKaBtiJiOahsMMAgLGdj8X/b2KeEMy8NRTNJfuCzrpE3wY0ajOE/lqhpWjCgoYZxlPiAbmKRLpop26oyREBMSEStipsuzGMo7Pmkzbr66g+/mXiRjjYJMwpKUzZMK5pF9yGQBLjkznfUEmNSpyyfp0bkzcjsMyFtnmxX/fvyha5SIR6MccjaNmtdJ2000UPvUUktvNV7FTENLfw5E3j9rUOLMLVMqkQnrpwBMuoezx39OTsGE/oxzKkmUFIkuWIBqysRjdWBNQ6Tyb6x23YsYFwDimMoxxaGjY2DK41v7nPxNdmyzLkrjgAlLOOGPvfb5+4MIRlese6KXPrwJw8yUeJo7YPHj8RdNsXhj8KFFNQShzMbL+WuwjXHhMW6+BbEvduL8gCZuVcKgJhPElZADiqsbcb9qY9XwziYjClF8OoXx6LgCDHB7uHTGZ2nAt19aEB/a3/PstlPpkgDf44IOkvvLKxm2CyKnLNNZlQmoYxpdsueBez7r+5LwMEnHVSDBqxmwMI6an07ugEyWSQE5oBFr95FRtWRf6W+mDnIiSgKpouPMdjDw+GzUhU3FsKQbz5qG/WCDOB9d/QcyfLLUx5+kaCiflctTNo7ClWTFYJOQNtaZdeQ766r0s/tdKGma1YDBJSCaJ3hovmqZhS7Uy+bfjWPNOHe4CJ8NOS36/sqdtfI8NZgmTY9/Up9YdeH5ygeZgMEhtbe3A44aGBpYuXUpqaiqFhYX09fXR1NREW1sbAGs3fPPPzs4mOzt7v8z5h0hDI0qYAD5iRNFI/pDIpZhJHEkBgxjEUAop0wPLOp1Op9PpdDrdj5UcgnAT2AqSiwXua+nToPW1ZDvh27iYX7AGBv1yYz81Dt4lYM4Ae+m+mYsSgXhfcnFBYZO7U0UD5G6eZRrEjyZtDMT4i88Amwes+ZA2aeB5Y2YmmTfcQODTTzGXlOA65hhi69fT8/jjAKRfeSXm4uKB/uWMwImbhE1C1DRMIYgYokQWL6bvpZc4KBjmiN5/8fUwH4ZBg7FlmTGePBqx8V1Eo4VQSZisWJSEJBPEjzXUwQeHr+OXXzxM1ivVaIkEaTOO5cu+a0hdsQizTyblnHOw9FuINyQXvMv3jCALjTqq0QBRkCAvm6KxdsxzPuTRGQFaXSqaFmXY3ME05NcjYaBqjpmS2y5gXGMDqz/6HzFjDE0AMabQVhLn4z8tJYvbOIdf82bmarSQh3abyieSh58Jdmqppj+8BtEawFVUTrS6GsEuYCouRg2HSXR1obptuFNTuaXrUNThi+l3WBGkKL20M4wxLLzyX6TN+pwUQeT/2TvvOLnKsg1f55zpfbb3ku2bTU9IIQmBJPQAAenSwYYVy6ciCqJYKaIoqCiCoPTeSUISSO91N9nN9l5mp7dTvj8m7LKmEJqgniu//eWdOW87ZSab+33e+/nLzi/xq4eWMHDXnQRXrAAg/apL8JwyC9FaiPlfbFqsHD4xpibLIyIzQGz3bjiK0JwgznbW4SGdCuqOWO+/hd4hZURkBthzIMHMCWYivgQWlxHJINJoqsdgkzBHNeLeABUVZq6YWIbdcPjFpLKFxUSGYgzu91F2UhGu3NR3Ucv6PvxbB/DaEviKTBhFAfn5XqLDCQDW/LFhRGge6ctaxjzPPFb6VuGRsiiz5wA7UwfFsbvQ04ocLD63jIJXOkkf56RuSSH/SuGsXHY/tQ8ZE+nzJ5A5wY25vBjLGWdg2rmBogk2ElEVm9eIxTn6HRELJjDZjSORyBnjXJx523S6dgxRMOXofs7BnjDB7hDR4QSBngh2yUTnjiH2vtLBpHNLWPTjuTQtbyVtnIeyk4p5+nOvEuwOI8dkgt1hMiq8jDuxcCTiu3R+IaXzx57bhLOKSERkhtvD1J5eiNV1aFS1zn8n/3NC86ZNmzjxxNFsyzfccAMAV1xxBQ888ADPPfccV1111cjxiy66CIAf/ehH3Hzzzf/WuQIIikbhFj8A7VPdaNKnS5TV0IgSJnRQUI4Tx4gJDRULVpy4mcLxFFFOHiVMY/6YFXYdHR0dHR0dHR0dnf9Skn7YcQPE+8CUBhPuAHP6xztm8RXgnQ6I0PBTUA56KwfrR+toGuz5IQR2AwJUfgfSjwe0sYLwhyHSAbu/m7oG7slQe/NRI6pLqGQGJ7KRFeRRwvGmC6DAfdi6jjlzcMyZM/K6/847iR84kCrffTcFd9wxcqyXDlRU6s9zk98v4N00SDwh4oj0Y2tvJ7p9O2fYcggMBBge52ceVzLp2ssZiOeT7OlBO68cJetNcvr30S/0sC8zA0hFVmdce+3IOF/23k/9g1vwvNmB/ZV6KCkh/brrIJlk4PRSVLbgFtKJagGKNA+nxY7D4xvG7xqmO00GWSQpGWmtETnjNhPWuJGBaW42sgK/WM/MCgvJZAg1qjI8zsyrX1bxEqKDA7zCPzGY84jJw2hyAIN7OvfYH+JV5e9EciIU/tjF5Td7KNJqkCwWEAQstbW8VbKVZ/km9ikuFhvP5DmzhEsxICVc1EVr+IbjNt7afhE+QNRUCppWoShLCK9ZM3Le4bVb8Jz7/jzKBYMB+8yZhNevB0HAfvzxR63/O27iAHsBuISvMIf/Dq/lI5GfZaA030Bzp4zRADNqTbz0wy10bBvEnWtjyc9ncJznOF6sfZHwcIwSewk/nDEfk3hkIVMQBCZeMNazomvXEK/9dDuapjFTgNJvFjLhmT+z+Q0TIWMVUl7eGGE3EZV56/d7CXRHWHD6JWw1L8CfMPLXeQm+FIdgYy971RlIt7zN8V+fPhI1Pe2iMqZdNLpLXQ2HCd58Mxt2x9k7biHHf+lUzv7DYgKdITKq0sYk35t6VR2RwSgxf5zp10xAEARUVeP1n22nZV3fyPWwp6XGyq31klt75Kjndwj1hvC1BIgFEyQiGl5PKureYEl9R2XVpJNVM/pdHQ8lAbBn2Mibms3sL08lszrtqGOIksiMS8vfcy4fFR3bBunb56dkZiZpxc5/27g6h/I/JzQvWLAATdOOePzKK6/kyiuv/PdN6D0wxhS+c9xbANwQOpWE/ZO5ZRoaCjJxYsSIECGEejBK2YgRF2lMYg65FOHEg5cMCimjhKqPLJGBjo6Ojo6Ojo6Ojs5/EP7tKZEZUpG9w1sge/HHP64r5SdKxgLofjZVzjxh9LgcOCgyA2ipCOimu1MJ+sq/ARnvkczvWOhfnhKZIeXHHG4Bx5EtEQUEruAGLuErGDnyFvM4MbbwFi48jGd66gySyZHj7y4DvMKjaGjIZnjxawlyWtK54EcG9hUPU3DePNixAyUS4tw/Z2LMvIYmV4Llj36F6nY7aZ/9LAUzZ4L2RdScBh4y/Zyt5j3MoJYqJo4Zx0sG03sn0HbX74hpGrG9e8n43OfoOa+cX0cvJTzcRBEGbPYpXG+8kwnmChC/gNsyREVIY6db5YA3ipDTzO5fJqnZItF9ug0j7YQ9YTzfjjLzAQtvHicxuKQWR6ENIyZsiQSZiShV9qu53fEdBLxsRWEw/DghYw9oGspQCGV3P0qiGNOkSWR9+9uY0urp/+sXuWxdkp1T89HmmPjuDzJpMTaRp4mUJYMkFrxG4dQywmsaiNp6cZ6bS8Tow1JXR2TzZgAsdaMRxlEivMw/iBJmYXQh8bX/xMIQ2VOuOrj4MUr2975HdNs2JI8Hc9mRn4sokRGRGWA3m/7rhWaTUeCXX09jd1OSvEwJrSfAmm2pRIz+7gj7V3Qx9byp3F1zN53xTqY4pxxVZD4S3TsGCXQGMVgNWL0Wxi9fhm3/PspcLvbvcqKGJGZ+duZI/a2PHmD/m92p8s5+wl/PRTDBWsnM1OvP5yfP3EBc2s2CnScj/E6g/KRisusyD/FHjr/yCnt3DnH78FloQwKv3d7Ob24upmxS1iFzdOU6OP32E8e817/PT8u6vpHr0fB6J1MvHIemaXRu6kEQBfKnHX03fvf2fjKr00iEk0SDGllVXgqmZFBzSv5h68/8wiTW/nYLRquB2V+ZOuJv/WmhY9sgL96U+kxuf7KFC/5w/Ij4/l7EAnFW/2oj/o4g48+toGbJv08c/2/lf05o1nlvNFSCBIgRJkEchZQ3j4iEGQtWbORRQhnjKaOWbPKpZNJhvad0dHR0dHR0dHR0dP5HsZWCYABNTkUK20v/veOXXpuKVBYN4KgYfd/gTCXhi7SmXocPK7zKegABAABJREFUAAeDkVr/8tEIzdaC0bJkSXkyvweJzk6SHR1IEyYg2g5vu/B7bqaJlEi+lGtYyDlkfOlL9N91FwgCGV/4AgCRzZvxv/ACkwuGeOrKAZDAip2BkgTL/zYeE2bOZAqNX55E8+sP0pkX4u3y71LQmYlSN8wFuyuo+mUXpY8+imAwsN8Zp41B0uQM9g29ya7ex6ibcMGYucUaGki0tSHZbEjp6eyybOe33EpMbiRulMmMqxhDbeR7S8HkhbTZiL6tXL/XxwMVKrJBQEpGiDkNdJ+Tz0TDAjo5AA4XHrefnCvy+awpF7qs7C78Luv8d3Hi3s0UqgIt3v0UVZeBIBDEhykexGQQiatJSrZr2EJm5OE+FJ8PzVeP1vhDjA8GQROobGljW1MXsX4TC9LjFOXA9vG7eVP5NQvvfIrGl75PuztA66wmunZfwrfP/SX22bMRbTbsc+fSRStJEqziRdbxBgICq9sf5urGVER6LPBTis9+YiSiXUNjn7QL2zQv+ZTwCL9jH9uZyCzO5ZqxjxE2xlEzIjbXMu29n72PCiV+0Pol+6OL9D9GLGaRabUpodAvW5AMIoqcCnRzZqd8jkutpZRaR79TNE1D0TQM4nvPNRmT2fd8A+H+MHJco3h2DolcG93ROPVdXryWIMYSI/XP7mPyhZUH2ygj7Y1JjbTftyMNycjT3bzx+RWEzSHQNJbXvErWbwrZ+Xgj6eUeLnzoNIzW0cUjwW6nW/GgvWMhKkp09smYBvzseakDb5Gd6ZeUIUpjz6NlfR97XurA6jEhiqnIZgBHZiqwb/0ftrHv5ZRdzfhzK5h21YQjnn/elGz2v9qCxWUme7yTM38zG8l45B0Xh7PG+DTRt88/Uk5EZIY7wscsNO96Yh/d21LC/cY/7aD4+HxsaYd6aescO7rQ/D+MikKEEHFiqCiECQICIiIWbHjJpJBySqgkl2LcpJFGJgWMw8SxfWh1dHR0dHR0dHR0dD5hNA3UGEj/5v882wph/G3g3wquieD4kJFi/p3Q8wJY8qDw0pSA/F64ag59TxBh/M9g8C0wZ0HXM6moYwCj58PN8R2yTkoJ7OEDkHkimP6lX00ZY6UR3b2b7h/8AE2WMRUXk3/HHYimsZGQMvKIyAzQwDYWcg7WujqK/nAnyCGw5qIEAvTcdhtaIsFxmwz0VRaybp6JDHIIMEwxlSxgCelksfdkic3ZGmERQsYw8pCIIEr0ZUWpOqCiqSoCMEwqojTWUI8aDtP85G8onGvFvWQJCgotgW1E/vYbDJrGpsJ6Bs4oxXdCC2YsaJqEUVaYO2BlsTyXNG9m6gQsWaAlMGgi01YrbFmkIYsqaaEksxuNzJn9Jf7ITwgKw9hyLsQQTdmDkHEC45nG+P4ZoA4DkOvrwZ6wEDYZsGoWvug7j02+lfRG+5jQasLjTyJYzIgOO+b4P1HDw5gTqVsQF5J0lShsPD3OlN0Kr5cILJsYRTA30+D+FYaLs2gNtBKrb6ArLtJ91y0U/u53GHNzeZPneYI/EidKMw3IJMkiD0WIAimhuV4YYkh7i0phGo3sYhlPjQjH05jPZlYBsJxnqGEqNUwZc9+/zK1sZx1u0qjkyOLhR0qsD3b9HyQGwDUBan98bJ+3jwF3ro2Tb5xE0+pesqrclM09NFq3KRjh5h0H8CdlrhyXx7lFWQy1hZAMAu680YA4VVHZ+0oHvtYAseEYxXU2knGVnHluvl/mZU71XuhRsWUUYzKZUC0iL3UOEJEVfNOtSDutGAaTlOVYia3tIWEUyG6QCcZseEvdBDqCGINmosMKsUCUYE+U1rU9lJ80KtKaTz6Z2a19PP+CRK+jiKISJzV5As99eTtyQqFxpUL/3kFmXF4xEjkcHorzxs93jIjtZfNS1yCzwkXFibkAdGzoHhmjfUP3YYXmnr3DRHxximfkcuovTiDQFaLwuNyjisz/CZTOzmLHUy3EwzLeQjtZla5jbiu+y55WEIQR32mdD44uNP+PoKISI0KUMDEiyMhoaDhwYcWODQeVTCafEmqZRgGllFKtJ+rT0dHR0dHR0dHR+U8mGYTd34dIC3hnQPWNR/UK/shx1Rxe7H2/yGGo//Go57JkhYKxEbVE2qDj0VTEctFlYDjKjkujE3JOS5VtxdD615QwXHTlh55qD+3YcOLKPoLFQfOfofs5sOZB7a1gziSyfj2aLAOQaG0l2dGBedzYJIUGDNQyjT2ktohP4OC2fv8uqL8ldW2yFqI6LkJLpJKZGTFxZcPZnDQzhwGlieMsF+MRRrfoT2YOm7T7McckcrrtSHYn9qSFup4yMr/6RbR4nMF//IMik0rROUXsDW+goMlM2RYDUc8upCUL+DXfpFPai3hNE3Mr81i+0IgxT8XHBpwBG1ZrLenBfs6UF/KcQ8W35iTGJfNJHFdIbUEeFU8O4V0R4TpVoS1TpCZgI825iMzZVfyUv5EgjiXXCuYN0Po3iHZCqHFMhLxiclOZzMfc9Tbz97nJS5tDudxBX1LlkQt7YILGou7zyD/rqxi6vgWWajxz6mndFqahRmX1Z5OICqxRjHSOMyLYJURHLh0c4Aq+yYHw24DG7DW5aIkEiY4OjLm5rFdfIzsUZKeth4QhjoREH11M6rqB7mgj3cX7WDEzSqb4a3wM4sbLHjaTRwlpZNLAjjH3WDsYWd9OExt5kzxKmMVCZnAC/1YG3kyJzACBnRBqGLWk+QQomp5J0fTUAoXS14f/7/+kK2DEe8Ul5Je6eay1l+Fk6vPzwIEu8lb62f5YM4IgcPwXqhl/ekroXf+3Rlb+Zheh/hgSSUomO7B5jDAO3N2drDj3YvrnRih9tYd0TaB3sZfePS00BCJUu2ykXejiztpynj3/TdT+BAZAsJq5JudanOlWgqVBqt+YwX6pI2X5bpBQtLGRyYIokvP5y7n3ao2u3iTDW3pofGmQRFQGVaNv9wCx3mEGd3Vx8m3zyKnLJBGRR0RmSEV1z7yiYky/uZOzaFrWBqQilv+Vva91sOq3ewDIn5TGmT+ZPsaH+T8Zb6GD839/PP6uMJnlrjE+1+9F3Wcq8XcECXSGqF1agdWrW79+WHSh+b8QFeWgl3KUGBESxAEwY8WKjYnMophKiqmglmlkU4DIv3crjI6Ojo6Ojo6Ojo7Ox4CmpTyIDS4QBOhflhKZAXwbU97E7olH7eJTiRweFZkBEoOH1tl7M8T7U2U1AeVfPba+zRlQ+e0PPUWAh7mbtbyOERPXcSO1TB1bIdo96hsd7YSuZ6H0WiwT6uh85k4C2hDmjBwKcjMO2//n+AG72IgLD+M4KOD3vjx6bfqWYSy+BvdZZ+F//nmMOTmIJ2VTs+1PWGUVPINQcwthIcQW3iKdbL5j+h0dL/6Vkr5shG9eTG7RdGxTHQB03Xgj0R0pMfSK9nkMbpqOsnITitBAdOYMvsUp7GELBpuBipw0dkwcQDAYEIwmHNtbmbAtnTRXKWed/xJP2+5jw657iNpCvJK3kupOJ1vH5XGtKQ9T0of3qQT5RUlUWwXu73wR4OBu24OR+D0voQ6vJxHvJDn4Io55m0mIsCv+PA9n7iaR3EPlGwMEfwv7AhtwLSnghS+0MBBQ6cyVaHU8wm2BzxPLPZmB7nsZuMTKH3/iZYOjCY2UVeQji9OY6XPRbxskJxlgWk+EGd7xlBn/TseD38feGqF3hpPNE9dTpPpYsqceJbAXZ3acN4s95BnGY8TEz+Z+ha0ugR15d5KZvQYVlQ6acDIFGw6CDJNGJnNYTJBhGtjOJGZTy1T+wT08yB1YsZFLMRISM1jwns9eED9v8jxWbJzAkqN6fb8nlrzRsmgCU+YH7+sjZviWW9m5bB/RuMbK5d0s/NsP8JhGz9VpNNDwaieQstPY+0rHiNDcvqmfQE80dUwwULKojKkTw0Tuvg3zoJ+G6vH84oyLyF6ayezHHuK42zvY75xGcuJUgqfk4zQaaO4OYLIbcOfaSERkxs3NpjAvh0uiX+bx1l4GZ2pkzDUQbwviKfHQ8HoXjW/2MPu6KtKKHCPzNBkF2p5tZO8rHUDq6zoRlZEk8GQbQYO+PYPk1GXizrVSMT+b/St78RbZqTvzUBuL2V+dRt7UbERJoGjOoV7LbRv6R8qd24dIxhWM5ve/6Nj0Vg/bn2rBnWtj3vW1mGyfDlnRnmY+ZruMd2Oymzjxxtkfw4z+d/l0PBE67xuZJNGDHspJEqgoJEklfhAQMGHGgo1sCpnGPGqYSg4FZFOAHT0Dp46Ojo6Ojo6Ojs5/HWoCdv8AgnvBPi5lWzHGG1gAo/cTm96HwpIFuUug+3kwZUDu2WOPaxokfKOv34nG/DcSJ8ZaXgcgSYI1vHqo0GywgWgE9WDSPmPKXqF1hoHXb0vD02KiZ2YaDusGZibmM/SXv5Bob8d95pnYZ8/GgIHJ/IsoYn2X6GRKA8lKxnXXkX7VVbxoeJRXwt/D5B7kuo4KSofX8Gz8Vl6zrMSMBRGRS2q/yqLaZw57Ton29pFyn6+Bly7uIXGqmYWvFdBu3kUbjQiALCQZKJO4zPF/rElby57OV8huDTPhRQ/jC7rRSr/Cq1Vv0FE6jCGpIosaJi3CbKGF8KU1GFpUHCYbireG6Ne/weNDPyS0L8C5Bd+l2nYwcjvWTWRwJ8QSGIy9NK2t4ulimSeKfMgkGYeXxU9ESHSCqKkMPtnK/AkqiTxoNSosEzVCq1fz9PUBGgqKqJfq6RZbUFABDQkJWRJoS88iwz/M3EEnpw8YIPAAaZXfpu+XN3Cf/FN22FeRF19PfsjCN/0uFKGYM/qGGXKL9GYoXM+N2CQrx08Bgek8whpERLIpQMJAMZXUMo1ZLGI688fsIt7DFt7gSSKEiBDChpMuWo/p+buPW2mhAYBBermQLx5Tu8OSMReUKIT2Qcb81OfvU0KorZdoPBX5bQ/1s2FXnCtOy0XVNHpicc4pyKKnNE7HwQSC6eNG9Y/yE3PZ/lQLmgaOTCuZlWmI297ApKlM8Ngp7WjiLTNMWbGM8r31WA6EKBBeosufy2Cei4KTPEwu8uCv9SIIAkaLxJxrqwC4dWcz7ZHUgs8JP6rkSns6q+/ZS/fu1PfSijt2cd5ds8acS1/DqLew1WPm8ofm8/J3VhLujSCZJQqm55CMybz2/VUM7h8mK9/OaT+bjsU9VlD1dwRREgqZ1Wk4sg6/kyNvUjot61Nic3a156gic+/uAWLDMQr+xVYjFkyw4vZdKLJK//4AjqxDI6vfL/FQgvW/30qoL8LEC6spmJH7ofrT+eTRheZPMSoq8YPRyADdtBMitR1ERMSGAwNGXHjJpRgvGRRSRjYFZJFPPqVYsen2Fzo6Ojo6Ojo6Ojr/C/g2pURmSHkDD74N2SdDfCD1fsa8lG+ypkHPSxDvhexTUxYOR0OV4cA9B/tYAIUXfeynclhKPwdFl4NoToX/vRtBSB1r/WtKzC24EPqWQdvfwZwJld9JRS5/DGiaxvATTxBrasR1jUggM7XFPYeiQysb3VD1feh+IXUv8pam3sbEOHeQ6WmdJJp7MFu68b/8DP4XXwQgtmcPRX/9KwaP59A+C85PXZNEP+ScgSZKCMCrhqf4PT/CboLsuMqytB5mJ1VWmgQa2UUGOeRSxH52MofFhz03zznnMPjXv4Ig8Op1MRq1GPJgnFBmN5e2z8fATmw4kEkyVziVU3O+QBpVuJavZ/KdYXoWtbP6Go2hzL0oyGgmlSQa2T1gKEiyW5QpjvRTsnQATXPS4urj9+E32GuLkNdp53fRK/ntpD0ICLQas8kIJzAYoM+kERtuZqYgssYt0uoU6bLEiOa7eH38MIYYTF+hkD8kIGdrFCsw7W2BzlNUAviIGw2ImNBQMaQMEJAwECfOfnaRY1R4OaOTR3NaWBBNcCXX8LjtAfo1P1Kkj0gSwrKNsJYkSxhHp9aCptnx0Ucz9YxnOgBzWEw6WQzRTw1T2MMW3HhHjh/yLKFhwYYDFyECmLFxHCce03PYSfO7yi3H1OaoZC9O/XzKcF92McYf3EtUNbC54iyuLDNhM0hM8Dh4vX6I7b4DXH1ZHjPqvEhGkfFnFqJqMfrV++hZtJmNDzTRu1Ng3sqz8bVVU1ZeTmLlSoyiSHphLt+fOYGd61eRLhkwGCUUBI5Ld1GWl01JwsELV72KklSYdGYlEy6o4IHQ/azZtYbt4QyKuQxRMDAoK2SMc6EkUt8FTXELj+62s/bGFj57goG6BbkYTBKVC/NY++fU4kDlwjxsaVbOvPMk+vYM4Cl24cxx0Lq8kd7lqV0FATmP1jWdVJ02aquz7g9b2frgHnwtftLLPcy6fgqTLjrUrmjCkiI8+TYiQ3HGzT3UWuMd9r3SzLp7tgKQMymTk38yb+SYKmuoijbyWn5XgsQPyraH99CyOhWBvvLn67nwkTMxmHWp8j8Z/e59wijIJEkikyBOjDgxkqT8tDQ0bEYjj/8oBxGJccYJFFNHBjlkU0AlE/GQjhHTe4yio6Ojo6Ojo6Ojo/NfjzkTEOCgzyvmg1GI+UuBpaP1up5Med0CDKyEqfcfPdFX3xupH4D2h8EzBZxVH3yemppKyPdedVr+DMH6VERl3jkpwTu0LxWlbT10azj5S1O+y4Ih5be8+8ZU0r3EALQ/cuxWGu+T4OuvM/TggwB8pl6h6e6TSXeVcgJnHr6Bd3rqB1Kiv28LFYi420V8mDHKGqbOV5FDC0aaaLKMFo3Cu4TmAXqxYsMuOCF/KQfYy318hzhR5nAyq3gRLRojPBgkIKWRZp/N43XdCKIJGw4SxBEQmMTYKMt34zn3XOxz5yJIEmr6TzGppUhOB+S5mXDaT/iONpkXhX9QRi3XcwsAts4Y1Y8MYPInWX5WEmOGHZ81RtCoYRZFhs0KJg3qRbAJcFp/B8RF/NYgCVkmP2Bgc75CzKpgDPvR0BAQ2Bdtw+gTeX66yrYSUAU4sUMls0kj4jVSXjCHLb8SaN/yMqKs4qsWOL3OCKKKbdBO+9IaWmfv5gK+wF18DyMmCilnmH4MmBARKWM8vUI7kkmm1dRGQtRYbxnGwwMYMFI2nCQvqNBlA0syjsV9PFHPcdxv28q29AgQYQPLOZPPjlzDKiaNlGcrJyFIh0aSamgM0EMZtZzAEjxkkEsRF/AFXucJooQ5jYvJp+SI9+oElvAGTyIgMo/TxvT9Gk/Qxn5msIDJzDliH/8JeC5YysRZJ7GhXubz45zUlaf0kCfa+1A0jbZwjBv2NPHZ6lwWZzjp6QtjyX6WIG/wcPdOYu4wpJewY+GbTHh5ElV3nojr607Uvj7MixczMcND3be+QlBI0PXaDhqZSP6EAuaeU80bP3oLNakiINCyshXTxUleGXoFAIu1n6HoZvLF2ZxfnPrunX1dFct+vZMVLWnkOxLE/rGWp14U6T45mxN/OIcJZxWRPykNJaGSVZna3WB2miicmVr8i/ji9P7pceSuAKKgoUWjuPIWAJDcu5fgH+9n94vphOIeNFUj3BdhzzONhwjNQweGCXSFMLqstG8ZZLgjzLRLyjCYDn0W97/eQjKSxGgz0rO9HzmhjNSzec3MvKqCrY81486zMfn80kPavxeB7hBbH9yNIApMu6pujFitJNUxQvZHTdvmAfa81I630M70z5YjGXQL2Y8DXWj+N6GhHbS7iBDCT5IEcaKYsGDBigEjRszkU0oRFaSTRREVZJpysd/swoWX8/gP3eamo6Ojo6Ojo6Ojo/Px46iAym/B0HpwTwbP5MPXi7SNlhNDIAfBdLT/a6hjX2rq4au9F9Eu2PPDVORtwUVQePGR6/YvT9lkAIT2g7MW2v8Ow1tTyQyrboS0GYe2kw4mclKUlJitHRQxPsYEiPLAqE2He1BiSe8ZWFzHuJ286bfQ9zpoGhmyjSGjRpIEW007cJ9/IhO2lpDs6MB99tkYc0e3lP+d3/AKj2LHxQ38giom8WzoPnzDexDNFl7NeBybYuG876k0VankRg0sqliCY0mE13icGqawmM8wgZkUMCoWaWj00oEdF+bWYYLLlmEsLMS1eDFLuZr7xZ8TzpJIqkZu2DWdEx6z833DYrK//31EU0rwK+3NJlav0p8h0JUDXk3BrTowJRUiokJJLMIBB8Qj4GyGcEJDi4HZmCRh1fA7jVji4Aga+UzfZ0byCZlqTyHwyj/ZnBVHkCFgh3UqZK4yUGHM5TNpZ/DLmX9G8RhQRZnemMbbWUXIniCDs2qIWhyU48VEynbAgh0bdq7h/7DhZBUv4KOf9KAbNRkn7BbQJIEOOjnAXq7le6xLfo/JzfsxqTLZcRuWulNJ5p2FY/guyvxDdLtdpHPo1v9ERwfdP/wh8sAA3osvJu3i0WdfQeFefsxetuDCy9f5ORfweQD+xu1s5E0A2mjkx9x/xEfpHK5kFgsxYSGNUU/l9SzneVILITvZwE38gczDzPE/iawiN2f+y4aBXIuJ7b4gPbE4VlHiwW1t7PvndjwBjePnRDnuFgGbJKXW4gQVc9KKIAgoJpF78srp9RZxvmBkBiC6XLhvuQX3LVClaohiageFI9vO4P5hAJw5NkyiicK9fqyhJNLkNL5QV8mCtPFYDi4m5E9M47K/zef5b/dhX787tbCExu5nm2neHiGjzM2Sn83A6h4NHgwmZR5p6SE6GMP+mzbia4wMem34poUZb/Nhsht57LIXCK5cT2W6D3tcZTgqguAgaUsQyPIRVsLYpZSFRsfGbpbfuhZV0ejcnyC9Mv3g+z3kj3dSfWYZniIXAFufrmd1QzNCa5g8l4uKk0sOEaMnLS1h0tKSD3zvVv9qw8g1jAcSzPryFIaahgn1RZjy2VpMtg/hLX4Uov4Er9+2HTmh0LqhH7PTyOTz3r9QrvPe6ELzR0w/3XTSQjuNAPTQQYgAGhoGjJixUMA4qphEGlm48FLJRNyk4SF95B89HR0dHR0dHR0dHR2d903G/NTP0cg6GQbXgBpP2WkcVWQGshaDf2cqujjzBHAdui37mOh8ImXXAakI45zTRzyKD0GJj30dH0iJzJASjwdXH15ofgfJDBXfSkVgm7Og6LNHrvshcZ1yCqE33yTZ3Y1j7lzM5eXH3nhobepvQSDqLGSvY4CIycj6NC+1nWtZfNNtGDIzEd5lFRIhzN+5iygRBAQe8d3GdT8pIFbwd5LHxUA0kB2ZQY1zBmlNWxjXlE8R5SC0cxbf4ETOZqh7L03CHuI5UTRVRQkEkNxuHhTuZCMrsIUlPvu9BPbgQZFJUag49VR+zt/5s3ILm4aeJR7r4sXTJWp/sQnH22/jPDFl8WCtrcVmz+DFb7cjChLddolidx13DH2TrO130ShvpN4Z536zhhqA9e0mjvMbcTldJN1ealSNCxPfozJtOpY51SPnPXVLHg0b61DmbGfQJdNdCX25MN9lxJAwoETCLB6cy6ve3YgInB2TWJtZQH72YkLsJ5dMruCbrOU1GtlFkgQCAhZsLOZc5nEae95+gPDvHsBni1I82crqr1gxYiKXIgoZR2HaX8Hz/VRkfXo15J6Ncd8dfHnIygAiK0qsWPLstLAfDZVcirBgZfiJJ5D7U/64vkcewX3mmUjOlHdwBwfYyxYAAvhYzzKWcBkAfkZ9x4MMv+fjlMOhSeL8DI2UVRSCDP/HC82H46vVRSho+BJJjIKAtsePyScjiyIdO7Ko2T2eq2tUnpNs9DuyOb75VOZ8bTwvJgK82Zu6zj/f3cLDx9eNCMXAiMgMMPvLU7ClW5HjMhMvrEZc9jpf+EsYX3IIdniZ/5sFYz6rkPJPvnquysuD6Th8fWTZITCs4TBK+NrD7FveNUa4/W1DO2sH/Fi2Bcnr9FNamMPzx/dg9WrsLc5i+3efJnd1FClkRo1lMq/2ALk2N7tqM1jnWkvgpAF2NW7kzoo7MYgGOjb2gAaKrBIZiuOKJIkNxwkcGCDcZqFtbRfn/fU0FFHju/VraZsWQpigcd4GmS/ecvxHfp9iw6Pf7dHhGM5sO0vuXvih+uzbO8jWh3ZjdpqY+cXJWD2WQ+okIjJyYjR6OuJLfKgxdY6MLjR/QGRkwgTp4AA9tDFEP3vZTD3biRBCQcaAkVqmspCluEkngxyyyCObgmP3TVZV2HvQZ62mBkQ9tF9HR0dHR0dHR0dH50PgroNp90PSPzaR3JEQjVD1fx9+3HeLypIl5St8JLIWgW8jhOohfT6kzwRLHsS6Uscdle89Xvqc1M+/Eh+ELVenIrsLL075N38IDOnpFN53H2okgmQ/fCKuI+KaMCI229NOIlAyjXWh51F2NFD5sEan/wYK77kHyT167SKEkA/m7tHQGNqzidj2Hk56IoB0rYAzT2XRDgvl1/2A3pkGwuvXI5hMOBemxJzWJ//E3gduRRMENlxTzvG7K/Fu9TEwN4t1X+lFEo3gCzEU7EIgG5kkQts2nmYP5oDK+vVv05ExiCcxjFmzklRjI6IpgGixYPvDj9k+5UpiNjAaRdyksz/4OKrBj0HMoTju47R6L9m7+pmh5hEmE/vsPGaFI8wyz4SqS8f6cMthaHsMV3CQRX82sWW2StwDvgKNndNl3GoMraydr4XPpm7dkyTCA4heK92GNJ7iQRRk8hnH49zHbjYRIYQRE0ZMRAkDYMFKfOUahkItEILa12Q6PzMb8/Mmat/YQnv2V8i58UaME+8EOQCGVBRoxLcMGw6yKaDCN8wzeSt5NvZHCuRicuwVfEe4c8z9E61WBNNoBKuHDExYSJBKJJfFqC3MGVxCB01EibCUa97fs3WQ2SxmIyvooZ3JzKGU6vdu9B9Ge4/My29FKHSmcVGhwO5AiLbsCEYhiiiA02yjPO8HeBx2ZpcD5cD5qbav1rcRDyXxtYcRRQFfeZTcPMdhxzHZTcy4duLI68CWLeSb88g15jLwWoC/X7aCqpMLOe7y1I6Glrc6WPXLDaDBOTNzqfryAnp2D7Hx0bYRQdqenvoebFjWhb8rTFtRHFQN0ZckMZwgUu0hmR0jvbqQWFBmyBkhF1DMDhQpSS8lbB+oYu+bHbSd24dFStISa2EwOUi2OZvcyVnUv3iAwYYhDJrAQMMQtjQzaTlGElGV9j0+nrh+DcVXF+D3xalYZUKTNJozkkiHsdY4EqG+MI1vtOLMdVB24mH86Q8y7eoJvH3nJgRRYOrl44+5/6Px5k/XEvOnhGPRIDL/28cdUseda2P8GYXsfrEdV46VCWcdeY4fBEVWGW7xY8+0HZKs8X8NXWg+AgoKYYJ000aYAD4GGKKPNvazl63EiaEgkyBGlAgSEhoaTjzkHMwm28p+LubLHM8pH3wi0SjU1aXKoRC8319cdHR0dHR0dHR0dHR0/hWj+8jRxB8XBReCEoFYD+SdO2pzcTgkM9TePPa9up9D/4pUhHLG3A8+j4afwNC6VHn/HZB9ekp8/xAIgoCktEHn3pT/su0YRYzKb0P/m6nzTZ/HFQjMXGkj+bdnsEWNKPiJNzdjmzx5pImHdGaxiD1sxoiRxcvcCAYZp2biglUymaeqWCqaUfb9hBdutNA8KDHXfCbjnBOJE2PXC3eRJAYaZD7byJ6JCXZ9cYigI0l/3EyRdTyRPAvD0zLwb96DbDfw2kkPY6SE2JPltK9ewtBXu5Gd/Zy4TGPF5XHKpo8VjBoXmlCxoRAmoYXYGnqRwr9rmHYKOI9PY/CELHynZLDUJONKiBhyLQjVN6WeSWsBCAKht96i74XHaSkaJu8kExXFXTgnmalsUtlsMtBZnsCiigSrnHgNlQSEGGvFZqSsEJoKshjnEfdKwigoyAQZxs8g6WRhxUYa2WSRx0Rm4WMABYX2aSbMB4PMu8eV037nD4itaqZDjPOD0FOYH3mErBtuGPnsrGMZQ+52Cof9AHS5CxD2d2EZ7iGmheny9tJQsZ3JF1+MGosh9/XhOe88RPOoEOXGy5f5MRtYQQHjmMlJI8fKqOUXPIKCcjBp4ftDQ6OB7cxmMZM5nnSy3ncfn1Zaoi20xlqps07mxt/FaR9MUB+IkDcjwby5Jn547UzW5bbi7kgw9aQCPPmH11IuKsnhxWcaUTWF6a0aW7v3kXvz1GOag3HGDJJbttAz2M8bE/p59JzbWLTsPEpmZ5FV4aZ5ZfuIZX7H+m7mfWsG+dNy8Jan07Sqh+xqN+Xzc9nzcjurf58KMMwqNRISklg2Bsh2WSi0OVk0w8E+IYAZmckRA+asCKqiMu7caax9uAF/Ry82zURJz2y2eZ5j/sLppBtTFhnFc/KZduV43rp9E5k1FhAE3Pl2mld24B8WsGW5GO6KELu3hcoDFuSDgm1R0n5IdDaAvzvCQFOAnFov9rTUc6wkFV75v1VEBqIAJMNJqs8sO+w1K5lbQNGcfPrrB1n18/UkYwqzvzyF0vnHsOh5GDRNIxmVR16/u/yvzP1CDfK5fQwLg+A9cr33i6qoLPvR2/Ts6MdoM3DybfNIL/vftb79nxKaI4SJHvzpoZ0APoIMkyCOTJIYEQbpY5gBumkjRoQYUWSSaCiACActMEyYMWLGTTpZ5I/4Runo6Ojo6Ojo6Ojo6OgcBskC4774wdubvJB/7oefhxIb+1oOffg+gw2w+7sp/+qOf8Cke8ByDKKeaITsxWPeKq05mU7ldTQSGDIyMJeNFWwMGPg+v2MH68gkl5zFfgYaf4/RFSL7jD5iWUm6XQqdwT/xMApqhsYO6smglHHUkjMpSU5IYXAA1qabcAjQkxNBUAVytQpqmMZEcSb1P9xCS5uReLqJ/c4dVFPIgOwhXreXZNowPW4jr39ZZLzJQwAfFqwjc3TiQcKAFTtRQkx9QiH3LY22kIb7YR8zZC/zJkaRMjLAmpdagGj6DTgqGUpOQehVGbr79+xXthHcPUy9UUCZlEvF+fmsc/aycmKMioDAqe0qK3MHGTa+xQnOM+iyKqycUIjL30GTWyRmEEhGgyQNClFDiIQQx4adbDmfamkqFwpfpJcO7uQ7aGiUn1JHf34VysAAG8SJDD4eIM0gEZCt7E/mUmxJLY5sYAWv8TgtNGCuLqVqIMCwIUl3Whb5f97J8AQJQRBIDvvICnoRnRb2XJNDy0OPk/XseubyU5x1U0au1zhqGMfhLWkEhA8kMgO8yuO8wEMAbORNvstvPlA/nzZ2hXbxg6YfoKDgSZQwOPxdevb7MQ4nEIZjNI03YxZFrri4dkw7TdNoDcdwGw14zSkv4CyLiUt3iUT9KeFR9ioEeiK8fMtWgj1Rspfk8UwtyKrGV6oKmZ7uGunPeuaZGIqL+fXGb/FKhoZiCLF67kt8w5Cy6smsSad9XTcAnmIXBnMqQnjcnGzGzcke6WewOThSzm9OMs5rIpLmRBIEBAS+5qzl1afryXHamfDVbILdIYpm57H27i2oSQ1V0ZA0DVd/Osc9cDpfP/6zGN6V4LX0hEJ2PNqAEldIRJMM7PORXu4hujeKZJborfcjGgSmFWfSafZjkgUmTD1U+B1qDfLMtzaQjClYPSY+89vZ2DxmYv74iMgMMNg0TDKukAjLI2L0uxFFga0P7ibqS9lorL93+wcWmgVBYOaXprDxj9sxu8xMuaz2iHWf7HuSB7ofAGDZ0DJ+W/XbDzTmv+LvCNKzI2WNk4zIHFjRrgvN/6lECBFgGJkkCWIkSRAlzDCDBBkmRpQQfgbooY1GfPShHPwTJ4pKKlvoOzYWKioiIhKGESHZSzpGTIhIx253oaOjo6Ojo6Ojo6Ojo/PppPom8G9PJSfMPgXSDt1m/b4JNowmSVRiEGk9utAc60klBrMe6pVrHjeOwt/+lviBA1gnTBhjS/EONuzM4qCv6Wywz54Nmoav7U46On8JDLHJHSIhmDFgPBhU1csMn4OyaV4SPTGyqzXOmftTHo++Tm9WMxiNCKYYF/ElsshDEzV2lWwCYCIzUZCpPmU3Wfu30eUPst4Tx2/UyKKAzaxiHzuYwExmsIAXeZgEcSIEERFx94IQ11Bl8AQUEuFO1EgNQy83EmnrxXtmjOHq3bh29RPerrF7s5XMvgz84wZJaFH6kwKBZAT8vaRZDIwLaMzu1qgMwLggmNBYPXU9V5t/ySb7StbY+wGN8tcjdJYqDGeDJIBqTdIU3ozDJ9Aa7OehqggWoxMNjQ6a2ctWyuvG04dErGsH3cZG1Op8MtpC9M/ewROXWfgMPfyd36Ae3AXtE2MIWcXYcSHgR0zzsPBJgeWXRsBk5An7g1zAl9j62K2UPtNJAti9/XoCD36ZPZadjKOGU7mQfrp5jcdx4mEJl2HmKBH/x0gz9SPlDg6QJIER05g6iqJxx0N+ttTHmTHezNcvdY/xJf40siW4BYWU3+6wqYXi7AGaN4BBUykZHMS1N42sE03sf7Ob9i0DFE7LoOKEXG7f28bKPh8mUeCHE8YxyZv6bM37ci2r79mDxZBgRuxZ1l7wAkPJKsSMDN54oIH+7xShOSR+v6+dv8weG71vnDCBeH4d1sbNxMMyxZnZpJem+q07txJ7hpXIYJTyRSWHjRAGqDgxj/0ruknGFAqnZpBR7mTrY80AlM7O4o3bdqJGZbqI4rZamH99SkzNnZKFZ1Unof4oCVnEJBgoU8qxqrYx/Tuy7Jz6i/m0r+/GaDWw+S+7AMgeZ6G/W0FJKLjzHEiywORphRjMIifeMOGQeXbu8JGIyPTvHSQWSPDGrSJn3T4fW7qV/OnZNL7RSjKSRBNFHrlqFbFgkuqT8znhK4daZJgco8+h2XH0BICyKrMhsAGXwUWd49DdJ+ULiylfWHzUPgDqw6Ofh5ZYCzElhuVoO2uOEXuGFZPTRCKYigZPG/dv3i30KeNTKzRraAzRT4QQPbTTwQF89DNEPwGGDppZdJMkiYaGioKGhoKMgoKAiMCoeGzEhAUbJixISKSRhaSLxzo6Ojo6Ojo6Ojo6Op9+Ej5o+h0kh6HoMvBM/uB9WfNgwZpUUkHh2D1Ij4p3eiqSWQ6lrD2cR/HB7X4Rmu8DNCi+AvI/c0gVY14exry89zcHQaCr+AReczyJJSmzNjOJmV4UZEqoYhaLQG2gQKogmV+EhAHJUIOvdAWlTCFCkDJqySIP5DAnJmeQackhIAwzlXkICLSEL+f2yT2EhBB5qohPKKCESl7kYQD2s5N+umlkNzEiANiSkFkOZc8YsPTJSGkqijPBwIFhgjskel0WCPZg7VXQgmAwgkON0GXtQkRhYJyGZSZoMZC9kxg/uJFzTCK7HCDJIIjgsyRpNw6QQyGX8lUCDJFUQ5z0jw34CuGZayHqAJMR4kKCiEMi4g/gbdmIy2Kiy+0naA8jSlaa2I2PAUx5FrK+8RMSB2qJV3SyPC9BLtvJ5kWCDKMgk0YWlUxkBgvYyQZ2sp7upcV0jtuHI92LKSuHRnEPB9iLaWg0+Vgo2s/jiXvYb2kCYCtvEyMykvBPQeZCPkT0/0GmcwJ72ISGxmTmjBGZN7GKAXpQt89nVSoXISs2xpg90cLsSR9efHu/qFqCkPYmAhYcwrwjirIAkx2TebLvSVRUsoxZfPPsNIrX7CMpJ1E1WDKxGP++AMtv3wnA/hXdiF4jK4dSSf8SqsZr3YNM8joZSAxgmBzn8ocWEP7LXxh+YiudXbl091nQqk1ITiMYUnMxS4fuZO9T+lhgOQFjpQGTauDzrrH37UiRun37/Tz1jfVEfXEWfXcSF/1xLuHBOOmlDkRJpGBKOpoK2dVudr/UPtIuER61fJh0UQ3ufAf7lnexb0UPgioz/dIycicfusilJFTQIL3CS/H8Qt7+435Ek4GCKZlEA0kADCaJi/4095CFBkVW6d7Wh9Ul4m8PEugMgQA7HtrJhHNKKZ1XSN0F1TSv7MCYYWTjH3dgzEzDaDdT/1on0y8pw54+9pma9cXJbJAE5JjM1CuObl10W8ttbAxuBOC6vOs4K/Oso9Y/EvM981kfWI+GxnGu4z4SkRlS3t2n/mI+B1a04SlyMW7BR+v//J/GJyo0d9BMgjBD9BMmOOJ43E4TbexnkD6Ug/HKCjIa2kjEsYSEGSs2HAgIiEiICIgHj+kCso6Ojo6Ojo6Ojo6Ozn8JrX8F34ZUueFncNw/xyaL+yB8VCLzO5R+ASQruGrB4IDQfuh4FIweKL4KDAc9YnteZMS4tfvFwwrNH5RKJvJa+jz2sptK8rmFrwEaxVSm7BfSZiFknojJtwm80yB9DrWsI0IQJ25mshCC+2DPTaBEqMuYn/KRPkijuRujYMFIAlkUqGICeZSMmYMdJxwMBxNUDVtSodIlUnuejByC0BBsDBlxlqpEHEl8UiexfQLji0GwwMAekAXYeZrC29/R6LPB4k4wtIq0+0N4SOeEAS/JR/ew7NQEuKHHbsB2fx5X7VtPfm0u0mftnLJ/FzleGekNCElQf7aFzkoThlCSgCtBf1aEM+tDFJnryIuKKJlhtngHATBoRs5tCjKzL0i7t5V7MyWGcBEjwm42ESdKH10UYuQqvoMLDxFC7GQ9CAKGyeMRkBEAEYkKJhBa+gWiW+7ENWhAO28eg64NaAev00qeR0YmizxyKMTHwEfyPMzgBAooJcAwFYyKeat4kce4F4CocRcaX0A4aAdqMn54LeWR5h62+YIcl+HiM0XZ790A6FF/TkRNiYlxsYkM6aoxxwdiCYyiiNtkYKJzIpdl3MzbQw0szZhDeVYhp12n0LKuj7xJaUxdkM++FV1j2ssDCTKtRvrjKVG1xG5lzfAaftX2K2RNZknGEi5VBLoicXwRF7JsZLgjwqLvTsKe60BWNa4tz6Mr3sW9HfciazKn55zOb2K/IaZEcO3o4Kf35eGs/D3azTePSfh4OF68aTNtG1N2C09+dS3f330emeWjthx5dWkj5eM/X836B/ZjTzMz7ZJRK52192xh/yst2DKsXP6PhbhyD5/EcPtTTbzx4w3YnBKOdCNpdQWkV2cAEBqIk13tJh6WmXV15SEis6ZpLLv5bbq39xH3J/CkS4StCgaDiiCAvz1lPRTsDGKypyKTDSYRJZbEaDdjcRox2Q+VHm3pVhZ8b9ZRr9E7428KpnZWWOrtrH90GxWza6lZUv6ebf+Ved55FFuLGU4OM97x0SQifAdPoYupl384r///Fj5RofkHXImGjExyjMexhoYZK1ZsWLEhYfhIto3o6Ojo6Ojo6Ojo6Ojo/AeiJv6lrAIfsVD8QRneCnt/DJqcEpm901O2GHtvgaT/YCUByq5PFW3FEG0fLX+EGDHydX6GnyEcuA/19hVEqLhhzFuX8Q0mMBMjJiYyE3rvTnkmAwysSonk5pQoVeP9PK9p/4dDTCfDUsv3+BMv8vBBiwaBM/ksp3ERORTydc4lrg5hVjUa8wUm7wDNAXigOyBz80VtfLNRoWQrdBUbue4UmQtaIG6Ftz1Qv0AjQwZrEprs8LbDiykeZ12WE0no4pJ1Km/MgqgL5MFcGtbNA3E/0uYAp5VcTK75FYLnCayZpRESYWCcAbM5m97MdgRZwmRPo8g6Fauicpw/g+fyQpg0hYQWJz2mMrMvJRKXhOCEPhOv5kcAgQ2sIJci0sjCgBEXHgAWshQjJnaxkRM4kwDDHGAPU5hLNvlMLFzCy38NEU/aWGBaSh7XM0gvEgZEJLLJpo8u8ijhZI5t8SFGlEf5A310spClTOXQJJm5FJHL2AjLFvaNlK0TtrL4uATL/zlMiRTC218MfDC/XID1A37+0doDwN5AmEqnjYneQ+1fDjkXbddIOfquMsATbb387UA3kiBwQ3URaWYjD+4X0KjmjiEfxbZMJp1bwqRzS0balMzKIq3EwYG3erG4THjyrfysKJ2XuwbJspg4LS+dHx74HbKWihB+YeAFrjn/QYLrdxPck0602IWcZsMWhVsnjYq7X1r9PfYm9mDzmtnGNiS3hDrsYyDZQ1OWi8k7d5JYuxbzCScc9XzfHZmsKhrhoTgm2+EluvGnFzL+9LH3JNAdYv8rLSiyxmBziF1P7mPOlw9NYti1c4jlv97FcHcSf0+SQpNAIhQfOW52Gjn7V8dhMB3++zQRStKzvR9/W5BgTxiz04TdLaDKIlk1aVSfMQ6Aghm5OHLsBHtCZNV4KZhfSjKqMf6MIoyWsefVvb2PAyvaSCvzvKdgLAgCkxyT2Nm2m6z7inEa0ti4cwdmp+kDRQ4XWYoosvxvRxx/3HyiQrMVO3ZsGDHpEcg6Ojo6Ojo6Ojo6Ojo6h6foMoh2QtIHxVe//2jkzqfAtxE8U6Dggo92boNvp0RmgMAeiPeDKR3k0QRfJIdHy+VfA3sJaApazlnEdu1CcrsxFX5wce/dCAh4SD+2ypqG1PUs06IdkH0qOAFrIdGDO49NgoMM30YE73QwZzLO+1m+y3w6aaGKSbTTxIPcQYBhjJjIoZBW9vMaTyAhIUo2/OYEu9NUTneDIQSqLNJabmGyL07BIhl1kcAkspkq27hnUjuJiTEsgh0tEmbArJAbguPbLexrP4W3p21E8XajCQrZZwkEsgQ8Qxo1f1ZpbYJoTpxgjo+GHU8T32Zg+GKB+oXQZ5OIWCRUepBFBc2gErIk6a+6gryWp4la2tAsFgxNDoI5QQIoiBgQEfCQgcVgx0WEYipoZR972IyXDE7lIlrZz1u8TOPmLFbKr2PM7WRPwVY+L97IZ/nayKW+lx8zJPSBCZKo/JZn2cLbrOBZ9rMDIyayKeQW7sd7jPfvVR5jIysA+Bu3U8WkgxHlKXwMpDyySRvTbgYL2MwqFGRqmEpdVw9eoQtUWPObAYqPz0cyHGoTcSxEZGXsa0U9pnZ24XiC2hsAOMTjxxx7qq0PAEXTeKajn5Nz097ZE4CiaXRF4xQ7rGPaGEwi+RPT6NvnRzKKvPbTHXz2b/O5smzUkqbEWsK20DYAii3FSB4Ps+/9NW8mVqC2RPCabGTWjl67bU8203CgnUFPkLAzRtGkbGRBRjUYsccM5PeY8bUG6Fw9QM1M+RCBFUBVNTRVY/H3JvGPa1cjJ1RqTs7HnWc7pO67SYQTBLrCyHGZ9nXduPIdqAi07QojJzTkZ7qYcnkdVtfYSOrhzggWlxnJLKHEFSSLiRO/OYnNj7YQ6o8y5fzSI4rMACaHEU+Ji+7tqXtgS7OQXZfBybfNw5ZuRTKm2lrcZs68+yTeuOlt+vYM0v5mMyf/dC5ppa4x/YUHIiy7ZQ1qUqVpWRsmu5Gyk46+4HZT6U282vc6zeZePAYPAMGe8FHbxIIJ9rzUgcluoPa0AsTD2J582jmwsh1fs5/SEwpIK/V80tM5Zj5RodmOAxNHN/3+n8dohG99a7Sso6Ojo6Ojo6Ojo6Pzv4Y1Hyb/9oO1Hd6est4ACOwC+7hU1PFR6KcbE+ZDBLrD4qyG3ldTZXMWmLwgGlKRwK1/BYMLCi4CUsLfPmkHxQVzyKGQvl/+ktDq1SAIZN1wA84FCz7YOX5Qup9Dbb0fAQFhaA1MvZ9I3iIeE+4gLZCkbKAJ8cDNpJMJ3lngrCA3/zPkCqmIwGbqR2weFGTe4iW2s4b97CLIMEkhgWAU2J7l4M+nZ1CzeZgJ0jkU1K7AFOhGUjVsqkgFpYwXinmdLpyCB0WVSUgqhiSYggJT2utoKxmPkvEkmiGJIGjsPF0kfwuU74SK3nZOND/D9r65hCfuYVHRcrKHEgjbzbSfECNhtmBAxI4DmQQaAibM1LvjxOviDGsJqhP9tCsxQh12AnlhHhwHcwZFznR+nauzLmCIb6Y8jdEooAwJiQrq+DJLGFD6CRYbIezBEsjHOSSyO2NTKkIcSJKkkd3EiZJONsMM8ubGGPtaJ7Jo8hSKyv9OD+0sYMlRRWZV1XhzUwxF0ThxhpWEYTQyVTm4W/wdlvE0T/MXBEQu5aujySOBGqZwE/fiZ5ASqlhr2DJyTJQEhA+RDHBuloe3+odT1hnpbmakuY5Yt6tP5oHngkiSwNVnX0+eZz6CYMEq1Iypl2+zUB8IHyybmZXh5om2PnpjCUrslpGkfpCy2Diwtpcdv2ugt96PzWvC5jUT8cWR48oY8feKnCtIM6QRUAIsyVgCgNVg4Jt3ncCXb+qiJyTStc7Mr2bLqDaFP720j7SBefhOeAkpBtcEriPNmM5Afi+1TT4GOl+nz1LAwDrw/2Eb874x+j2TiMg8+bV17H21A0emhXN+fRzfWLOE7l3DhPoj9Db4MZvBmmYhGVNZfvsuYv4EM6+uJKvcwUvffJNQT5jBRh8ZVWmIkkh6VSZdjUkSZgtvJLLovbuXb309H5cjJarueXY/9S82Ew/EyK5Nx5Fp5tw7Z2LPsLHwWxOIvf464Z99gSGbDedNN2GsrDzkHgmCwCm3zUdTNHp29GP1Wsiblo0z51CbjshglI6NPYgGkUQwwf7XWqg+swxbmgWj1XiwTgw1Obr48F6CMYBJNHHGcaexYtZaOjf1Ys+yUb7o6OL0yzdvpW9fakdJoCfKnGur3nOcTxPNq9p569cpK5l9rzSz9I8nY3GZP+FZHRuf2mSAOgcxmeBXv/qkZ6Gjo6Ojo6Ojo6Ojo/OfiRIa+1p+l7AxtBEa70hFSFd+B9wTeYYHWBd/BEdS40z7zUwWxkZXHkLWIjA4IdoFGfNBPBhRmHcO5JyZ6lsQCDDML/g6IfwYMfEN+WckV69O1dU0QitXHrPQnCTBOpZhxsIMFhyyQziInxYaKKTsqNHNjbE3iLIZEZFiuQJTsp8/G/7MC3ntLBKMlA4J+LUBXP4DGBPD4FsP0R6w5oJnCiWOKqzYGe7wEtkxhZah86i68A2ixjAKqShvTdCICQl8eTW4006kdNvL5HVl0ZVo54BTwqZI/CRvL09514wKpQJgTDmQdFo1fja7hYLMZSwcyOKE1nbCBoUtTTBzu0TBkIZlQCXL+QrzxeV0B1QW7klg84oY042cHChnZWYYJx4mcByreYlxbyXJHpR4+sR7CDv2UqwmmSyZmWBUWf9iCb7L69mWYWJ/jhMbLi6gmLO4nBd5hCRJ0skiQZzVvIKfQeJE0UwKajRJnCgCFmqYMnKdX+IRVBQG6SVCiFMbfsEdD6VEsNfWwh9uvJastPeO0r/viSAvvZWyNdlan+DzV32GFhroo5PFfGZkYcTPEE9xPyoqErCcZ8YIzQAZZJNByj956pV1xAIJokMxplxWe4hP77+SIE4QP2lkHvLsGUWRmyaMe89zAfjV34ZpbE89J6GIyq3XTzlsvRvrSniyrQ+zJPKZoiwsksQ9M6rpiyXIsZowiilhdVWvj9vrW3Hd0YLYn8Bk1HC1xan0mpl0bskhEcYG0cDSrKWHjNfcpzEsWbC4YTiosmZ7nJa8AXYXCmRsz6XiH9cwx2Ol/7Uw/YSZdf0USk8tZc19DsJDSbq2RejY10haZRbjz0gtyux+qZ2GZZ3IcYXhjjCr7t7DxffPY/XvdhMPywzu95GeI+LMNGEtyqJvX2pHxIrbdzL7imKiQzHkuEI8lCQeSGDxmJEkFU+hnVfCefiTBqKtAvc+HuA7V3nwtfhZe892YiEFm0VkykUVTP1sDZJBpGvnEHJCxXbvfQiJBFoiQfShhzDeeuthr7/ZaeKsexax7Ja36djQQ3QoRjJ2aMT2hgeb6GsMoikqaSUOmle20/DCASxuEyf/bD6eQhfpFV7yp2enBONM63sKxu8gSiIn/XAOUV8Ms8v8nhH3gwdGd5QMNAWOaYxPE75m/0g5GU4S7o/oQrOOjo6Ojo6Ojo6OzvtHlmXefPNNmpqauOSSS3A6nXR1deFyuXA4Dp/oR0dH5yh4Z0LaTPBtBs9kSJ8zeqz5PpAPCtEtf4ZJd9Poe4CL6+sRNY1A+k1QtTx1XFOg61mI96UEZFvBaD9pMw8/tjj6X+429hMiJR4kSdBo2EtlWRnxpiYALFXHHnH3cOxGtht3k5QkOmlmKVczQC8xIjjx8Eu+jp8h0pImvt0xG6eQlrIMMYz9Dnk0u5nFgwasySSbM0QSlk3sYTMCsME1yDxRQZCThIkQN/jJVsxw4PegxkAJU5tzFnVZM3js1xchYaSfiRRMbSZW+yYGjMz6a4K61yBUbmLx977Nc/H/44mKrRg0uGS/gjcm8mCVSqMnhIJMfhB8FohKoAkgmyHsAVWI4lPe5o5GI4oq4o0rJAoFnitX+cJmAdeghOAT8UVVxm0yEI/HEa5QCRYaMCeTI6LvYj5D5dPDGP7yGhpRBt7o4+2709gjhijFTiijlHn5M+iMRYg4rDjJJoif2/k/nuWvCAjYcJBNAUP0E2MfCeIgqRhMKnmbpnKluZmFWiEZ9lI46ObQQzsZ5JBGFgICsZZSIAZAIgl9Q8oRhWYNjU2sIsgwb++YQSAEDrvA7qYEbrL4NrePqd9DB7fzLZppQCZBGePJpuCwfb+DLc3KopvfY0HlIL10chffJcgwE5jJ57jxA1uhBsLaSNkfOrzFhqZpvDr4Kq/4Gik1zmNu1EOJw4pZEim0j83l9ULnAKoGAQsYZRWDTWLbwj1kXj5IRsWxid+hpMz9/TvYGpDIN6WRZbFQkmdgj6ywd4IZlycdc1Slbtkg3oO5xFpWd1B5aikTLqzmxR9sRlU0HFk21v55H9XzPCiNjUhxM5IxJY6qskp/o5+XfriZyHACTdGI+uLEHCasTgXfgWHe7UHvcSZwBFvAmo/FbcZgNRDoCCLHFaSkSr6/nxyrFTlmxRdMWXA0ruxm96oASlJDMghkTfYxwyCy+R9NbHqkCSWpwt4Z5Fr6mFzYRobryJHnAL4WP12b+xAlkY4NPTS8dIC6c0cjoDVNo2XdAJ6qHGIDQSzpDuKBBIIgEPMnaFrWxrQr6xBF4X0Jxu9GEARsadb3rghUnZzPnpfaEQSB6pPzj3mMTwulJxSy75VmEqEk2XUZeIrdn/SUjhldaP60o6rQ1pYqFxWB+J/nK6Ojo6Ojo6Ojo3NstLa2cuqpp9LW1kY8Hmfx4sU4nU5++ctfEovFuPfeez/pKero/OchGqD6B4c/ZrDDO+4DUkqEndaXRNRSAljp4EAqAtpgh47HoP2RVN2htTD1/jFC8ntRRAUO3CMRzRVMIPfWkwi+8QaSx4PjWG0z9t/JjP6HqTMIvFBbxX7HLjbyJg9yBxoapVTjZ4jiIR8L9x8gKbeCkAuxrkOug2rJ5JG6QsyamSrbaaQRpondxIgybJf5/cQMJoW9VA6GqBkKkS1noiV9DCz3MdijIEx5lIULCnjtYNR0oPo1OjJXUUoV3qYks5/qQcJA8TY3O9bfzwsLdmKQZfJCGi8XwLiASlTUiEgaoqYxZAFXAmQLJA5ql4oZYmoEFQ1FMWLWRCIixO0ag27YUWXCUWSgaX2S0NokIgpiWMSWK9FosvJk3Iwr1Eydo5JXeZSqLWtJD8WISgLxZoXuWBDR4majNJEaWw3Xj4sx2ORmf+cAyyZMoFc6wOvCs4QEPyYsmLAAGn4GySSPIiowYyFg8fH54lfJj5kRghIcuAfG/wSAuZzGTtYTJcwizmXRDCevrk4wFFCpKTVSVXyoTWaSBEZMvMrjvMBD9Nfn8/aBLJI9ubjsIksuP7yn7zvjTFfTMWidFIsVXCh89dierWNgDa8RZHhkrC5ayafkA/V1zTlO7vy7H0mCK886fMLAx/se56bGe/EnFDYIbxHcfSt/mFlz2LolDgt7A2F6zs3E+doggyXbaZi9ApPqYlvT2/y55s84/mWxJaJEeGHgBQyCgdPik/nFP3/PY2VvIi8spLnreH686DomVRjpf0ymbmOErml28n2gBiX6++KkFxrJrksly5x4QTU9jVGaVvciGkTMFgh87WuoAwPk2l0cd94X2bvah68tjDPHxkBTkMhQDINJRDIJSJkyj859lOiEIGUtk1m06xymzzdg+s0PmKmGCIsFOB+7Dclq5KVvrECURPx9UdK7Ouizm7EO9nLBt08jGU2y8o6tCIkoaCbkBGx7opVTf3wczWtSXsu99X6CvVm0G7x0ieV88XOXoGkag43DKLJGNCCTVenG5k1F0f6rnYoojX0tCAJZVW566zWMdjM1ZxXS8vp+5GgqYt1d4BhT91gF4w/KvC/WUH1yPiabAXfu0f2vP414S9ws/eMphPsjuItcH9gz/ZNAF5o/7USjUFqaKodCYLd/svPR0dHR0dHR0dH52Pja177G9OnT2b59O+npo9vdly5dyrXXXvsJzkxH57+Uim9By/0pe4vSzwFwnOM6AoN3ISGRYZkC0kGRItox2i4xBEoUxMOLY4fDhYf/4y72s5MiysmhEJzgWXro1v0RVDmVaFA6GLkZH4D+5bhJQ5X7Gd/TR1r5PN7mVbSD6dEa2cWUnhCzmvZRsHcYixwiniswbN1IhAZKORg5nfDxuT1+Hrf6IGZmlvM0/ONS1g5B/AhAo02k16bQkjkRLbmYYDIX7S/XYlojowhAaxxtcjcFJ6+hcU0p7vJtaGnd9Koq2ckoNQEbgsGB3TaeFSXtIIiEDQK9Zo0pHXBKO2zP0IgLUSQtFcUcMgmkxwUGLCCKJhLEkQUNAfhNbZLzWgVCBniiGBAFurc6uKvfTP6UBKU7hzGGNDYcb+K5+Tn49pchDMUI+UQ+O/V46mOvUpkdRkwqeBLQMU0gptrJGC7mR46HyPY3IER+SRZ59ElWzmwK8JesZRRKccJOEUWUSRJjAyuIEaWXTjykU0o1fXRhViUihGihgQY1xjIGuZSv4iUDAyYMGOngAN40hftuymBgWCU3Q0J6l2g3zCB3cyN9dDKbxfgZAqBrSxnGjH7KrEWgCZy78PA7XEqoIl31M1lpRkKiUj2AZPCD8NEIe1mMJtMzYcGF9wP3NWeyhdmTDgqZwuGjopuiTbyTTzCm9ROQI0fs77ryfLIsJkKFMvFpxbw6vIccxcxefxiDGGFfqIepnvIxbX7V+is2BTcBUL9JpjEaRowGiDlbsUwbILf8HDY82EvL0y2cFFPobw5g9SnIXSp9oSSWbBd156cie/f6w6jn51JqkSCsMKE6gPrgAKGBGP4dQ9ikLVz7zOf4xzWrURUNVdGQtCRmQaOgxkLvec1ES4PYM6z05Dcw8Yp0Mh94kx6fCZvVQZrQhydDRsrPxlvqxt8WZDAQw5epYDQoQIThaDcb7hsmPhDEQBIRmSQW4r4wr3xnJbmTCxlsCRIdjiMaRAS7nf6oAdHtZtWvNrDvtTY69kbxlnrwljg57zezsaeZ8Ra7mXZ1HftfayG93EvlaYdGiJ928xQa3ujC4jJSsSCXygU5NC1vxVvspnxRyft8Oj4CNHjzzl1IRpG5X6rBk/+fpaeZnSbMTtN7V/yUoQvNOjo6Ojo6Ojo6Op8S3nrrLd5++21MprH/sSguLqazs/MTmpWOzn8Y8QHoeQlMaZBzOghHiQSzFULtzWPesuddgd2QB4kByDoF3hHAcs4A38aUwJy1GIzHLjKP9N0Zp3KjH1NRPwMbXkTx+/FceCHmkpJDKwf2QP2PQY6kEgvmL015QRuc5MuleEgny3oe2SxlmEEa2QVAKTVcFLAS2NJPdEMM88Q4/uhunh2nsJNvcy3fZxKzIFiPqTfOca0pD9ln+nZQdEMMUUiy6H4Nx4DGrvNVrONzuYbvsd+4g78YH6QoK41aZ4SsqEpSEtjlKaBmxmaKzlxJJNZKK72AQLTYjHhhEZkr45inT6Wk2EA3CdoC28lqinD2U2AW4VwPrMkGRQATAm7ZyFeHzuSRgi4MGNnLVmKEkTSo92j8xmUlIcRRNQX7HtjfO8TnjQbkRpXBzyk0e0QEZ4IMqZfo1C6S/gwYzKVHa6ck7iUxJYqWC0IQmhdoRM29dKgx/vpUiO+dWQiCyAvpbbyS3gGoRASVXlMUgyYgYUPCSBw/VmzIJHHjxYwFFZWHymQubIKkGGNliUCcDh7hd0zheGQSmLHQThPtNGE0m/lH9u/Q0FjEuWRTQAGlrOYlQp2NGB0G1rpf53QuYS9bSCvtJbBuNi67RFaahNd5+Oe6gjou4FwC/B0nHgxAUuvGKOS87+f1cMzhZGSSdNHKTBbi5MNt6T+SwPwOC70LeWNwDQ2BIOnCFK6vLDtiXaMo8pmibAabfLSs6WRSwSIukFYRVxN41TpeaReZ6hnb5kD0wEi5Kd7CrLVR9nl8eEIBAs7pVDjyWd6yB1VWMQ/L5ParaEAgoSKZJEIDCfr2BWjLEvnprmbiYQFPqZn7T6vAOtzP0CMmBpv70RBp7XIiPtnC3C/WsP6B/WiqgjEhYLKmbDLskgslqRHsiyKJIoZCEyvWZrJ+zfEkkhK5UguJhauYcU0dJ/90Ho1vtDK0vpGm5V1IMQhUwNvb2jD+vgNBSAmViWAcg1khPd9CoD3I4luL8BTYiAzF6d8fQBAE8qekk4wmaVnVQTSgoCQ1wgMRLB4zPXt8lM1NPTvjl1YyfumhCQPfwWw3MvHsUc/ljAovGRUffCHiw7L89p0Md6Q8+Vffs5cltx09CazOR4MuNOvo6Ojo6Ojo6Oh8SlBVFUVRDnm/o6MDp/P9i1o6Oh8K3xbwbwPP1JS38SdFtBta/5oSfIuvBkv2ketqGuz+PsS6U6+Tfii69P2NJwiQffKh77tqYdpfQQ6C5f2LdpGdO+n+wQ9AVUm0tCClpyM5ncT27KH4b387tEHHY6OJC9seTCUXlMww/qcIPS/hsOTiyDsHgLO5knSyiRBiPmfgSN+NGnmdwQODdHeaaHAptC9yoqGxh80podlRQTBmBZLImoEDgQry/W0sfsFF8atRVFSK6xNk//1LTDHM4XkeBKDrjGq8GxL49w3RON/InukGIhwgoYRwJYawiiAiYJU1mk82MWVKFUy+nstFB2lkM7jJS/XdK4kNRulGY/VlBiAJAsQNAk6phjcLjExjPgeS6ylIWumwxFEFAadmR5CMaJoEapRwpor3OBWlU8MtwoSgSLkEBFWmD8T44RRIOIZxma2MG/LTYXfS7XKQg5+hYo2NOYCogTHO2tw/g/029gensazvDYYKwJpjwO8IkxA0kogkCBMnSpIkIjE8ZJBNSqjPp5hhr4O/TbfhY4AMrHiAQXoJEUBDQ0DAip0McvkDN9NOEwP0spxnqKCOU7iA9N++xfGv7UQxiey8qZrZkxczidmEZgcYtFXQ3a+wYLoVo/HIAm25cBFbhecY1gbIFKZjEQ5vNfFBEBA4gTM/sv7eC7cwnu8V3EWRQ6HCVnFUYVrTNAaa/Lz23VUocQUNjXmnfYO+GjCTcdi2p6afyiO9KUucxbE6ctv3o71ioT9Lo6v6BqySlerFeaz/235CvVEkk4jBLBELJjBZDQRFEzf8PogvQyVSIdL4qglFEfhmwwC/+2Y2tlt/RvvVDxOwFjEoZ5DRG+X4z1VTc0oBUV+MZ774OslwkkRcxfBwAXnVdbRKzUwOHcfGf3bRtF4hqljRNJV2uRxzX5JdL7SRVeViwyPtEBcY/IyRuFvAk+/E9HAUa44bf2OMjHFOKk6uo2NjNya7gfQKD5LZyPYnW7G4jDhzLFSfUsDCb03EYDHgzLMTjwQQRDDajBgtEpnlR/du/ncQDyV57bbtDB4IUHNaITOvqDimdkpCfVf50N+tPk1omvaeiy7/KfzPCc1dqwbZ+qsm+jb7iXTHOe3p6Yw7Z/SXBE3T2HjLPnb/sY24L0n2TA/z75lA+nj9F3sdHR0dHR0dHZ2Pl8WLF3PXXXfxxz/+EUhFeoVCIX70ox9x+umnf8Kz0/nUoCah7SGI9UDe2eAa/9GPEdoPe28GNOh+FibeCfZjS6ZFYng0yV7x5eA4NlHgiDTeDsGGVDkZgLqfHbmumhgVmQEiLR9u7H/FYE/9vE9aHrmHvvt+j7GhB2txOVoigRoKITmdaNE+nov+kvXW3ZRTx2V8AwOGVET2O5i8o5HV9lIou37stDCwgCWjb6TPxnnFnwhvP5doWxD/BAVfeRQBN7XaVEABcwbGqXey/O9v0TBYhqMgi4kZkLktD0PjAKrZSOGJFsKbb2Jd+pOMLzuDPqET2W6g7denMBTvIH7gAJ2RBgSjCcUokzSr2FUTMVHFKXiZZFgMVefTa4UudrGUq1G9s2nka/Tb9tB0lpEd46wY6ERFwYINRVCIqsOc2lODsX2QuKUSj2wiljGDwuJbeI4H6Re6WGZ4mgOZe9lpggyzytcjYEajKKQRllJJ9AyISCYZm9iDa+tONr3dxTO5aaQvkeiwDRMTNVAkNEElNuVFzucV5ryyD2c+tOfKxIdAdFkIG+PIIshEkTCgoaEgk0Y2J3AGO9lABwdIECeTXOZyGvvZSQv7cONlNS9iw4kBA3M4BReeEasTH/0jt2199CWuei0I5BFLRDnn5Rq8kzPwkvIAZtKxPW8rhFW8LFmwko6RJDcLh3pAH46eeh/bn2zFmWVhxuUVGM2HT1D47+L5jn7+2JjazTM/y8O3a48uMj/+o0289UITxo4hsmvc5LisnCul8brNhsto4KqyvEPaXZxzMTOabQiBEPnVXvpz78Le1kt7uAZXfw7xYILwYJyoP4FCyt5FiylklLlIytDgyiAkmgj3JFFfHuD4hkFkk4EOZTztvWmMq6uk6qef47n/20A8FKN5TR8Ny7qoWpiH1Wvh9NsX0L6+m2hQZcsTbUx4cz6l/ceRXuLAnxFJeSGLApoqIpASTtWkxos3bcHXFkIUYHHAzbw/TUfcG2L1ni2oTisZU4o47vIKpl5YRl/9IMHuMImEwPanWgj0RhANImnFTgomp+PKTtmqnPKz+ex7pZnJCbCk21PHcj6Yv3HUn6BlfR+eAju5tR8uqnnXC2107UxZyGx7opnyE3JIL3lvjW7e9TWs+u0ekuE48Z4Bnv/qMuZ8dSrp5aPzUWSVdfdspX/vIKULCpl00Ue3KHOs7HulmY1/2o7ZZeakm2aTNs7zb5/DR8n/nNCcDCukT3JRfVUhr5y3+ZDjW3/ZxLY7mln4wCQ8lXY2/aSR5xav49KGEzE5/+cul46Ojo6Ojo6Ozr+RO+64g5NOOona2lpisRiXXHIJ+/fvJyMjg3/84x+f9PR0Pi10PAZdT6fK/m0w/cFRD9+PikgbHBTC0NSUP/GxCs0tf4TBt1Ll+jaYfpho3fdDMvCusv/odSUzZC2CvjcACRI+2HAJOGug4ttg+Iiv0zEQxM/Wl36FZI/gNUWgrwNn1QQEkwlrXh+204OUbr2dnuJCNucPUcVk5rAYSq4F0QxyAAouPKaxkiRQUTFjQfLm4f1qJa2OISaoRiqGppDnWIyz4RbqlX1sL5vGCYV3YMo/jQPdPVinf4v1t+2k9pVO3AELVIcxTYmjxuPQs4qJ7pOpzrwZDZUCyvhV/RK64kFEWUNIxjG5vXgQuKY9B9XgZG7O78gomUQDO7hJOYVerQW3YufnEx7nT/eLdPsEusrjRIRBVFQ0VOLE0NDIGepiXNs6hD09DK8dQPJkkneJlfriPRQnx5MmZrNX2kpSSjLo6WGvGGbYqREXNTJiMiZEVDTyIgIO0YNVgbv+1EysMUG9axDrgIj7SjfYwmBIgCTTbd5BN5C4GM76uYSn0wQ1JeyakIXGBgRkJAwYMKCSio7spZ0tvEULDXTRioqCgMhEZhMhRFwNkoz0Uh7M5+WcIUqF8TzH37BgYZBe2mjEgRv3QZ/jPEslhqwOsvtSgqq36PgP9Mx104oiSISwAUPEiGDnyMJcMw38MXkbkZvLyQ2X4SUD0SAy66oj2yT8O3i7f3ikvKZ/9LOvaioPdD/A/sh+FqUtYmHaQgabg2xc1UnEJOEwSHR1hijMc7Hw9ArOKzxyVG706afx/uUvAMSqqrBnZpDZ7cdQ30jHrx/l5WXH098tEDeApmqpSGmrAU+BHQUR2ekATSO3qQf37i5CkhlTUsa8s5WstJQfdNn8HNzv8gduWdtL1cKU6O3Od+I+10lkOE7Dij4iQ3GiwwksbhOZ41yc/bOpPHjRcvxdEaxeKyVz8zEYNRqe3Y8WSpIQLfjrA7j2xdn8l704PCLBfj+1ZxQx6bxUvq+s6nR2v9zNvuVdqIpG1BfHnmFBlATyJ40uaNnSrEy+pPaY708ikmTTn3cQGYwy4YJqssenFkTkhMKz396Avzvlpz3j0lIqT8rDkfXBPJKNltEFD0EQMBzjAkjh1Awu/et8nv3S6/jb48T9cdbds5Uz7jxppE7TG600vdEKwPaH95I3JZvMqrQjdfmRo6oaG+7bhiprRAaibHt4DyfdNOffNv7Hwf+cclp8WhbFp2Ud9pimaWy/q5npN5ZTdm4uAIv+Nom/ZL/Ovkc6qft88WHb6ejo6Ojo6Ojo6HwU5Ofns23bNv75z3+yefNmVFXlmmuu4dJLL8Vq/XgztOv8B5EcGi0rUVAiH73Q7J2esoeI9YAlD9xTjr2tHHpXOfzh51JyDey/HRCg5Or3rl/+Ncg9G0KN0PSblEjevwz6V8CUP4Cz6sPP6X3QQzu+UhPp/ii+8U6onsSEGx9E8nph2/WE4/XAAJO6e9mRn4vEQRHFYINxnz+mMZIk+TXf5E2ew0UaX+dnzDIt5M6KfrqFdkDgCuOV5Lespl7eTZIEZS1r+IvtXtZu+gqm0n2Mf30P3jUDkEwgawrxOg0yNUQlCmoS4/BeKjIPRlJrGl97sgTf2z08epWB5acOYcLC6ebrOGvcN0G0jERgb2AFvWoTaAp+Ic6rvm/Rk5WkNwMUZDQ0REQ0DQQVZnaW8fXGRizJA7Q+qiD7o2AysT13C8udT9MntbHV7qHAlY7BYsAomkjDyD/G9dHuAG9MYEO7BYtNYNgmYzQqVAcMJDvBb9RQRIh1JnE5/SCbASE18EHaJsD2kxWy+gX6zs5gIrPppp0kcaKEkTCgIKeir5Gx4yCAD5kkAL108DwPkiBORjSGMRFlVmsbUVni1cJtJIhzK9vJIIdCykgnmwWchUyS+cIZSLcFCLzwAlJ6Ou4lS/ggzOEUdrKeBHFmcOJRRWaA53mQYMKPEBbpphUvGUR88Q809kdJncfBbn94pPwOrw6+ytP9qcW23eHdVNmqSEvLTAmQCZlQcRrKSV6W/t88LC7zUcdI7tgBQFw2kNi0D4ddIaGZgCj2YCtt7RMRjC5i5VaE3gTRTAPCcV48cQuh7hgzYr107h3CMuhHVpIYFRXBZqCuWsVhS/loGyQN19A+uvZHMaU5yb360F0eNo+Z8+6eRdPyNgYOBHHkumjfNMCLP9zGjKtrOembdQiCgKZp3H/yEyAnMQhJRFHA7jGz67l2lKSGzWvG5jVTNjcLyTDq4921I/XvhigJZFV7mPHZctJLHWSMS4nwXTuHWH3PXgRJ4MRv1B2TZcbWB3fT+HpKpO1v8HHB389AMogEe6MjIvPAviFW3DbInsesnPTD2eRNPor10REYf0YRwx0RBg4EqDm1AHfuB4uyBuBfguI1VTvq648bURQw2Y3E/AmA/8jkf//K/5zQfDQCzREiPXEKT84ceU8yS+SdkE7PGp8uNOvo6Ojo6Ojo6HxsJJNJqqqqeOGFF7jqqqu46qqrPukp6XxayV0Kvs2QGIS8pWMtFj4qjG6Y9FuIdYElPxUpfKwUXQbhllS0tSUbDvwBSr8wav3wfkmbCcc9miofax/2klQksKamzgFAjUPXU1D1vQ82j8MQjqqs2xEnO12iriiSuk7S2EWhIsrp+e58hp/fgmgwc+5Zd2AwHbRCcJTiiHeSRT77DH6O74wyQ+nkoO3vMbOON1jJC8SIEqOTf3APtcI0utNyQHaAaKJBCjPD6MGSjGOX43S7nJiMAiYjyINFmDQVoxBCtiqIgyqZ60SGlmr4rZCZECmJjYqVsYFXefP8bfTU+Clrh9qe66jNuJIapoAkICMTJYwTN1VMRFI1FBSMKhT1t5NMO4dHDfVoaNhwIiERS/pB0XD3v4I67EYzghKOYJqcR8Ago7au5uSOCEgy47IDPG8yMM8yg0F68ST2sseb0pCCSEjpRlqKIoiCikeETOdJLFgc45evvIFRUHGdJYGmIgCaJowRn2QLrPg82JCQ2MF6tqKQxIINAYGTOZdhhtnOGkIE2MUmbDgQNBFBFpEMEulCDj1aGzFRZlEgj605Gps9vQTe2SVABAUZMxZyKOQkzh6dQLaV9GuuAVL2Hz4GDib1S8k3YYLsZSs5FFJA6WGfhyomcgv3EyZANgXv+fzYcYFdQbuoA+nRcdi9ZiadW/I+nsCPh0tLciixWwnJMidmj37PhZXRBSwNjYgaocBj5qpfzOKhR+uJZhu5/PLxGPx9JDtDGKqrifoTxEMy3oKxUbXqrNlsWNdN444CRLubE4q24vEmCA/GCHgqyaxOo+6SOnrv2cHGighbFjoozHWQti6GuzmOrMbIGpTx5FiJSB6Gd3dwQvQZMrcnaPzxLryXfw5T/SZi7b0kky4MQ0PkmTrg4L3zdwZ5+85NJCMytdntJO/9Mw4k9uScSzCrGoNJYsfTLUhGgdnXVhEeiBEeiOHKsxEZjKIoIhiMDHXFifs00rIE0ss9ZE/IZM3dmwn1RZhwfhUls7PY9XwbABULckciqt9h1W/3jIjDb9+7l3N+PXPMcSWp0rKuD7PTSMHkdADiwQSRgEw8omL3qqiyippUMBgF0ood9Df6ifsTGNMM7FsboP/zb3PNc6eNWHUcK5JRZP6Xjz3S+l+Z87VprLtnK4IoMOv6sYum5YuL6dnZT3/9EKUnFJJVk/6Bx/mgnHjTHLY/sgeL28z0ayb+28f/qPlEheZhBjF+wlp3iAC+g3Po7wkCkMgO4zu4GgkgZWv4W4P4GPj3T9BggC99abSso6Ojo6Ojo6PzX4nRaCQej//XJIPR+RixFaSS0qmJ9ycAv18ky7HbZbwbRwUUXwmNd6Ze97wE3pngnfrB5/JBPhfuiVB4CYSbUhYURi+YMt+73TGiKBrf/c0QLV0yRDv41vF/54SaTqi6cUzyRDMWvmG/m+aL6smhkDTeNYfyr4K1gOxIM9kDb0PEADyWuoZps97XfIyYiJIS4Fx4cZNGkVBJm3E/AgJ1zABvhNx2JwEtSVrSxGXChZx4jZeX3zZTlvZVchp+iG04iLVAI+7WeD5No7tYJGLQOJkOzmMYAYEnzY/zdmEf3WUx4pJClbgdC3upZSpP81fu4YcYMXI+X+BqvsONfUtZxjPUBkycOVSOP3gGK73L8DGACRPjqGG3/BaCImAUFToMcQq8k+C6nUjD7XglCXO2Sk9SQEWgwq8RL+kjSoRTuID7XF8jLQoGTSBpEInZvBjEOCISEhJavI+Lj7cyY+I07hm3m85xmYTUOKo8gFERCRkUBk0JQEXTNERNICqGMGHBotmIaCHiQgyAR4X7MGPFiAkjJtppREtC/CUTsiuOp8iBpzSdpBjHnkjSIfVQ71KJm11YkBnu8KCpImq6D+wCl3PDmPuYJImfIZx4uI8fs48dZJDLN/gFVmz8mm/RTxcCItdzC9VM5nA4cePEfUzPzvl8HhGR6KVhTj9/KcXGsk/Fv0WCIDA3y3PI+6emn8r6wHoao40s8i6i0pay+KicnMmtk1Ofr/jy5fjvugs0jYHKxaxuriUUTSLP8jDzi9XMy/LiC8S50VPIQOZp2HMj1DgdvDqUw7lfcFBQlUeaOZPB9hiv3bqdEq+JwQuLidlkjKLILv8AheEYoiBgsQgUpFtIhGQmeuuxxAP4elV8v3qEl5dlUFjqIRy34DClolbb9ilknJE6l+e/vpLu7X3YvGZyW/6CARURlfzeVWw2ldPTE0HxRQkONbD5nwewOIxoJivRniFyJmVh9Lrp3D5I784B0kpdnP/QyVjcZjb9ecdItPFAwxDn//0MimZkIIoC+ZMOFVMFUSDqi9O/p4/961t4sbSbGWU5nF9Tg7fYzas/3Ubrhn5ESWDW1ZVMWlpCRm02vb/dj5JQEGw2enYP8NYvN5CMyJQtKmbyZyaz5u5NNKwcJB5WiUdDPPaFt7joj8cTDci0ruuldG4O6cXv7be89Ylm+uqHKV+QS9nc95eMNbMqjSV3LxzzniKr+NsCSCYJV56DjEov1UvK31e/HxWZVWksumXuJzL2x8EnqlwKiIiI713xY0Q8OIt3ygCiMHZegpb6gnu/c/UlA3w78F3Mys8/3CR/dPBv/6kfrp9POerBf9SPBUlI/cIgIKT+FgSE/2fvrOPkqu7+/746buue3bgLCRE8uJTghTr1PnV5qPcpLfxoqVCltMUqUEqLuyUBkgAJcU82WXeZnR2/c+X8/rhhQ4oFK5V572tee2fuOeeeufeMfc73fL4Hrp+ExHxtPt+Pfv/t7G6RIkWKFClSpMhbzuc+9zmuvvpqbrjhBtRikEGRV0OS3l6R+c0iq69+/59Fw/ugdAl03+VGfte/761pN9fNSPMK2lrnuOJ1vpdNXXUcP3m/65/9IqEZwCd8TO/cAam7oeJEKF/q7lB8bh/ja93bC1jZQ+o7hQJGczNadTVqyUsj2JdwCsv4IE/zILU08RV+jIzMF7iKHaynlErU7nq+9cNHsBMf45Jlq4kEm9mZf4gTps9k/nQPmO8jV7iXnu5nAYW982ror4iz15cinihhY2cvNx8xkwlKLR2hLiw7S14y8Ak/Qgmxh80s5mR+ymVkcYO47uB6zuJ9nFT6IxZvjbPSt5FLZz1PPPw/5MijoGBjUUoVKCoFtcCDdRB1DH7c8AzGdKhPwbIumUjGg5YBy1Ngp8eDhuBpHmADT2N7dWzVg8eyKBOzGTdUR6v5LLLHIEiEZdnjgXVMDAX50dCRpKq/Q3RwM3LvgwDcXd7JveN97GIbdi5DxX5BtE9i96k2qZyNoylIsgWyG/xskMMgh4aOQFDohMwTfnzvASNhkElksUpM9kUEewIWhuIQkGz09lk4qSwSElaygsaSUxlXc9BGIUmCa/gqQ/QSJkaCYWRkhujleVYSJEIXLW4EODk2s+YVheYxRjZC99/BUwFNnwTVTz5VoHtLnJJxQWL1QcJE+TCXueVfY+W+SYE1PIqCyhJOGYu0frtwUikyv/kNzuAgvksuoS1Vw7o/NLM4ej7f/vqcQ2wUkv051v2pmfa1A8zp+Qu1PhPdr7L9wXb2VDbQlTPQHk7x1FEe9j63j6HVg6Rkg646hRpH0LJ9hDKvxmP3K5wys4qGI8p45KoVCCFID+aZ+FyW5pO9mI7D7vk+rN480RGHQIOfcTPLmbi0mr7fPo/VKpBMB1tXGbQV1AEvekM1heEkSixK1Slu1OruJ7rYs7wXJ5cj2Zsl5/MTkpMgQKkoZ7CpmlRXB7KmMdiZJTcsI0lQNS1K+YJGJp5UQ24gxf6n3QSoIpfFSBXwRb0Y6YPBk9l4nqd/uBYtoJPJKmy8vZWFH5xI5dToWJkTvjSDa4+5AzOdwfEKlB92ct2X+jH/2MWF3z6eTX/ZS3owD4qML6Yz57xGMgmTqjkHJ862/HUvZtYCXO/jBR+dRcWvTuCni+/HFhaSJLHzoU6umHAbjinwhjX8JV4+8fCZr5rcr/mpXtb9sRmA9nVDY+P2jWJbDo9/axUDO4cZao4TqQuh+TTSA1kWfXLuG263iMs7+u31NzxEmNf2fXm7uAWdz3Il5xxYptJS1cJUpvK1vmuZV30wnP78gfOJVka5iZteV/tL40vpsbsplw8vw+t/KjY2lrCwsSmIAgYGtrCxsXFwUFHxS/4x8ViTNHyS78Dcs4Iu6a5PmeSKyPKBPwkJRVLwSl50dPdRyX18mX/ZO/20ixQpUqRIkSJFXjdr165l+fLlPPbYY8yaNYtA4NAlvnfdddc71LMiRV4npcdC1S5IboWSJW508TtFYDxM/t+XPNxLB120MpW5hx35CbiR5Du+QSyfYKI3yb7EJCQJFjR0uvu9LxNtN/CEm8QRYHQLBCa6wp+ZcP/HjoSyY12xOTLH3R47XIGer30NY98+ZJ+Pmh/+EM/4g5HmjiiQEcu5mCP5mPR1JOlggJQHL0fgRsp949fNbN9fgZMaoPW2mXz88h1cH7yVbaT4H/4PTQ3jm1hO7MRq0tuyjKufgFJXz2BzN2ZBYWT5CRgdVQSX3Y2Bg6ZEQJIppelAxPRCVvMwOTIHkvsJBujiYW7jIunLfDvzLraPa2UkksSUepFwo7B9BNnB8zTo0xgyu+gqSfKjcgVDmJQaAgeJfq/NltIp7BjKkwkn2TBtAFt1BS3HHEF1YMSjoqgK1Xj40pT/RUNnhEHmsIRUrJ/dsc2Up1OUll9CSXAxO+J/I0gz3UGNlaVD7JMNnFyeyIBEaBjO/LVGdNI0VnTW4wRG0OY9i4QzliNTkmRkFIKEyI1KFM6Oo9SBklSQfTIevFgUyKoWIJEhzbjMJPIDElbDdiTTQ218EbzIwWAjq2hOdpPKOATC3XgCFsEDmskGVtHOXlrZRYECMjKreZQzeR9hoi8/Vm0D9lzl2sYAqCEKVZdy95fXkuzLoagy77pqAVXTXqE+rj1MwHdwTP2Bn7CFZwHooJn38flXrPtWkL3lFgqr3eSiqR/8gFXWx7AchUzcYN2fmjnla3PGyj783Y3sXdlDLlEgqAXRlSS1s0vIV3roczIkfSmEXoIybNL2ZD/lHh2GTZxGhZ75QWKJFMEGV/Ds3z1K46JydL+CkXHH2uSwnyMjlSzXsqRMi7YTbGbfMkTZfUM892yGQKmXktkn0NzRT8g3xO6q+dgjHmyvzZnXns3gviRV06PUzCwhEzd44BvryaRlsD1o+Sxr7OMp0UbQ6uuY84WTsYerSRS8RJ/dgzAKBGI6kixhmw6aV2HqqbUM7Rygb4P/wLB0WP6TbSS681RNDROs8pMZzOJYDt3r+xncN4pQPYQay3jsqi184E/Hu7Vshz0P7MdMusk4KYCacxNe2pZg1337sfMmRtYBHDrWDjDSmaZxUQVb727HMmxi9QEqp4WJ73adAHwxD6pXJRLUWfyxqay7eS/ZnmEU06ZQkHDQsUwH4Qj2reim9CNTX3kMxA/6hQshyCUKxOrf+Jga3D3M/pUdyLJEPmGg+TQidRqJtuRrV34ZjIyJkTIJV70J7+j/IN5RoVk78PdOoqKO9WFy02Sqqqp48vEnWThvIQCFQoFVT63i6quvft19lZCokCuoUF4++eBhIQThYXd5RbJUf+O+Zm8jQgjy5DGEQVqkyYv8WEIHBwcJCU1yr7Vf8hOSQ4SkECE5RJVcRY1aQ71ST1SO4pf8ROQI9Uo9ISn0L7Fcp0iRIkWKFClS5J9FNBrlggsueKe7UeQ/FacAHbe6yQRrzofAy/u7viVI0mEnsnsnaGUPP+fr2FjEKOcD6W+wb6SNGdGpjAu9jILRcy/0P+qes/r3Q2EExR7lqqVXs75/EZXlfiZPnwy++VB38UvrWy8WMASk98POb4Ex7PphVy+D8Z+ByV99SdVCayvGvn0ApHODdKy5m0njvzK2v9/5CRnHFf4MeR/lyv+87HM2DAcUL/nwJPpCCX42E9JyP2t4mEpqudj5CJijlJw1mZKzwF/SxEIaeGDDDvJdtVgDleRLhlCEhIVJ1PExQ1nMpXyJEDF0PPyErxAkRII4AgdNaNyf/T7pRzfRvu5ddGgT8ZR1IjQTEDgYhCmhhEocycarhxgliXDyCMlhyANJTWLTtJNY4r+UexPfIeVYqIqOLVnMGoaP7gVFwM9nWHREZBxsruNyaplAmlG6aGW5chcd0/YhI/N5glTyDH+o3c1RpsrGQC/xYDmG1IFQJEJxCdsDlg65qMzU5y4ktXE+XZ4PoE/dBqoNAmoKMSZ7jsHBJj5viOCoh6QWx1MlUaFXsYyv8hXejYSMwEHgUDK1jUFFxpIdwn6Vs6qn4TiCP92fprnDxNtUQ3OjG4kqD2lcVvsFsiUtNDKZv/FbZGRKqWKYPhqYDAia2cZ8jn3Za46w3Nf9C9hpRtrTJPty7l3LoXPj0MsKzaYpuPy3I2xtLjCpQePKz8Tw+2Ta2DNWpvVF228bxotExoKJogmsA7kbM94U/9v8v/Qavby74t0k+/wI25Vc9/qOIdDQQPWZFezqMHim/nckwnls72xO9H6K8qAXjwNTwn56KzwYi6LISYVQWkXVFZqWVCArMqf93zw23d5KIWPSsqoPsaqP8EQ/EztHmLE5SdYfJ142hNRSTaDPR2YgTXDh+ezoSeEMFQj4XY/hx67YQOPcIIn9Q3SsH0L1yMiKhKLJmI6MI6uMOGX0pyrxdOmMXt/KhVdU89tEBdkSL9MHOvA7FjWzYyz+6BQ0j8KKn25jYM8okaoIiX0D9G0epOXJLmKTq7AMm5O/PpfBvUme/sl6wqJAIWshedxJg0LWQgiBJEnsfmA/O+7ZjyVpSKaFrEI+rHH0Di8ltkbt/EoiFa3kUjaSJBGq9JHqz9GwoJx3/+YoRjozVE2LougynoBGZjDLtGUTx5IRnvatuXQ8uZ/OXhMTB4EPgYxjSxSyNuMWv7pmNuXkGppX9DLclqJpSQVVM2Jvakht+tMOkl0pHFug6DKaT0VSJCaf8fo/Ewf2jvLgdzZQyFpMWlrNiV+e9ab69p/Af916vHQ6zb4DH9IAra2tbN68mZKSEhoaGvjiF7/IVVddxaRJk5g0aRJXXXUVfr+f9773ve9Ifz1Zm1unPw7Aha2nYwTe2UsmhCArsmRFlpzIkcf1qfJKXrx4KZfLmaPPISJFCMthonKUWqWWErmEoBQkJseIyTEUSXlHn0eRIkWKFClSpMi/IjfffPM73YUi/8l0/Bl67nG3E5thwZ/+JQNZ/hnsZhM2bpRiV6abL6z9OqrlQVd0fr74/1EfrD1YONsFbTe427lO8I+H0qOh+058msWx0wZBDUHl6RCb//IHrDgVhtdAep9rm5Ftg8II5DogMQD5PkhuhxlXvqSqVl2NEgrRldrOMP1snmxyHJNYiruKMy92jpXNvWhbIGinmRBRSqngE5+o46c/bcOyyjnh8yFWyAY+AsSooJcO14qlehn03kdKMbi+egvdcgt6xEf22fGElBxTFy/H5yjUGkFG/DlSxIlQyiRmspHVSEiMYwo2u8iTZVzSImgUKFQ/xefHpfnKo5+CaXuwytuRkBAIcmQop5pGJnEff6LELmGEPlQBqgAZhSf8a1nO81hRCwmwKKAIBc2xGfZARR4mJmF/uMB2af0BYfcJJGQed/6OYxnoeRnNE+Rezx85MjOeTfpTrGmyUCUfZRLIyFi6wkgtTN0eYcN3K9FLyrnlPefRvtDL5vC3uZEPk7bT1OeDfL5jPNOnXMM2ZRst7GJzZA0jDGFi8D4+zxwWcyxnspblpEggo5CWR9GmdNEomohKXvbwPHvWVHLnctdbe2BtFfrMz6JM3IandT61p53A4hIvAKt5hG5aCRI+kEQxgIZO7SskBARADcC4D0PnLeCphNqLiToBAqVeMsN5JFmiZtbLJxPdsMtga7MrUjd3mKzelOfUo/wcyVKe4E6EAG3dMu7NZjh1iQ+f9+2xRfVdcglWSwvOwACBD36QEysXsvKa7ai6TMspG9iTdcXuG3tv5Evv/h650QLDLWlKx4ep+M5pfPOp37KrchdIowQUL+HqNq6aU06gtpFdj3Qzf1yQ97+rmtZsnunHzMRsyRKp8ROq8GGsXk14505OuegonnxAQewZBSD+SB/jq3T21rSz7vQ7cYRJaVstxz1zOpmaDHb3JIw9SRwHCnIeRYNkV4pks0RmpEB0ciV62EegzEdJY4BUbwbZlMnmXW8WSYKR9iS+wWFuvnwiiloBTCQ1mGPFj7fx4LfW4ziCvct7EULgCah4jAEcs4AwZeI7e9CiATb9rZWBPaMIWaVrfT++kAw2pPqyNB5VSbwtTWlTiPyogS+soHg9FBwFb0Sn1pCo2ikTWxJh4imNnJK3eeTKrQhkGhdXUjPbHTehCh+hioPJ/WZf/NLIZEWV8fol/FGN1HABbAlZBlmVqJlbRtX0V09o6w3pXPirJZiGjeZRSA/lee6mvdimw6JLJxGtDbxq/X9kpHWU8qmlZOM5yqeWcMaPT0DzqQTKXn9E8s6HOykcsAtpXtnLoksnEyj5F7a1+ifwXyc0r1+/nqVLl47d//KXXeP9D33oQ/zhD3/gq1/9Krlcjk9/+tOMjIywaNEiHnvsMUKh1zYn/3dHCIGFhSEMciKHhYUpTNw5J2fsi4BX8hKQAkxTpzFFm0KT2sQsbRbjlHGUyqXFKOQiRYoUKVKkSJEiRf4VMQYObpuJtz+Z4L8wk5nNw/wVBxtzVEOy3ECYgl1g7+j+Q4VmnH+o7cDkr0HlGdD8YzBH3eR94ZmvfEAtBLOvASFcFWngCfdxKwMoIOuQbobOv7rRzzXng6cMACUcpubqq3lgzcUMTYgwdGSUdawcE5qD0nGMivsBCMnHjx3yJn7EJlajoPJRvs7sqYu4/voZB/bOZCZe7o8/xoZblzKaXcLmcwzmTv041JzL86kf0i3fD/kIM89Kc3rFamZk8kxJl/MDu5zOoIItJRhhkN9zJf+PP7GTDXTSQif7kZAIGRbBgkN5XuIYo5/4rEepmZIi1nsh3eW3MkQfIMiTZZj+A6JzFklyCJkaYRMClmBv2EbBwSSPSYFSKpGQMDGIe3M8Xit4/z6YnoDH6t3HxQtGAoaOVJCRfOD4HZx8Gk22ebZwOwlfFkcCGZNu3N+/QnLIVwdwquczSByVFHdKN/DeiZ9lC72UFmJYwiCpmtxR3ccVcogTOYc5LKGdvQgEBnmu5//RxDROtM5hZ3YjeW8OXddpZw8evHRJLZgUaGIq27IHx1csJBMYWEihZyHjqlVmTzpomPxZrmA1DxMiSg3jaGY7U5lLlFKe4XEilDCDl5noqD3PvR3AA5x3zSI61g9S2hSiYtLL28aURFw/4BfSKJVG3dfIuVzKHJZw170qT64IsJoUa7cZXPX5VxELhQBhvyGvdqWqiugvfzl2P/VgB/mkK4BvebSf3kkpnLiJz+dh7rLxLDx9OqrHjaz95M5PssfYT/mzNQRDEdJnjFAXLqPOW0pgboDyvuex+/spjJxEWvHSYRaok236tvQj+/vJX301APlHHiF22rfH+uAL6wSDXrbN6EAoDrKA/iP28cCJN+KNeGm4fiETts9C86hYNsTbUmiSwfD+PAiHVKtC6Zw6jv/CDIyUxWhvhs03b2WwNUvBVjBHM8jJPA99eQV9m3o57QfHIcsSW793Jx13dJJxggymg1imAAS1dbsx4w45J4Ks2DhCJbWvjw3reyhYCr6QjOZXUQM6qf4c8YFB+naPsufxHj5+78lMfdcEOp/rpW7EIpWUkWUJn8ciUKYz3DxCsifN9GUTmXLmeLJxg0CZF1l+qe6TS+TJjeSJNUZeogvNvngqHc/04PFJeIJeLKHhDeuc9YOFhz0WNI87Bp/+1U46N7oWHemBHBf8YslhtwEwfmkDex9uRQ9ozH3fdKL1b9zSN/IikdsX0fEE/+tk1pfwX3cGTjjhhFdNOCdJEpdffjmXX375P69T/ySEENjYmJgYwsAQBgVRoEBhzENLQ0OXdPySn5jkRh/XKrXE5BglSgm1Si0VcgUztZkE5Nc3a1SkSJEiRYoUKVLk1WlqanrVSfuWlpZ/Ym+K/FsjBAjTFTBfoOZ8GN0KVtq1d/gvFZkBJjCdy7iGLlqoLGnk2/qPSBXSBLUAs0qmHVrY3+AmEex/xPV7rn6XKxZH58ARN0JhyI0WPRwR7YXXd8XJrtDf+wCkdoGsgeyBzlvd/YnNMO83Y9X0+nrkS05liA0ANDJ5bF+58gmC0lFIkoZXmgJAnhybcH1tbSzWsYLZLAIgS4brCleww9hKatWZlDafQRqNH/0hwV9+WAn5Xqa3beHhxgw5c5T5HMWHzSSarqGicUkiyp/VDZzeY6LqMlvr02yQn2Yl9zHCIKYwUNGozmuc3O/j2J4ccS1PqQWXhlbzg9nPYSVrSfWejrfhGWRfmv3soAv3/c2QTWqdUt492MjGaJKElCVFkjxugsQhepmeLkGxVUZl6PHDsxXwUD3oeChQAASOoSIpJo4GZkcj3nFtmB6HDlrpCQ4jDlwKgZvg7oU7pjDJySkcHMLEeJ6V1DOBNvbQr+XICIEtZBxtCgajdDj3kSDPZdLP2CY9x238GpMCD3Mb9/XdRlKMoLR7qCgbR6fqIdd6Dlq4m5lTHKZIs6k92uG5bQb7OkxOOdbPxy8I0j/kUFOhomsHPw9CRDiDS8buj8cdpz/iy3TgJkp7N5/iOM56zWEYKPEw7dS6Vy0zeZzOl94f4bmteeZM9rgJIw/QxBQG2oYB1+Zjd1vhFVoBkjspbL6Kx26so394FpPOmMdxn5k+trs5meWm/T14FZkPTyzj9sHf0ZHv4Oyyszm19NSXNNex3hUYOzJ5pNunIh3bjhZLcVT7CbSKYY54t+tfLoSgP9fP1BWzsZMOEhXU1C7i/ReeT1ANkrvrLrI334wjBFtvvoXVZ5zLjqpJTF+dZ2a/TaPYznQJwEKYeUJaivKJYULVPuac18j6W/YzXZvGvootGMkCRiiNostImkr/6c2Mf3IGdsbB45PRQxrZnjSKsAEJM1vAH4RJS2sYbkmy6tuPIg8PUaIoDOSjKKKAEA6Z/iztz/SQGcwS0AycZ1eRyU9iNCdj2zbCdsdHelTnuLNX8+RfjgEhgc+LnBjCzgdx8GAm86CDkSpg22A5IDk28fYUG/6ynzO+ewTn/OYUbMvBzFnsfaSVzX/aAYAe0vFF3WuvqPJY9HJmKEvr011EaoPUL6qhf8cQT3x3DbZh07CkhuO/seiQ7zNtT3dRv6iaof1JbEmm7qg6zrpi/utO6tf63AB7nujGzNuEq33kRs3XrvQPLP70PJqOr0fzqZSMj77u+i9mzvmNKKrEaG+OGWfWoerF1fv/dULzfypCCBwc8iJPnjyWsLCwsIRFgQKWsJAlGQ3NTaCHF7/sp0luolappU6tY5wyjkqlklK5lAnqBHTpNdLNFilSpEiRIkWKFHlL+eIXv3jIfdM02bRpE4888giXXXbZO9OpIv9+ZFpg5/+BmYT690L9AXEqNMW1y3AK7pL6/3LqGU8948ELv1ryQ/aM7mNyZAJl3tKXKXzJwfP4YhQP+Gpf+vjhUHWme8t1u9ek7UYYHXH35XsPRj8f4KN8nTU8io6HJZxySFM++dBoag9eKqhlgG4A6pgwtu8O6wZuK/weW7IoTGuj5OkjiZrjcF6IxzKTVBV8fLtlJr16jobaT+CLrHGTGAJL1POYuzNFh5nGdAZZlCgjGLyfZH0LhpYGwMZkX0iiVptNhWhjWOmloDqokoWR89D11OcAKAn2oJZ0o3gF6b0G+ZIsSlTQ77P5Y1McrxPAF68m698P3mGQJKJ5h3P3DvFkrYIug+LA7RNVkGQiRMmTxbKSmI6MLQtkxUZSHIQl45N95DSTrDgYRewmnFewhbv83XQcUkMh6isOjgMLk1Z2k5JGsSUbCZW5nMi3nJPZI3VSLlROc/7OPOVy+ugkT5YCBklvCkezsCIGXX1xBnf9kIItYVPPVrWFoYl9ZPwpJnz5L0wWKr1SB1+ll2Nqz+BiXt5r+8XkyY2JzADbeZ4SKqiinjJeJinl62TpkT6WHul72X0nLPCxs8Uc235FOm9l9zN+uveHgHZ2PVLO5BNrxnyhf7Szjb68K1Rv234/hudpAH7d9WvmheZRrpcf0lzdEWV0rB9ipGAhaqLMWXMeHllmYuxQwVKSJC4ov5Bn1G3kAw4+6onnm6hUXSHaamsDwEwkqN65ixNzOWZ6IjxxxMeYCbRl6snlBlHMXYQmZVh7xw48ykTi7WkWfmASM75Sxn1tu2GvSdWaMA2dE9nwnvUYhoka8FI+KUahu0Dp+DC9u1IUhBfPgdURtunQuKSSrrXd3P+5lXTvM4n4PRQsBcwCNqqbeNIR5FMWvpgXDIcpdYPs6qsma+oYQsJx8/Ux0FXNcyuO5vT/2URfxxTyvgV0/nUNSSmAlyxl8hDUT2B00KGQBUzXokPVFWRFImdbXLtvCz25DOfVTuCYCyfjDekM7RshWBcll7TQAwf1IcuwePiyp8gOuV7fR395AX1bB7ENt0Mdz/aQi+fxlx4cF4WsRbIvx0hXFtmjk+jK0Llx+HUJzcm+LE/8cAuyKpHsy6LqMif97yt7IndvjbP+ln34Yh6O/fQ0fJGDz6FyRtlhH/fVkGWJ2ec2viVt/adQFJr/jcg5ObKOhIlJTuTIiRwOziFJ9zySB5/kIyAHCEkhSuQSGpQGqtVq/JKfCeoENDQa1Aaq5KqizUWRIkWKFClSpMi/EF/4whde9vFrr72W9evX/5N7U+Tflq6/u3YO4EbI1pwLiuvz6kbOvrMJ2f8VKfWWcJT38Jdwv6W8IFRXL4PUTnBMqD3/Jf7ZHrycyDkv24SJyYPcyjD9LGUZ45nGF7iKZ3iMCKUs4eSxsqvsRzA1NzpYre3EVzJChTmeT1xwwC6yZBFE5xFJbCISOJKh0pncUPYUuZyHc62LmOI/HV/r9UxJqwgjg5TYhRXzcYGR4afTCujIqMiEJR83TLbYUbmAs1vTDNvreSAYJ9gcgawfVIX07vOITl+Jpu1n9HtezM+lsDwy1hyH5iEfiZ1nEKpbjbxzMvrR7SA5qAIq83DxflfUeqxOwpIsQoUgsdYs2YBFraeMzaEENoCQkWQbbAdbhyGnB144tRL4CBAiRr/Vj5BMpIKf4R4/H6+4kGd5jBAxlnMPO1iPg42CgorGgOhkp9SNg6BHMtkidtDBzWjoGOYgPgmyXhmjAFY3mJKPvC2wKCAhMZSV+Cu/oZtWUiTol7oxMahjPKt4iGM4g1oaD7nOGVKs4B40dE7kXLz4mMxs9rIVG5sdrGcnG9DQ+RJX08DEl9R/mgfxEeBYzkThjUdfnnGMn6lNGpmcYMaEV35PEWqUlozNoBOgXHWFac138Lg5+6Don3cKY5dGILCFfUhbKdNiypl1lDQESGztZHWVg39tkprtBk1zKpm1rOGQ8h9oeD+Fj65h/c17ccJeuk8oZ1sizTEVUbynnkrhmWdQ4nEsjxe7UCBmjzKra5D2aCX7h/2ElHnUeqsoi6WxUiPoFLBNne0PdHDvHSsw8lX4j6hkoHEfR918Ov64h+y4FFM7jmDB+dNoWd0PEkTrHPJJE9v2IDkWeizErif66LnpQUQ/BASkcyHKIxlCYZ2u/iC2oxMJ5ag/brwbJauHiHz9Mk7/8wM8vEZn7z4FTPf8OI5Cf3cNycARvOvPp4LiZfnIXlbfl8FBJVDpxzcpSqRekBoxwRcg3pZB8yqUTgjz985mnhp0J6Wu2buJOdEymk6oZ9M9PSQeHeL5P7fyrqvmUzklihCC9bc007G2H19UxxfVGdw9TKzxoP2Er8SLHjo0cHHhp+Zw68UPAxKO4iXRncUbfn2fRZlhA8cSeEM6voCMZGTY+uetVM+IEix3/ZXNvMVj/28z7c/2khwwiI0Lj425pV98FXujIm8ZRaH5bcAWNgXhzsi94HP8gkeUjY0tbGzcMhYHI4+tA8kopANvrRYWPuvgm26cOAWhoaJSJpcxQZ1Ak9pElVJFRI4QkkJUKBU0Ko1FW4siRYoUKVKkSJH/IM444wy+8Y1vFJMFFjk89BdF5KqhorD8YhwLHONfM6K7ZCHM/yOk9rgTA/8Q0fxqPMgtXM8PyJLmUf7Gn1lDhBJmciTreYr1PM2RuP7N47XJbDaew8RAN/389nNTGR8uh+FnYdud4KmCyV93o7UlhTu5kr3sAD/cyD2cktjBJKmFeiuBIgDhMGDtJmKYOICDIFTQyUsOvXoHj0TjxOZ9lr7+cQykbkMq7yPWsxFjcD6yVk/YZ6HFvUw5P0t7yIMRsimky0i1LSYbbyQ3WkPNyV/DMRwkDwz44OF6OL7Xtc1YWS2hIKPGc4xEVTIhC2FYTMk69DoaVkHHyPaTT/hRZ0hkMQ6eOAGWZNHABJR9ixgWg4BE0KtyBpcwh8V8mrPopR0Le+x3vRc/UakCSeiAG9U5KvmQiVOah1A2i6eQJWTC8lgAuV4mFMmTzq1ltHMBineEmvGbyFoTSDgpFB0UVHK4SQFlFHy4Y3SUOAARSriBH9DMNgD66eZDfJn/4XIe5w52spEdPE+AECYFHucOBunFT4j38XlKqeA6vkcbbvK8Yfq5gI+9iQELTbWv/d7ys2c/yIruFhJhwckVDhddMo7SxoM5sD4zuY5f7+1yrTMmvJdfdfUy6nTz0boLqfK4UdlpK81Vex7m2X6NCm0C353dxGWz51DftYFbSq9n17ICx9d9Cs17qMQ1vH+ExooK7vmGDzQZXZZoWv8cqW1b0ObNI3bjjQyeeiqlbW0EsxmkqVNZ9L1z+MSeduJP3Erb9GeIpgN8LDkbz0iIZLOJqjs8d+Me8MlQkKjeOJXsSZ1IQlC/oRHfbolIpczSL8/EKjh0bxpi0nHlRGu8dG+JM15so97XR6q/ETuTQDiVRKIWDZE4Z/3fbO6700Nu5W4sWyI2p5GjPnXQZsSzZAm1Ry5CunA5oWSceJu7gkBWHbwlEmXzpo5NKhqzjqMy1Y2wTAgEmHxGOcMto4RGYaSvQLhaECjxsPlvreRnlmIJi5bcfvKOwePDKseMLibR7Y5Hq2DT8fwQlVOi7Hmih813d5AathhqSeGLeZh76RymLZuI6lEZ7U4x5YzxOKbNmus2kx3OMevdU2g6to664yYy0pEmEzeon1/KpBOqD3us7X2slSd/uJ54r4kW8OEYJpEmH5mBLPuXtzPnEtdKZvMdrTz/h93YBZtMwkZWZCJ1Qcyc/RpHKPJW8Y4Kzd9NfBeP88q+YC+8ib8Wh1vOwRkTfR3h8MKfQIz9f/E+cIXhFx6zX/g7IBSbwnQTBhyo74iDbTk4ROQII9YIXXaXKx5LoLz4T1IIEaJcKadCqSAshYnJMfySH13S8UpegqoEfACAP5b8ET0YIyyFicpRZOntyepapEiRIkWKFClS5F+LO+64g5KSV8/KXqTIGA3vBxwoDEPthSD9F3tGFkbcJIiBCZBtcy1FrJR7XsZ96J3u3UuJPwv7fw0IqDgJJn7xJUUy69aRXrkSz5QpRM89F4DNPEsaN4q9ny52sZHxTOfnfAPjgBCqoHAEx3Ch/HEGPN0Mm8O82/cpxnsa3aSEzT92o6lTe9zJisYPA67H8wv0GZuJ7nyAtJlnRBaEwzPRc/0k5TwP1AtAxbFMhnptTNskWpnBCObppo3OcDeeQYGjOVQt/C3Hb6+meZafVNTkwn0Wqxf3MN5QSPrLSPWeQb57LlDAMXUQGkZ7E2ppP1p5lofq4dF6lSkJuLTZIeHV2ThgsWeugVAgLVQkWeX0HsFOKc2ApmE2RRiS+g5ahByggMEgfZw+6WgezDSjWgGOD43nQubQb/eSJolAoMoyHslLI1MIE+MoTiVOP09yFw4FPPJEBuhBN9tRRJqjhmBSUuaZWoUGeRoONuLIu/DOfg6hpSjPLOKZa84lFW7Ff9ZtzKyfwgSmkyPL0ZxGCeU8w+Pcxq8AuJBP0EvHWL97aQdggG4e5W8Y5OhkP+OYjJ8Az/MUKiqmKfj0+l8RefzzpD+7lxc+SjrZ/yYG6uEhhOCpzQIp2ERsMpiTdGaceehn2ZLyKEvK3UjZc6/fzdDK06gMJ/BcthgqwXRMPrHqs6zevR2QIPgJ7ooGOKGyhPuH/wrSKHkhcV3XdZxUctJYu33bB3n826sRlsP7xXYqjgnRMG8m3uuupQAUVq9GCoVwurqQ/H68to0WjVA+swo5sYe9x61FSgpSsSQDS0aZdNOZ9PTFyQ4ZSJKE7PNQMrsUEbI4u/mTlJcn8I4OYpsaDePLUXWFWXNt2n+/lv0Pm4SqfCyKdDOt5RYYhkJpPevVM0gaXirDSU7/yVIGA5NID6yh+ugmZMW1d6ieHjvkfG34y37anh1ACIEvoiJrebTyfoSlsfaBGxluPo7eZ21SSYl8XsIbDhCrC7LkM0fw2FWb6d47wGhXlvRgnnCVD9tyODPYwP3JZ0g7cSZuK7DixyuJB/Pkkypm3ibVlyNc5WPm2Q2kBnJIkoSBF/wqwaYY3duTzDpf0PFsNz0bB4jvSxCsDrD977txbMHg7jgX/+VdnPKNOaz7YzPeiM7xn5/xulbY33fZOkb7DCQJqiapqPVBhOW+mEPVB+038qMGdsEBJDx+GWHbxOoDHPmBia/QcpG3mndUaF5uLEfJv/qXnsMVkQ+XFwTkfwY9+R6arCbGOePGopQ1NFShuv9R8XCo0D5y4O8FFMOi4TzXc+ae7tuwPYd3yfJOnj3ZPa+4X0LiuqnXUe+tf71Pq0iRIkWKFClSpMjbxLx58w754SWEoK+vj8HBQX7zm9+8Ss0iRV6E4oWmTxxe2ULc9XQOTgIt8vb2659Nej/s+AbYOQhNc8VTK+Xu677DFZv/1SKbB1fCC7+BB598idBs9vbSf9VVCNsmvXo1SixG6IgqTjMqWRtTySoWZVRRQgVxBsZEZoBu2jiCY5jETK6R/47tsVEPSAJtYhclzhAhIu4vVyc/Vu98PsoocXJkmDccx6QFU5cJFCyENEp53btpnj6Vbdp3cUSWhrjEmf0OT9Q65OMFKi2VefFtROvmsHH8kygWlBsqu+cNEO8IMfAnifqqBIV6kAUE9RRW/bNEOiYwmvESHX8/fn2UoOKhq68arfyAQCoEMUMwNQFhW2CUOeySQSiQ8Vo02ZOZbXnZV9mB4c+S0kZwEGO2GbYRpDDSiC/aj+yTaVW3Ux+JsZct3M46HBzsvA+8jhv5bEkcrZ3IKAnSjPI7vs9kaQ5TORKTAilG6aeLszO1zO4YRXPgxsk2KTlLhhSD9JInS86TYSYL2TPcR/y0Kwg//THEj6/nq1dWEAsf1EeEENzZ+wT5oBdPOMcT3MUJnM0D3IKExHG8C4Ae2rCxUNEYz1TmczwncR7X8T0McnQP2oyOGGSHbNJPHE34glVoisxRvDTR3luNJElMa9LYsd+1zJja9MoR0Jv2Gey7rYfgaIZuNPZc+Vf4w2UMFAbY1bEXWYAjBLnmjbRPOpqrd7axzzEx1SzTIgECyqGv5b4tgwhbUNH7DFVdT1GRLUVf9QRClsc+Z52BAeTaOsy2DhRdx7PQtc9ZVlvKI1kHEbYJ5xSSz42n4/k0mUHXukFSXG1nUskU5l58Og0LyrljcA2p5xUQDuu6p3BMqsD6n64km7TJWzrZbpgT3ojqUdC8CrmsgWdaGdHKKvJKPbu6y9l2z1ZG+iySAwXqp/sJ1waxHIcn+0eQJIljomG6t8bRgyrJbtf+JlRioQQKIBXo36xhDT3L0Jp60mmVYHUITzDMmVccAYB9QJgNVnox0iYIQePCMmrLQpwz5CG2bYiye8uQOmLsGY6DJCFJMlXToiT7cmy4bT9zLmhkz+M9OLYAWcXI2qhemc61PfRsHACgf/sQHc/1MNScACAXzyNsh7q5pdTNfRkP/NfAzFtkR90JL8sUpOI2F117NC0rOyidFEPRZB7+6pOEa4LMee90tvxtH0P7U1SM93PxTSdSMe2Vj2lbDh3P9uAJadTMrRx7XAiBVXDQPP/FE7VvkHdUaL42di3B8OvLMPnvxEd3fpSdqZ30qX1vqp07Xsj7krz/ZfebwiRjZ3CEgyRJeGUvXtlLQAkQkAPoso4iKcjIyJKMdOBPlYrOKUWKFClSpEiRIv9KnHPOOYcIzbIsU15ezgknnMDUqVPfwZ4V+Y8k3wdbv+yKr3oJzP4F6NGD+80kmAnw1R+2hcO/FENPuyIzQGoXlB17cJ8WBvmVV9ceLknncVLOU3ilqZTI73tzOXCEDelmGHnetTypfqkfsxWPI+yDS8DFwNMY21Yzizy/CEzhrtkzWSydQgMTsbAYz3Ra2Imf0Jh1BriBRy+IzE9yP3dov2f2uCwndycZ7zkBai8aK1tFPd/glwC0BO6gR/ogKcVE90JKjiOn13B270Lkhp9xk/Njztu3g8YRiVzGx8AEi4mjtRzdD0njb2SnOXgLMmldoiD5SGckpAkFdj0rWFwnsXaKRU6CsgCMP/UBopkU3YO7mflEFWVWgV/EhjHToARAEjaWBN0+mNRhopfbCEUGycERsFT/IGeWL6WfaxlQnyUt9QASCIFtBOl97Ls4RgmlPi/hE+6hw+6nxWjHCeeQVRlHNcGbAUdBFHSymxaz95itDDNAkDA9tNLCbqSCxqDSg45OUAnSVtXAoNdiWBpgSziFhEQLu3jBJFNGZgNPY4VjGNkqWPJnqnqPJeA7dMXyNX8e5fH17yKjDXHkJx9hyuQKTudi5nMcCiollCMQ7GQjLexGQ2cmC7iETxOhhA/wJe7keuJpD/ZzbiLLyDMf4svLLiCmBCjn8G0LDhmDWEhIh+3v/H+fiLF8XY6gX+aEBd5XbjcP4YIxFhpYMpQEoEKvoNKswlS7yVoOEwrTiOkaffkC46QL6bBgTjDEh6oPrlAQQlBzRCXb79iDbAxS8CvIBwRDdeJE7P37USZNwj7iGHaET6eEB1DKKukZ/24Gr9jE5kUtVJRWMDTYjpSbgueeScTbMjimK9QKS+Av0RlqTbL25r3suL+TSLWfLrUeSYKSoMZgc5LRnhzpnE7KDiJLsM45mQsjPWBksUur6GE8A515bMug9X/XIUkS4WofWkBj1sVTmHXRFH65p5Mn9w9RckM3j48KmoI+ZFkgbAdJhnS/it+rowUKOA6MtqhkhvIIS5BsK5BLFFj50+2cdeV8Fn94EpnBPEba5JSvz2bXHTvpf76dWy/pxLarqEnOwWm3UDIBbFMgHIEQDom2ETz5IQprewl8oIFItQfVMcimHIZyJmt+u4eO5/qQ89aYfYkv5kH1KGSHchhJg1svuJdLbjsbzz94N78YIQS5kTyesAdFPfh60Lwq40+oZfcjXZgFm1xaMNSe4+gvLiCfNLjjQw9hGTaDu+L4y3x8euU5JNpG8ZV48UVfecwBPHnVc3Q/72p28z8ykxnnTWa4LcWD39lALlFg3rubWPiBSa/aRpFDeUeVxjn6HMJ6+LUL/psSsAI0ehup0CvekvYsxyLv5MnYGfIiT8Ep4AgHj+yhVCulUq9kYXghVXoVDd4GJvonMs47DuW/ealckSJFihQpUqTIvxGXX375O92FIv9NJDYfjPAtxCG1A0qPdu+ndsPO74Cdh5IlMOUb/35ic3DCwW01BI0fA08FGINQcz7Ib+7nsJF/ngHnSlCD5KQt6FItIWnpYVYehJbroJCA0kVQehzkOt3z7W8CYUHZ8S+p5p02jcDChWTWrUOrrSU3dYiO1FYEDv5MkP8t/AX1gK+tisp7+CyjxGlgAn5ePshrM88AsLW2mh21KpdyEQ/zPWKU836+QIiDke7jIxfizI3yiPF1PrVuO2Ezjy3twC7dx5Ej86jYN8K4EdAMhzlmmMAuHx2ZGpIhg2RJGh0vOV2QAxoS48nTg1Zm8bPNKj+aZ3GBBr+ZYdHNJo7hDL6evpQ7C//H5lltPPOcRWqdg+IDdSYoOliANgDOHhu9EmYkHJI6DNo1zIgugJJFnEolW/gygwwikUMgkescT2pVGHIC/xQvnVPKGah6GEIWkuQgskGkcAEkCcfSsAdqiYzrZYRBLAok7VFs2cR0HDLkwJIQ6SBl4TBoMCP6MUqpYh9fxsEijSuaOtjkyAICOTaAFkjgH/Ry5Wdi6NrB11cq4/Dk+jx1NDFoevE8cyEfmbwYIQRipAJ/QAIP7GITz7OSWppIMMRCTiSCa00xlyXMZQmJKpufVo7Sr9pccnqQyd6q1x6fQ6sg3wvlJ4KnbOzh53mKW/g5Ciof4avM5MjXbMrvkzn7+ACWJWjrsSiPKQT9L7UBnT/dw2lHhlj9bIEZWjcXXOROrqqSyg21n+b6J55iE+NIHzeXrqwbca9JIT5Y8SW+PqFxrJ3dD+xn/U3b8EY8TP7sHG7ekuHMu7vJpHOUnzqb373bImpM4tNTLmPogSHswSGQJApd/ez81bXsn7mAx2b/jbQvjlyiohkgdYMnpGIZNgiBhEOubxQjHSA9kKdyquCEL84g0Z1FCIjVBQiWeclPmIc6uBctB96qKNqUJtqa6sklTCZfOIvYz3eQjYVJdOeQCgVUCsxrv5UpU0xqExey56EWqv98K+8aDbIptZSBrIyzIYGZMXCcA+PFlLFHfageB90Xhn4/kp1BQgYzj5XT6dke59nfbiexb4jKphDRhhK613QQ359A0RQSXTkc3cuUqslk7CzZ4RzD7e5z0b0SkXwXZckRpvS2kP5JG60rpmEZNsIBK1sgJ0tYZpTyCeVEq3Rq5lXgWA6p3gzJvjSqrtL1fB+rf76ek75z1MuOE8d2WHHFs/Rs6CdQ4ef0q48jUOYf23/BL47iujMeBSHwl3rYcGszheEkZVNL6N8+RD5ZQA9qTEo0IssSJeOjrzk2hRB0rz8YGNq9vp8Z501my11t5BJu3rVNf2tlzvmNeALFXAeHSzGk9V8c0y6QSPaQttLYfg9+NYBH8lCqlHJE6AgWRRZRpVcx2T+ZSr3yzc2gFylSpEiRIkWKFHlHURSF3t5eKioODVQYHh6moqIC2y4msynyFhKaDJLqipqKF/zjD+4beNwVPcH1DS4Mgaf8nennG6XsOECGbLu7rZfAuEvfmraTO3FavgE1u137jdB07ANi4mHRcp2bfC+1A3rugNiR0PhxV8x/QdjzvvR8S7JM7DuXkUnvpDQwiQ3936RqpEBBUegMOgT1Ai8s/r6bm1jO3SiofJSvM5tFL9uVicxkH9sBaGIqf+An2Fj00MZD/IWL+Z9Dy/tOZqE4D5RmMPNun2U/TvNPqEwl8CEh6wJVcbj6wTJWrN2GZQuO/ojGN5KDtAfhL5M9DIQ7sYIW6poIp0wPUV3Rh7BsLt0Hf55kM8U/h59XPMGjpS04jkW2TiK0SyGzxUFSBeMbJXKO4HEBW6oU2qtter0SZYZMzJdkBXczmdn00sE05tHCLjR0UlYCaXA35afcRv89FzLcO0KbWE3AnwXJAUtDNyOE8ZGSE9i6Q21FhHighRw2jhA4jg2OQo48KCYUvDhanlB6Dj+L3YmGG7W5jbWs5iEilOHDTz9dBAjRRyeSJKF5YEZdjBSb2I3OVOYC4PdKlMdkBkdUqqjnrOpp+EWAy+5bwTORv+K3SvjVrMuQK2UcHFrYQZIEv+RbxCjnOM4EIMUohC2u+MzrsCvoewRarnW3+x+Beb8bSyh6DzdjY2Fj8QC3HJbQDGCagm/9Os6uVpNwQOaHXyihvupQOUpRJC7/+bGYra1IzizUCe5EUfpnP8O3ciWnJ7OYp5WxLaKSsmx+OHciw+0p0n/v5bH7Rjnq41PwRXWev34rwhFkh3Ksf6yFrjNm8ufJl+NLp+ifeBPk3FUON/beyAdqPowR3+kex5ciE7qbO4/ZTNzuI9RbjhT2UD/iUFLmR9Yk8iMGsmOjKDaqYyNsDw4qwhFMPqmGunmlDO5Lkhk2aH66l2wKkmoltm5TXh/FXxpgc2st6Y4421as4sTo49T0y6zMnoVAY5K0mTKpn9Lx49jz178zksvjUTRCSZuc4WFb+kgKGRMcGzdlpI0qTHwJEMkIcz91BEbaYP1N23FMkAQ4tiDdl2PXPXvw+BRaVnag6DKeEg8Plw6TnuJhqkdnwpB7jSunl2BZFsmhLvLJAlYByktHmBJtoTCcotDSRuW0JfRuGwShIkkgLJvOjcNkhoOcd80iJhzjTma0Pz9I64YkBVMB0+YlBukvYqh5hJ4N/QBkBrLse+Jggj8AX0Rn6im1dG4cIjeSJ9ORYUc2SSFrovk197wICFUdvh2SJEnUzq+ke7173Jr57runP3ZwtYsnoKLqxeDN10NRaP4XxHRMBs1B0lYab85my8muB9UDrX9lRuVCKvQK/LK/KCoXKVKkSJEiRYr8hyHEy/8IMwwDXX/l5aZFirwhAuNh1o8guRMic8D3oqX0voaD21oU1H/TlahlxwDHvPXtDj+DN+sllCojFRrGa9cSUk8+/Pp2DuwsOIYr9jsFsJLQ9ClX2I/MhpLFL6mWJcM1XEZfsJOQpfPRngEcwJElVk9dzBLJnaQSCFZwr3soLJ7igVcUms/ivdQwjixpZrOYb+FaEDjYrOBe7uYmgkR4H59nKcsAOFn7MAPBvzHszVAu1aKEZxAcXc2grCAkiYzmQUrIPLm2mW370+i6l9lrk0RnqURNQUefYFWtzZRpU2hNCnIrz2f7mnuZdvQ66jMOFaafIBFWmX8jo1lIMlgRgScp43s4xhcHg/Rc3MWukMNAWGHLIhu/BJYk4cgOXivD3dzMndyAjwAONgUM9wnnFORMHq/0HH4zi7O3gObvB0cCBSTFYVZoEn3sI49GrVJLJOAjgwcbE9OxXUEaGQcbuRBASpeiojBNmY+ZU9F87qG+zs95kIUM0cvRnM4v+CYCBwsTCZlK6nCw+R1XAHAm7+VM3sOg0sW3vuDj6ad9VJQonHmsj/Z+g1XjfoZQCyRp59d9N3Jt5ddYwHFsZBUKChYmf+SnHMeZrOdp/sQ1ONicy4c5mfMPb2ym9x7cNgZd+5wDk0wRShhlGIAwsZep/PK0dJvsanV9mpMZh6c35HjfWaGXLas1NR1yv7BqlXtsXWXC9s1sO+p4poUDzIgG+ds3tzDSmQHAMmzO+O48tIBGIVWg4Di0ORb7Ullq/X5ikQgjpsn+RApFgorCIA1HVuCcvgj7uWdIhIbpaQpiGzbKqEZQV8iOZmnaO4FIrZ8Jx1URC5v0PNdFyJPHq5vY42swJZ0zLj8CT0DDE9DY91QfG29vITOcZ7QnS/WMKMKBoz4xhfxogSeu3oY5mgMjzD6zinplH5W+IUYpJSA5VAayZAwPQwWBLMv4VAWtVKEqKdHeWUASJjImBXyAhE/JUeZLUVeSoLFpJr75c9hyZyvmUA5b0vBGfVROjyJG4iT68gy25fCXeogfodA8QUILwPPL4L2TZxGMy4xbWMYfLl4JgKIpCCHYOjKN7niE6YHtxOqms+hrs9nzaAfCyaNHfZg58IY1/CUe1v6hmWhdgL3Le2hZN4oa9GEkC+TzCt7oK9sV+Uu8yKqE80KCv5cRjE/5xmx2P95Dx7NdDG11xxNC4CvxEm1wP6NiTa8v18AJ31x8wKNZp2aeKzTPf+8EV6AfzDPn/HEo2ksj8Iu8MkWh+R3GFjZZO4spTLJ2loSVwCN7KNPKOLr0aE7UFwHvB+Bd5e8C379YsooiRYoUKVKkSJEib5pf/tL1P5UkiRtuuIFg8OASd9u2efrpp4sezUXeHoKT3Ns/Ur0MZN1dPl9xKihv3s/43w4rDe1/cP/Xvwf84w7uC01F6pWo7B9Pxch8pHk/B8l3+G03fgRyXZBrB28dSDKEZ0J4OkRmwSvYH7awkz46AUiZ7XT5ZI7IT8cQOT6b+zgej+tHKiFRSe1Y2WoaXra9F8rO42ie5XGe5D7O5D2s5hEyJOmlY6yNP4lrmDjYT31Gwl91Bo3TboOBx9xJicozCPrqEK0/xfDuI+ifgarsJODbjxBgC5PSsI3tCMAhL9nkgT46aX/odLZvrmD9pg9wfOskmr55N1O1kzi1Pccz4RHOTEJ7CPaXBegUS0mNm8vPZ23njJIwXaEOhisDSJ4BZFuhumBSlZFoi1gYuMnDTApjz1VBxS8LZL+EbeYx921kJHAiTiYH0iCSBJLssENZg44XFY1+uhikB/VAlDLygZUlwkG2fJR6wkREFcm4ztN3zGNn7yBXfLqESeM0nmM5D3MbAM1s5xzxYW5zrmWiMou5HEUpFazhkTERfBtrGWGIZ3kMrUTn4+d+i+m4idwiIQl5yOGFdS3BkLt1CZ/lPv7EAD2kGaWLFvroYjl380Lpx7jj8IXmsuNh6ElwTHcCSj9onfERvsb9/AkVjWV88PDaA8pjCl5dIl9wRcRxNYdnQ2BbDnGtHqltO2WVPpYcu4TGqQ0cXe6KiUbaGitbSJtIksSJ31nCltt2sSqfYc8JpVRoIGExr3oLTzRHyYkcs/YPcNZD6xip+Bj13/se1u4T2J1YyebJOyjtzVK7Yxy17Y08PWk5qxcuJxVNMpFP8bEnLiJ91z0427eSm7iA53dWMNyWonfHCJIMG/7SQt/OEVSfgqxImDkbT0hHkqBmVgmF0QxOwcQWCrrskLM8mGUV6FVTWZDbyIJJGVYNfJreNo3+8jAcO8jsTU9RMb4RX+ZYIs2tGIaMABzNh+7V8JoWdjpDr6Gy68Yk+l+fR47FMFM6jiXIxguM9mTRFZn+7UMApHstUt0SWomMqYJpFOjyJrjg3XMAmHtRI13PdaHaFpbQsGWFdLCe7dEmKpwqjBV9VMxvYGBXnER3DhAYXRnSA1mipYKf37Ed21HJ5mQUGSRZQlHgmV9uJDouQsfWNL3b4jQdVckJX5yBJEkEKwKc+N2jaH2yk5IJUcaf8NL3LM2rMuvsBhrmxXj4q3EKqQK186uYcPI4ejb0UzW7nNr5r20NM9qT4ZHvbyY9mGfB+ycw57zGQ4/jUTjqY1MOa4wWeSmSeKWwibeRZDJJJBJhdHSUcPjfdGb8MDh2/bEUROEQj2Zb2OScHDk7x6g1iiMcgmoQXdIp0UqYHZxNk6+JSyovIayGIZOBF35opNMQKArNRYoUKVKkSJF/Xf5bvue91TQdiOBqb2+nrq4ORTkoMum6TmNjI9///vdZtOjlIxLfaYrXvci/BUJAYfhAIsDDWCHQfA0MupF9eCph/g2H7h9ZD9kOKD0GvG8wL09+ABIbIDjRFfw7b4POvwASNH0Cqt91SPFBermKz2JSQDKTfH4HTMqGXeuTudcd4qc7whBPch8BwizlHDReKu7ltm5l6PrrWTu/ixWXpJG9XiKUcjnXs44V/Jrv0EM7ABPzFXxzVykTciHQY3DEjWOWCtt5nhXcQzk1zGIhu50NTGp5itLtg1x27W42xR1OOCPDCeemaI8Kbh8PtqzgwUv/daegTOjETvqx/nYSp19/HRVZi1InwrJ9CYbUURwc1ifG84Oe08HUUIRC42duwsQgPRik0FvNtOrdBDGpTSssTFhcOQ/goNwhIeMjwCd2OezLqsTXGsRyOiuc0yip2U33st0QdMVKGQUNHYHAokCQKOmUhB2Iu34EB9oNU0KjNJm8ZdKxO4YkwL/1LObVlxI8biVt7EVDw08Q0xR0PDuF4ZJt+MrjhCpSnCSdh46HXWwE4DjO5mnuH+vzHJbwcb45dv/vfY/w19wfKFPLuNJzLGZmKw9WDLI50Mt6nsSLjyamcgxnoqKynqcAGM80vsyPXt+4LAxCcArIKvlUgWzcIFofRJbf2Mrq5naTVZtyTKjTOH7Ba0/KDNLLphs7ab9zgNLhLQTqYpx6x/8csrJ7/+o+nvrlTlRd5uSvz6ZmZsnYvv/duJc9ySwAvZnbMc01tGFSkoxw1S+TVHp15sRCeJctI/DxjyOEYPnIcuLZETy31PLjxh8zkB1mwn1z0DNePn/2hzjp8zMBGGkbJdmX5dGrtru+2Y4gGzcIlHnJjhjkRwuUNIbwl3gIV/poWFhOXb3Ns5+6ked3V2EIL0rAQ6xUkM3rRMdF+PBfjyeXsrn3snWA6zKRr9URaYtpk0sYp7ew5ntPMGLFULwaw9RgOF4kGXAcTAMUXUYPKFiG43oo2wJvRKfpqApG9w9RiKcBaIsJtp4tk3EsogWdBsfPhXIj4SqNRGuSkgY/W/+6h3hHCjPnYOsBhKRQMSXKwg9Owl/iYePtLexf1Td2HAAZC0XYKFIBBBQkP8gKKgY+j4knoBKbXIEUCpFqH8YYzXPM52az9GtHUsgUSHSmiDaE0f0H36uEEIy0jeINe/CXHhw3RrpAZiBLpCF8SOLAw2Hlz7azd0UP4E7wf+i2E4oezIfB4X7XK0Y0/xOwHIuElXCFZRz8sh+v7OXY6LGcEDuBeaF51HhqiKivL8S/SJEiRYoUKVKkyH8Gra2tACxdupS77rqLWOzwlyQXKfJPJdfrJq0Lz3C9id+K9qwkBCe/vckGhQ27rnBFXb0MZl792uJwIX5w2xx56f7YAvf2ZvBWQNUZ7rZjQfedIBw3wrn/kZcIzeVUcymXsZXnmK8dx6RxAtJ7XJuNF4nMADHKOI+PuHesDLnsVp4PtBNWqpiLm5Cr/8c/xk4k6JzdQrY9R2KKj366GSXOYk6m1dnDrZ2/xRmUOKlqMhNyB6KDCyNupLceI0uGG/khJgW2spa/8Vt8sp/AhACXlX+c3586m3vV5fxc/zprDgi0Zi+QkPBOgeCZ6zD6gyjBHNGP3MOAPEB3GPQRnTMswXRpGnE1z/7JcWLz78JKhkBIJLJZFL+BWpJHDEUo6YlQGh5hab+CrKlA7pDzoQsPASvGxmqHqOHwPinMzhGHq1IPkVINNrbY3DPbtR2xsXHIEyCEQJDNCgoYaFkPXj2PoYCjyESIoaKRk4cw67oxLUFaGuWpWIppdim6otBPF+OYRGLYR1zvRMg2CV8HWcfgfuVPHMGxHM+7KGCQYJA0SQKEkJCo+odI9IuqTuciToeRjbDru1w+YQs7RZJ+R0WSZTQ8BAjjw88FfJxSKilgcAoXvv5xeeD1MdSS5IFvrsfIWNQfUcbp3533hsTmSeM0Jo17qZhnWQJVPbS9FdzLXdyA1DaNKmUmTsWRDFkvPeaEY6rG/ID/kQ80VfODHW2MtKeRNu0mU5EioktY5Qlkr58JQXeVhlzp2iVIksTJJScjYoLBC5LU547kiO+sZeHz68lm61m1fwvVk6OYiRRbbt1FPlmgb08K2aMi+/0UDLBtQao3S6Q2wClfn0PTURVIkoRpWPzppFtIdYVI5b0IJGRhM2RpaH6JeEeaO7+wlmhDEMcWGCkTgYARg0CJh471Q+i5HUyX17NNWkCqUEqoWsXr8ZPsySJrKlLBwjYdbEPCX6JTSLv3PQGJzekOKLeoibv7nz9ZICpVnLyC2WpRc6vB8/JWFCPtei4LCT3iQ5YkgjEFb6WPkT4T23RID+WZeEwZ7XUaHV4FRZXIJ03Xql2WEJZ0wItZQlYlPCEFrwyy6sFX6kPzKSQ64iRbhnEcwTM/e57SphB7H2ohO5wnWOnnzGuW4g2712f1NetpfbITWZNZ+q3FYxHLnqCOJ/jGLMU8wYNSqOqRi9YYbzFFofltIm66X0rac+3E1TglWgnTA9M5p/wc5ofmU++tJ6S+vCdRkSJFihQpUqRIkf9OVq5c+U53oUiRVybdDNu/7voJ+2ph9s/dSNo3ytAqaP6JK6xWnAQTv/hW9fSlpPe5IjO4iQ0Hn4D69756nfr3Qmaf66c87iNvfZ+sjJuIUYu4x9j+NRjd6vo2h6e5Htr/wFbWchNXY2OhoTM99mmIzX/FQwzSyyPWH/B23c8+vZdux4LwDJbJH+NULnSjvBFM3hBg1VEdDDsKURHjGeVRlvFBMtd7CNzdwNyuLkRVP+aXomgxCcqOY1SHp/gTAAUMfKZF9dB+eqL9JLxBTMnh+5FfkWQECQkJN31Zeq3N4A9AtgXZUwyin+vFW60gmQq1tsmwBxKPn0aicyKXhfv4Xvl+tpbtZV2jiaYK1LIB7FSI4b9cStkHb0LZU8dHrhhhXEJi6smC/iML/HiSjrBkJMUBCRASUvtUhnxx1ukO9WGDpL+CCzbUI6tbeXBmjqRX4GR82IYP2VNAC2Ypo4pR4mQdBX3Uy9c746ALkh6J+yf4SPsyzONobpevQ/ELMvvq0SwdYyRC+2iIudNVjmEOebLEvd3YpQmElsdR8hSkPCPkWME9tLGXfrqoZwI6Hsqo4njO5nje9fIX1hgAIKmaGLKbGC5EBA2dGRzJOVyKFx9n84E3N0aBvSt6MTKuRUXnxiFGuzPE6oOvUevw+OVfRnlibY6GKpUrPxMjGnZX8zzNgwCI0/uJbyunzK5ixpn1rytP1ZxYiNuOnsmff/8Ua5rHs/FdGzCFzIz0BzjiZ+dSuvpplPp6vGefPVZHCMFj/28zbWsHOdZoZOKO21FHQTGbUeQNrP5NBeGgwUjbKPHWUSzDxkFBUtLEZtYysGeUULkXSTg8+dNNeLxzyedgxY+30bZLQjPcXFtCSDg2FLIWliZhxQ1atw5TZzikBnJYho2suM/VSJl4QhpD7UNM9ApmSRvYqR1Np+UB4RAbF0L3K/TtTCBsgazJ5EYKKLqCJEtsXJJh/0wTYQsaAxaLt5agefLkTBu/MURdYZhx3gC9ydhYngiBK3Yruowe8WPbICSF9GCeZ363iz3376Ws3kMgLCF5/OhBExmBY5jYo6OIgoUt6YQqPSz9ylyQBE/9bDvJUcHks2tRtB6SraB7ZCQE+5e3kx12k8+m+7P0bhmk6dg6ClmT1idd6x7HdNj3ePvLWmPEWxIM7Bqmek4FkboQZs4kO5wnVB1AVl4qIi9430SMjEVmMM/ci5re9mR/+1e0k+rNMOHkcYQq//NdCopC81tIwSnw4NCD/L7n9yTMBALBgvACLqq8iGMixzDeN76YwK9IkSJFihQpUqTIq9LV1cV9991HR0cHhULhkH3XXHPNO9SrIkWA+DpXZAbIdUOm1RVE3ygDy12RGWBgBUz43Ct6E79p9FLXLuOF/nurX708uH7JR/7FjYaW/yESc2iVG3HsH+eK0PLr/GkdXwd7r3b7M+5D4K1xz2dwIp20sKKmi93j1vIBNjI9W+ZaaqhB1jT2YCuu6LeGR7iQT6C+6Ge9QNBFKxFKCBPld1xBn70JEd5PlzdHfd4PxgD7xEOcqp9O+Re/yGNXfYau4SHinhy2JWHZBQbMJyH8QXbu3MnitjbqRkZQRkbof2QZdVd/C3y1XMcX6aIFgDKqOG73U7SsHqHlMQMjahL8P4Whpj7SjJIni4WFjEx2pUNZRuLcdoE3LVh3hszgJAeh2gxaAluBlOkndPY9tCDxoVwIZWLhhScIso2T8yFpFvZolEkbBVvem+DpUoeaDbBrk07i6AI4CkJxkABPtpxkzkbyFrB9cZoliZHQCKc1LMbp2ErGq5BBxeiYgFPQEAUP6qyt6D4PZ/MBtnqfp8O3lbTHYWJWptpw2Lk/x333SPz5nN8iJhmoihdFUlFUgSI8+NsXMnm6xUV8iqv4DEo0gdfTQ8Exiahh0nIOCRkLi1Z2I3DYzSYChDAx+AI/QOHQ14MQgsERh3DoKLz+Bzivf4A/NPSRkRzqGM9SzuGDfOn1jUXAIM893Mww/ZzE+Uxh9ti+knEHRWVP0E349lbQ0mXy+HNu1Hl7r8VDq3O890z3WLU0MkQvHB1nwhSTizJLKBn3+gP1JEmiamqUd9+9ifN2x7D9grkfjVH7yflw5EsnaHKJArse62a0O0uYUaq8IbJaHsu0CIQEW/cnsGJDPHfh3YR3RZn8xAw8eTfq3RtW8YU1YvV+BnbFsdJZVnz/WZxABMcR+CsDjHY4yLqDqspYFjiOII+DpEv0KDb+nEFhtEDAZ5PuSpLJaXhjXkzDphAsw0zKtNmT6TdKyKUSoHuwrQCRmhJ8EZ1QlY94Wwq74CApErIiMTABrJwFQtA7DjKPpzhuYzlbJuyhstDBOY/toiyfZYRzMHBFUAeZAkFkR+Kcy49hoHmUZ37fPGYTUsg6yLJE9QSdQE0Yf8zDuGNrcQyLR768glzCQnVs1Nwocy8ez0P/t5HKWW5CyaG2LGf9+Fhuu+g+ssM5og1hJp8xno03b0c4AlmViI1zbRk0n0qw0k+637VAiTa+1K4h3prg/i+sINGRRvEonP2rpaz99SbyCYPKmWWcfMUxL7HW0P0qS78483WPpzfC7gf3s+63WwDY93gb5/7+tLdd2H6nKQrNbxIhBBtSG9iY2sgDQw+wP7cfIQRBJcioNcr3xn+P00pPe6e7WaRIkSJFihQpUuTfgOXLl7Ns2TKamprYs2cPM2fOpK2tDSEERxxxxDvdvSL/iZgp2PsjNzFdzXlQs+yVy4ZncCA81I3C9dW9uWMHJx6MMg40vX0iM7i2EtO+C4NPQmAClC89vHqS7N5ejDEEzT91BejRreCpgJpzX19/eu48KHp33Q4zfzx2nD+Mz9Nf2ghylru4gem7DDeCVQgCaje5sgQezziqlamovQ+CMQhVZyF8Vfye/8cu+xnO2t3KkmQts0sH6GsqQ0Imaupun3OdzO3VwfgKqSnf5KZPTiBTqZAs7UYVDobsMGm0AGE47rjj6Lvf9QwuLS3FGkmBvw6BGPNuBiilkhNz8/nN31dSWciTTkjE/6gRu7yMQXqxMJGRUdFomljHCTf0Upcy0DSZ0p8L7r42iiVZGFoGGwf/gnUooVFAIFf2vNhqGQlQQ2n8fTP4nHE8q2bcQNJsBwu6F8BQnwRpHfCj64Ijg0fQc//5xGvvhKyOx59GUm0yJLmlcTsnWicT0rezszAMtsLow2dj9tbh/epVqNUBauyZbNRWYUUtnpRs6vY6eB3Y/HdBYlcW/VQFeZ+Ef7rB5IKE3uZhU3wS05Z28GF+TogIDUxiG+swfWlMTAQq4kCqPhkJBxsZGRsbkPATYj1PcSoX0sIuBuhhpjiSX9/ssGZznkhQ5qrPXsOxZVmWaAHyUo4saSqoec2hZ1LgCe5mO+uYzGzO4BIe5q+s4iEA9rGDH3ILOq6gPPWUWgBGOtJMPqkGT0BjD1tpZTezWEgtja9v7B8g6HcTxdkH5poiwYOvsw/yZVZyLwLB0rJz8JYdXqJNIQQim0UOBNh5bzM9mwaonVWKPgHMbIRIrZ+QnHzF+ppfIdGZoZC1GHBC7PHMocZcR1KrYstoPeuPVtixbCMBuYN8dJhwd5RQbww9H6FVtHHap46je+MAgYhCWZ2OYzkoCuRTpuvhXBkgUuMn0ZXBMmyMgEzetOhc5KVkyyi7d+VInqgw9/E8jiOhahKaR0YI2DE8nl3OR5GsDIbw4ggFUQCRNNG8CiXjggzuT5IfNQE3kaInojG5I8i6ujxCgnFbJGxHQd+c55JVHUyWnseWQbUdCAkUW0NTZQzHR8vcDL3TJDqefJZT4jV4IzqOZROqDOHX3eSVVs4k1zfKnuU51t3WTuPRNYTHRcjG3QmEfMbhx7P/hkAhWO6jZEKUiikRKqeX8ZmNH6R/xxDh6iDh6iAl4yP0bxui5ohKog2uoCxJEqf98Dj2PtyKv9TH5DOaXnLNBnfH6d+VwEi5z/vhb6/D73UHVf/2IYabR6iYVjpW3jIsnr9hK4m2JLlEHscSTFs2gRnnTR4rY1sOm2/ZyUjbKFPOaKJ+0Wu/rl6J+P7E2HZ2OI+RNFDL/G+4vX8HikLzG8RyLB4cfpCbe26mPd9O1s6iyRqVeiUBxZ0FGrVG3/yBFAUuvPDgdpEiRYoUKVKkSJH/WL7xjW/wla98he9///uEQiHuvPNOKioqeN/73sfpp5/+TnevyH8iPXfC6GZ3u+0GKD3qJV6/Y0TnwswfQmY/xBaB9iasAK0MRBcctI2o/CeM78hs9/ZmsXOuYPsCVur1t+GthuROd9tTBYFGmPp/MLIOXyQEmtumT/jB7ANgr7yXOe3d2FmNgsfgYu3d0HkgQeHwGhJH/IC2wtNMi49QNRongcJRQz52Vdj0h+bw1eFjIddLaGQXDfkA0EPMThHRw+Tzfk7qVhgvZIajAWZ6zgLgggsu4E5pE+pvb8XjVym59EM8zUM8zh1YmDjY6Hg5hjOQqrsIeFaTL4RR9AoWeBdQjU4vHWRI4cGLEIKpFzTi/2sHWquEt1JB5DWamIYlmexgPQBKRT+SrYBsg2K/+MwhFQCRYcopvydoBumeswMrIaH0Q9onMeio2L/+Enp5Cr0Qpf/s7UTiU1G6z0D90NXImgmaSR6HZHeKm0IPUfJsPeGJfoaeOg2rt57oqQ/hqUiwsfkItuY24GnMoEegWZV5pEzQ45XZ1S+hZXUyT0n4TjQpT0g0VmxnqE4wS32K5oiHr9LPB/giZ/F+trGOFnaSJYOFiYZGCZXU0Ugz24lSRo40TUzDg5dK6tjMs9zIDxAIArkadmz9NhIao2mHR5/N8/ELoqhAEI0gh5eI9Tq+z/38iQIGVdRjkMMgP7a/QB6TwpjQDAfFZoBmtvNrvo1A8Dh38G1+Q4xXeM94FSpKFC77UJTHn8syvk7jjGMOiskevJzOxS9bz3QcNPmldgjO6CjJb34Tu6ODfN001ncuBEmmZ0M/p1xyIfqah8HjwXvuua/YJ1mRKYvkSGbSZE0PW8URbLKmIKsyOQT5GMxvfZ7Bxi58JQ67v9pLnbMQKSKDI3PCCZ9EpKfx0FeeZPfKIUxT4J9v01LTTCBZSm15I4ouUzk1zPC+BJaqMCwXMEUObxYkC8oet1EbvZTLOkM9Npm4a4NhJC1Urw9VtRGmjEBCkt0o82RfjtyIgbAFkiLhmAIksHI2k9Z6aGyrorO3n1irji0p6JLEfuZQZbUSkOLsUecyrNbTMMPHgnOncN+tW9h1LEiyYIsYpV4KM2VymKmn1jLn3HEM7x+m87le0r0Ztj/Sx+iAu8pipDPDxMX12LkCib48ueE8UjKF5A8gC4U5/7sSJ/Icy++pQ279HJOWTiBcHWS0O0WqN0PjcXVE6w+OY8dx2H3/fno2D1C/sPplHQKq51aQzwosEzSvjBASdsFG0RUUj4K/1MvaG7ax6Y52QtUhqiZ66X6ue+yY1XMr2HDTdhqOqh2ztdjzwH523LkXgL4tA5x/4+n4Sw5vsuMfGb+0gdanOrELDrULKg9JaPifSlFofgM8Pvw4P+/8OR35DgpOgSpPFXXeNzmb/0p4vfD3v789bRcpUqRIkSJFihT5l2LXrl3cdtttAKiqSi6XIxgM8v3vf59zzjmH//mf/3mHe1jkP45/jCL+x+jdfyQ83b29GYwh2PYVN9metxpm/fTNidb/bPz1UH0O9D3gWmdUnf3adf6Rpk+CFgUrC3UXuY/F5kNsPh9gGXdxIwAXSB+DhvXQdgPDWpqg42XBiArY6LGug+0Zg4T3XMuHRnaBnUMCvIqfMir5gnIlijYNrUqHxCbo/S4gMOUIv7v5AUp6PBy/oJ5TKhrRlTyhZBWhha43cAf7WHn+FqRl05EcMPU8d3I9AoGMzAKO5zw+4gqN9fCNH9Tyx1vvQIuEOPHjR7GBFcioRAoSn9yZZna2ii1VI/zlCi+n/tikYFls/3QtQcJo6AeiewFbAcVEUmwkIbmPSw4IcGTAFgzmWvitF8Kmg+QT9GmCxBcgOGDTqw9hTj+BQiDLXnE7pZd+EO/OqQjLByKHrBoIC1oKe5GEwDgmS7SzlrmfuQfbEgxqHZjJGpRIB6YRwRmahN+bxHkO1qU1jFlxKt8vyPw8SmK5jW++ybK9Jqsm5RGSg9d2fat3s4lb+SVn80GmMJtmtuE+GwkFhSamEiLCu5jLIk7Eg58u9tPIFOawmNu5zk0KB4zq3ehlw5gDrkdtTfnrl3MEgr1swcSNpk+TZJh+zudjNLONEQY5g/cQ4JVfjx00j/XJIEcvHa9baB5NOQzEbRbN8nD0vMPzeRdC8LPdHazsH6Ex4OXKOROJ6AfPgbFiBXZHBwD25o0E9SrS4UYACsedQ+UnLgGvF9n/ytGkzu6dHKk/xdpsNUYuyJ7jm4mXpBi/eSrBTD0OWc65S+KpMzxYwRzv31PDPRfZCGym+KfgkT0QhqkXTKendRvDZpw/nvpLCqEU8nESp/z0IubMPBLNyZHtHARJ5hNXH8PNX3oOdRQkAeQhvKSSyioPMy4Ms+3BATIjBmbOnXAR/hCabWIaEqpfZdY5DXSsH0bRJOyCM/ZcJAkcSxAs96FIEsZQiILs7jdzNpIeYHn+PWhkkBD4MznsRIDdK4fQ0zpNG03aF5ogwJYFdsFi3wO72XPnVtJ9GUonxhCOID1iIYRA9alkhw1mXjCRkc4sPa3dFJDRnAJqPse4k9I4JU+RTxgU9C10bv4LzSvP4pSvzuTZXz6PkTQY7Uox44LJHHvZkTz9g3W0Pd1JZihHyYQoIy2jVEwvpWZe5SHXrG3dMJ6KGNmONHbBRmQymJpE/eJqZl8yjf0rOnjyp9tIxy3kbSN0PeMQDMs4toNwhJu4UIL2dYM4zhCTT6wmP2rgOA7ZoTyyKmGkC29YaK6aVc55vz+N7HCOkomx/wo73f86oTmVSvGd73yHu+++m4GBAebNm8cvfvELjjzyyFetZwubtaNr+W33b9mZ2UnSSlLlqSKiRv5JPS9SpEiRIkWKFCnyn04gEMAw3CWpNTU17N+/nxkzZgAwNDT0TnatyH8qNee7thnZTtf+QS95+485st4VmQHyvZDcCqVHv/3HfStp+hg0ftRVc14Nx4T0XvBUHhoprvhg3KUvW6WSWv6H/zv4QM0yKDuWhp2X4hl6nKyus3fcEcwqew+M7nWTB5YsQBnZQBNTGZEHkLzVlHrmQukxeENzDrYVnQezfgzZNv5011YeX/E0AP27+vjI18ajHEhA9oR5M1u0TkpwRR1Hleimld9xBRhxphZqGQ4Eicllh4iM0+YeyyfmlvNrvsPV/AWDPBmSNOQtFEmngloW9g1zz5RqbvxNHFnNMtFI0VV4FF3o6B4PJiZ2ywyM/iq0kmGksj6oaUcWbu5CxwIRl5hrWoRHBH1VEoFNgub3w0gcfL4sUc+DpKoW4Tn6OZSKbrLeLGJqEseUwJTB0LBHCkhRgTDAUAr01w+iZKDU64qsXm8OyTRwULF3foBpdQrSbi99y0dJf2gfsTN0Urcn6d9dixUYZoMxQnVWoTcgGNUldDNIbrCSlspm/q78Dh9+ZrCAPWzGIE8JFXyOK5nCbDy8vNg6gwWs5mEEgga1iS98YDLLnzWpr1Q589jXFr56tsdJ9edpXFxOW8CNoJ/JQvrpZoBuSijnJM6nklq+z404OMi8+mTTTBbyKH87YNVRSyNTXrMfL6a53eRbv46TMwSzJ+l8/9OxsXH3auxNZVnZPwJAWybPo73DNMU6MByDJZElyKUH7RF8ZX4iDQ2kO6DmiArqFlYjq6/8vP7QtpNHOttYsLeXqaNeMAt0HLGLPfObSZfm6F/Uzf/2fR95fzOPNIXQ24Oc9UyQpe9+NzXDi2h5YgDPDi9/r3maE782j2C5D82r0CttJe9NQEHgeCX6p3bStbOBfFiicmoUSZLI7IxTaimkDtjDyEJi/4O99Jd7aFoiUDwy8dYUds7A53WINpYSrAphF2yy/Um6V+1npDWNYWogq2geBRMH1SPjWAJhCwKVPiRZRgh3ssY2HfwxDUUyIC+QHJBxyAzl8ZYUqBtXwvAug67pJqXdGlX7oGyuh1xvjnzcJDdikOxKkU07oHjwRhRwBNUTdbqe6SSbcghVBUgP5pAdifJGLyd+cybNA7djmw5CQCGpYyUM9j/ZjZWz6N7QT340zzO/2ED76i50v45tC7LxPIGyAt6oh55N/ey4q5lIfYj5H56Joil0rBskWh/EX+JlYPsggVIPkiThi3mpmFbK3kdaXUEZsNM5DNNGMmQkWWL8CfX4SrzoJWHW/N6NYN77RA9nXj6XZ36xgWRPmkC5n/ZV3cTe98a1P3+p778ikvkF/uuE5o997GNs376dP//5z9TU1HDLLbdw8skns3PnTmpra19SPmNnuH/wfm7qvYmBwgAZO0NUjTLZP/m/YiaiSJEiRYoUKVKkyD+PxYsXs2bNGqZPn85ZZ53FV77yFbZt28Zdd93F4sWL3+nuFflPRA3AlG+8vcdwLGj5NaR2u97IkbmMeT1LKvga3t7jv1280u9BMwWtv4PCMOT7oDAEsgdmXAmhqW/sWP0PU5t1SIfmo4o8x9bcCL4mmH8zWEnXgmTjx/BYUEU9lF0M9Ze8NIkhQGgKhKYwnNoy9lBORLGVMAopeksbuMf3GCDRwi7GM50drMcWBu/eazOjp4eCFqcQm8XU6Re6l/IFrAxDHd9jgbOR1tpRhnw5HGxGdXi41uKsvQGcXJDExlq0UJbj4yn2Hf0EEUcQNg3imowkq5TN6CBkz6EtrqPW9eDIEgo6jrCRBuGYnQ4X2zL+iERnm+B3a2SUvIWYBEYTRE9vJ3zktfgn70fxJTElgeN4sdJBhKkhChCo7WBWVvCeTigoDjc05mjzSiSyOoRtvFoBO9RNxGcy7+jnON53Ahs+s4r+j7cQ1mTiah8OAur3onozrLV0qjIaPl2mVwTp++E3kYdqMT/zC6rGS+TVHCKrU9O7mHBUZ27JLH4vXYGOlw/yZWaz6CUi70yO5DKuYYAepjMf/zg/iXFP8BT3k6CBS/jMK4rUe1f2sPKa7QCMNnbR8Yu7QYbjOZtvcS0yMlOYc0j91xKZwZ0I+Ra/oY9OGpiIj9fnN/vUhhw5wxX+tjYX6Bm0qa96bWkqrKnIkhuACrA+exd/TjxEZVsa4wGHBSWL8S5bhjM0hH788Zx01FG0PtuPY4uxl+poT4bnb9mP6pFZdOlkfBGdtkySPz/3KOW/NNg95GVkeDphhtC7JjPjoVrys3cyfOx6ytf9hGRJji1zhkAE2DVZoiJyEh0/G6b36RGEUaAilmGNXGDZtSez4BiB9Lcca02ZtGoh2yrhXeUMjRrkExbVtkO0NoAjJLAEmkfGLjgIy40XT/bk2XJ3K7KwUYSJBBgZicGt/WS7Rlggr0AvJGgLH8WI6UVzLAwRRLYs9zwZDuGmIOrnyylfUI75VZu9D3cjHIHX6+DzqyQzEqosgRB4gwreUo10f5ZYU4TKvI9zbnHFUVEhCDdE2P5gN4oKki0Y7U5TcDRQFMJVQZJdSfo2dDO4pQdLC1E6qQRJkWlcEOWsHy5hYMcw+x46Dk/TVoY21NG9aiaaP03r+hG8uoKRLiBsMFIWrat6CU+ooHK8B3+pF0vIyEEf2/62B0VT6N08gDfqYfa7pxIo1RjtTOEJ6URqvGM6XazJFYanvmsC+5/sonNrGjSF0sYQgZhrC3PRn89i3W83s+o3uzHyUD61lOG2FKpfI1IfJlQdRJIl+ncUJ/pfD/9VQnMul+POO+/k3nvv5bjjjgPg8ssv55577uG6667jyiuvHCs7UBjghp4bWB5fTq/RC0C5Xk6dp+6fKzBnMhA8kOU1nYZA4J937CJFihQpUqRIkSL/VK655hrS6TTgfk9Np9PcfvvtTJw4kZ/97GfvcO+KFHmDDDwGA8vd7Y5bYPYRMP0KSG6D6HzXiuLN4FgHxNbYa0cY/zNovxmGnnK9nFO7IDLPjToeWvXGheYDAqBfCpOXNCzJcR10tdBB25HpV0DvQzD0JHT/DYafhpk/Aj32si2+5z3vobm5mXg8zoc+9HH0RaeBlaJT3wqS+34jIXEy53MhH+exnvewsHMvIcPGi4Qu+SGfAt+LvIFbrqN6aAvRXDvH7Bf8cA7srCgh4ClHsyXUyEK6pJNRbptGOVBReyXOZIeuqMCWwRYOekEGTUKa/Qw6LQcalvDiJ1goIFXaFJYIIrs9WLkIkTaHbaIS/ZgdhJoMfMvANxs8Jes4pRtO3SXx1/ESq3QJNToKtkxUT+NF8L428JkQsOC8Loefz3KwlREUwHFsFMmmYcJmHKWUW7iLXqUDx2cj41rOqKhIAcu1khAWXVKIkqCNuXYB8mADDUwkvr+RHRXPQGiY+J4QYiDEBGbQN30FDfVh9rKFb3MpizmJL/ADQkRwcNjMMyiolFPNszzOOlZwChfyF36JQNBFCxXUcgaXvOz17do0PLbd3xaHhAYlJttYy0V84g2NwheIECPCy4+rFyOEYPnaHIMjDqcs9lEWU2iqPTj5EQ7IlEReW9wGUNrSnPrbdnpHc4z7+Ay2Ve8C4KQ/t+AMWVihMMgykR/8AIDnb9nHxtvd8TPh2CpO/upsHv/BVobbXP9zI2Vywhdn8uTvNxG5bZTyHVH0giDnyDj+Wnxpk0KZgbZrErWhLcTWtuM9O0WMAnG9DiuiIxQHkc9jmiam0Bgc9SI9sptdj05l+ilVlC3vofKv01kZtkk2z8LXV0FmYoDWqZvZVdFJ6cIgSxPnUEgZOAU3NSSAIwmEBEZAIBSJUMKV7hRhI2yHCUOPE9H3ouAwNXkXSft4ElTikQqkChFUxcHjEWw4PgmNQzA0ROVSqN7gJTecQ1JVNK9K9Zwoo60K+aE0/5+9846Tq6r7//uWudNndmf7brYm2fTeCCmEFlroCCKgKIL1QURRfH6WR/SxgAjqI9JEmvTeOyEJIb33Tbb3Nr3ddn5/TEyIoaoI6rx5zWvP3nsac8+dzXzO936+qpmgyGlTdup0qkNh3tjUQk+sCNnvRXMrrLytiWw6d02rJ1fhlDOYlkzv3iyqQ0JVBbIECEGw0GbcSVUMtiaxDZu3bttJy2stdO+eANIEfOVe/GUQqPRgW4Kpn5/MwI5c4j5sgSRLGGkTRyDEuHNGsPWZbrpf7kVKx6maWoQn5CYb0wm3Rulc1ozfb2HbaY790TRa3+igZFwR404bBUDx6EI+8+ASjKRB79YBVvx6HQioPqKCWGecvS+34QupJJqzJPpTTDyjnv7dUXwjAsTaIgDUzjs8KDXPu/MfJTSbpollWbhch+74ud1uVqxYkatjmzw1+BR3dt/J9tR23LKbEa4ROa+dPHny5MmTJ0+ePHk+QhoaGg6UPR4PN91008c4mzx5/kEI8Ve/21AwJff6e8n0wrbv5aKGQ3Nz0dn/DLFZj8DwW+CuhuDEQ89ZydxPWdvveS0ACXyj//bxKs/ATO1lS+ohVpe7aHX9kG9xHaVUHqhiuup5clkf48QWSkpKKCkB+l+G6GZItkD5SVBz0YH61dXV3HbbbYeOoziZzkI2spLdbGIis5nEbGRk5uozQOlCQ8KBCooHtKJD2+sDOCxBICNhSRJndbgp9I5E+Bs5w/t5lAlHM84QTFwbZttenSc7+zk1Y5HOwh4PqLv9GIpFymngych4RvpJOeKAhIxM2KFTqCvIkosuDwxbgoeODBOYrxN/qYjCEb1Is2yEGyQbtoZgcYuHxVuLWHlkAqHFURDoQFEq56LhA0wDkjGB2SOhFHkRcpwEUZChKbWDOu8o4nIUGwuBwMbCiRsJCacsY5oSSBIePygoiPJWLMmgRexCe/kMyia0EZbDDLVpOGWTtDOFO+0iSYI4UYooZWe0jcuXP8XMxGnoJ9zODu/rODWJDClc+6OGhxnAxCRFAieuA17L70Tt7BL2Lu1FCEHRaB/dBQYAo5n0t6/DD8kTr6e444mcsPvamjS3/KCYY+e4URVo7zVZNNONQ9g88/820LMjgsOlUDaugCln1lI56VAbn3V/3II/YeHHxP3ITmb9ahYtmRYUSxy0NDXNA/U71h+MQu3ckCuH4xF6CrtQdnmJP5mmY2eEVa1dBDsCKBkN5Cxg0jRjB0qsEI/pZHZGZ+rDZUjEWfhWIU31fSRGOvnKrEuYWTiW7U8NMlTqxNedJS0E0c5h+s/9DHahTq9cT0d6PMF+lZBDp88D2azO7nmvUVbrw6rx8cwvXqHKnIisyNgi9/FoqbDfTplEyGJEtA8hVNIEEIAidAzLYtCuRLItYhSiSx6QFISQwTawdYvBMhl/wiDcmkCss6n1eRHZDLJsUzevgu6dcSwLnA4TYdiIgT4ayiO8/tM1mEmTSoZQJB8ZYyzxvgwIkBWJbMKkoNaFsASTTi6gdFolb/56DdkBE82jUDaxiH3L+2ldPYDTpyIJCzOeRk+DqkGybQAjbZLo8RIaXcSI6SXULKwn3JHEzFjYpoWdTGMmM/RtGyLaOgSqhq04ifcmqZhSyvgzRtG/YyhnDVKgEh/UeeEHayiocDHcHKV6TgWVU3PWPw5XTlhvWFRDYV2QTDRL2aQSUoMpJEXCX+RAc8uMO6MBT1mAZ3+wHiEEJbUlHPWNiRQ3/hMspf6N+I8Smv1+P3PnzuUnP/kJ48aNo6ysjPvvv5/Vq1czevRomtPNXNt2LSsjK0lZKUZ6RuYF5jx58uTJkydPnjz/VCKRCI888gj79u3jqquuIhQKsWHDBsrKyt7R6i1Pnk88ZcdDbNtB6wz/h/N0fU/6X86JzJATfpPN4Bv5j+v/nUi2wurzwIznkgGO+wEUHXnwfPUFuXnoYRj/c1AcOXuQormQaAIzCcEphwjiBjp3cwNt7GEux+eiVOO7ILYzV89M0DZiBnd4V+9vEWMTK1nMOUAuydvNa67nzY4XuLwgSSKZxOf3407sheiWXJPOh6D4KPC8t1WJisqX+P6Bfrezjk28xY6KVk4d1ghIIVy+WTDh56C8LYjLSoOt403HEEKi3wM+w2RU1OY4//9QTQOtrWluvLGNpk3tjG3o542Ll3FnVc5GRdggv6ERaU1iDaaxyjI4z9IYOW0CbcoeUsTJDBqk3QbxoMlJJSdyW8V2BpxOJEy8CwUDv/ATKI+iNYChwoALNjiK0YYbSQ1F8VSuR5IsFAvK09DjhGizTPegyl19XlreWIR64aloVf3UHvm/WP44tkdn0O4lKBcSJ4LYLzY7cTOeGYSlfgYdvYwxZ1C+8SLWq6/jnfoKYy9bStuuIEXj2kiZDkQqgNvpJx3PUhus4fIRn+ctniZJnAKznC2dBoGmIBvfiiMqVuEs0mmoUkkX9lDNX9a0wCBLK3vw4aeIMiwsFJS/voyMnF+Ov9RNvD/NiJmL2Czn7rsZLDxQRyCIMIQXPxr/eO1jb7txoNw7ZJFMC/xeiaNmHvSr3fJkG11bhol0Jol2p4j1pOjZFuaiuxficB2UrBweB2S6Id2Jw5nlU+YcxtX/CHHlNkbeuRxZ0/BedjBSu3pmMQN7Y7nyjGIiRoQXLryLXXuaUevdnPfWV2hekYJClfCYMLtOWIfbsKnbWcv2i5cT2jYONaMxq2Emu399NHXJVyiM2Bx3/6fYXjgd5QEvxs0WwWvGk7klTeE9LZCRqLZ2oOn9qPE+CtVBVKUYW1Rh6h4KzSiy0PAnPcR70zh6PVRvyt2PQoBDg6wFtipI+QQdk7Is6XuWmaITWdNYKk6lzx7BFo5gSJQRtcvIxVg7cco6gaBJ1PTi9dg4HA6Oq6vhmb29lCy3qV6tEOscRAiB12MhZVNMPbOGdbcMYqUSJIwAsYzMYzcMoKYc6KaGJmTGxDbTUlSHjIVlS2CbmBEbu6qQBVfNpnZeFX++eBkFoytIheIExhQw+qzRLL9hOwCJ/kzOI9m0kSSBLGVxBpwoioJtZ/CGNAqrfZiSRuGYciL7hrANk1Ctj54NvcgOFZFOg2bjK/dx5NfGMO8bMwGonKbir/DSvS1CX6uObQkSkTS1kzz07xg6IDS/ncK6g17LvlIvC78zm6aXWgk1BJl64QSe+e91AEiSRLhbz4vMfwP/UUIzwD333MMXvvAFqqqqUBSF6dOnc+w5x7Jxw0Yu2HYB/Xo/5c5yat21H/dU8+TJkydPnjx58vyHsWXLFo477jiCwSCtra1ceumlhEIhHn/8cdra2rj77rs/7inmyfPhkTUY892Ppm/n24QEWXtXm4h/KJu+BrHNgAB9ACKbDhWaPTUw/bbD2/U+B81/yJVLFsHobx04tZzn2UjuKdtn+TMTE8VUb/sdZIcg1QyBiVT3eAhOk4lquVDHKuoBiDLMTfyYN0e9Qr86yB93eZi5zUvVUZ+jyu/JCfAASCC9g2fze/AEf+L5+MO8+puV2D0KOz81hpkLJvD/lNsPr9z1CCT24vdOZVtwL13OGDFfAZsriqlmE9U08Pvft7Niwz4GFj3C3qM34ZucQLZlcAhkRSGxUcLYrKH5VDL9UNYznkW/Xcgz/rvYfmcbkUdzl3n09/w8PjOCmc2gJmWEaqD3mqSakph3S5R9X2CpIFkqL9UImnpPJNOzHWdBMzjDePssxoThLcnD8jodu9TJ4JbvI7QS7Lf8zD77aWrjWbZ4YE4/TIrG8YRm8otoIUJL4ajbRzqpoj76Y645oRFfRZiLdnyXpe5fIcWK8HR6KJzwHDMmjGdB8tP86p4hhtdORPbGmemt47KfDXCP9HMkZI4c/Cx7emOor9fgaplN/3CW4n0ToehN+octzio8h63D69izq4n2tQnCX9gJfotBevk132UOR1PPWHSynMC5FFN+4JKUNgYpbcwJa7M5+pDLJRDcwbVsZAU+glzBzymlCoE4TLjeuCvLrY/G8LhkvnlhkBFlH0xKOma2m5WbM5gWzJ3sxO893CZD8+T6sozcupaUnG2CmbVxvG0fY+7Xp7G6/xmsTJKZS3qhP8bM6k/Dgpmw4OLD+p11wSjKxhZgZizqjijhjegb6CVJSuwAw44EA6PaqIyPI5zNsPPkt9BL+6lMRehp7CHpg+TcXfhcHsKrjkOaMYFX+yYTDUdJKBrYkNrTyrYHtjPnm1NYFnLnYu5tCxMNCRsLFVWxUCSTLF5MoWJZClJEMOu6M9l3wSpqnbU0ljXQ3TGEpdsomGheF7Ilk3aYBJQY09u6cAedyE4H47RuuoMFxMIayaHpSELdb1ptY0ngGlWBS4LCIpvCugDHnzIL5zdfIro+gX9giKxlYeHAlRxk+1MyMytCmKkM4UwBtq0wmFIRkopplyDZOgoedjgXoOkWwaCJbcvIwsITdCNJEqmhNCtv3k7v9jCSQ9Chm0QknU2JISYUaPiKXYTbEygOCcWpIskSgSDITgfJAQtbN0h3DtK1vpeR88uJdqVQPRoiHsMT0hjYmUHzaQxN6KBtbjOjgvWEGuccuMZOv8aS3x7L0l9vRVrWy8DOYcyMhRAwYlbFB1qjtUdWUXvkwU38EdOL6NmeSzpZNa3o3ZrleQ/+44TmkSNH8sYbb5BIJFjWtYw/6X/ilStfIVuaRRc6Y7xjUKTDdwPz5MmTJ0+ePHny5PmoufLKK7n44ou59tpr8fv9B46fdNJJfOYzn/kYZ5YnzyeU0uNzkbTJZig9FrSPOPrMNiHdSc5L1cqN/UE9pgeXH1p+m9D810iplv3P0KdAWMTjcXwBja9lvs56bYBaGpnADDKkuY5vsZalpItTuJIOdmYtZmcup2rqhWDrufkmmsCMwtYroWgBNHzlfS1GUiTYwiqaHugisdrERmfzjS0smHl0zm/ir7Ey+ycvU0M9907ykyCCImxGMRGBYItYQ2fdHnwnr0JSbWRJodbViMfj5hQu4M3fvkxPrIOmqyIEhws5e84pnNufoKTLyZcezVmwSFmIPB5laGY/PpIEtRjVCYnpLsEffy4RLlZID8i4Q4KO589j57YjMJzVuHGjlq9Dz2Zp3Qy/t9O4Tszg9tpk9npB9uAcrSNZWRJp6AoIxkbhnDYQkkVJU5Ti1eexOVmKb8GrVJVDx4Y6fme20vrZS+hULbBltPFr0OPFuPDQyh7kwS0Ub/sv5KSGGYMzzvHzinQzAkEibfDI7o2EHvwl+pCJWWBTXqxQvPZSRGQm8yZ5+PrIo/nCt7+Ab0AhNr+TeEcS93gFAx0FhZW8xHbW4ydIC7v4Ph/McqmPrgObGwmiPMjNtLEHG4sLuYKZb4t8vv7uKNGEDVjc9miMH3/1g91nM8Y7ueUHJYRjFo2177zJ0XhsJeGOJO1rBxjcG8PhVpl2bj3uoHZIPV+pl2OvLILB7fsPTH/f8WtmFB8o17vrUSUVb7GLbNikLF3JzHMbmN/gYVX/H/B5ggQmjaDF2UxDSwnmcDsxbYDnpt+F11/O4jcuordQwh5IUjmcwmHbBEMyEwt8fLVKYodjF91KOS3mRMqldmQs+rRJ1NUKUgmJ7k6BaeSEdtewn9F3zsdztEX5bB+RvVEykQyqKrAsm0CRm7paP5OOmswodSNO0mRiBuUXnkD0NQ+tr7aQUSSy2VziQEmSkHweXEVuFn59PO6gRrHZTuriT3PUygSvpk5FsVI40NDIYAiVRMbB67/diSIUDKGBJGEaEk7DRtggJBVZmNi6xVzfmyQra9k2NBIjmcHKWvTvGuKpr79KNm4gaSrZlIXmhpLhMLFsEu/8elL9GWzDJJuwkRC4NR1HuQdfuZdwSxzbFiQHkjzzrWWcedsJVE0JkY5k0TRB79YBhvdFGLYiLDv7JSQ3dLtbSd+eZfFTJxL5ZhcxZ4wzS85k8tn1tG8YpnR8Ed6Qxqm/mElhdeBdVsV7M/3cBoob/GSTJg3zDo+IzvP+/McJzRkrw9LIUu7rvY+tia1Ew1Hiq+KMv2I8lc7K9+8gT548efLkyZMnT56PiLVr13LLLbccdryqqore3t6PYUZ58nzCkSSoPP2fN56sQvkp0Hp7TggOToSSYz5Y28CEnIUIgH/8IacWcBJt7KGNJmaykHX+dtJqKxWqlxsf0lm9dy9VZQP8/LflnBo48UC7AXqIWF0E5CApaYiCWp0ltfO5dP7n989Xg1GXQ+/z0LxfgOx7HornQ3AyABYWu9mMnwKqyfnEv8JjPMmd9NGFUZDGhRePrOAXJZwrvswrPEa/tQ/VzBLTJMKvGbQ90smEojRfWlJMYMSnuGrI4NnkTxh2ZOnW7kAu/SKlX3kB/x3lSG4DbcQglidLEJn/Tv+UW923Enb1YbrSfPNPX+HC9BV4O/8P+tZwjFpOeVErRrdNSSrLfEuQ7u+ixwPelES/S/BqNeATBC0ZpbORxJMnkX1tPj63jdPy4TtyBYonSuahEMlXIhR8rwDFN4gkgathAO/ctaTWzUVxpCgd2UrQhKqkhCxAlVwMepoYseAVOl76OpmlZxFy5ITOXcUbaVp5Bo7S58EyEbaErNh0DwgKnT7k6n0EJu7GvWMa2pRV6Eu2kyTnW5xMC+RoTswqL1I59+u7sGu3M7huEg3ZRSxesD/poJqTbrQ+H4VyCQFcDDNAIcV00XLA9mKIvndceq+uTtPcabBoppvR+wVfP0Ek3UXzQBwhQC/djKblNh+e4E+HCM1v35P4sBbopSGF0tC7B/PJssTcLzQy9wuNAFimjaK+S4LAUd8AX2Pu3is/+V37jA+k2fZ0B54CjYmn1aCoMnXuOn428mdsjG+kum48L47xccdAkrHX7+To+pNYOuUpzE6ZihkVXPBKB616mKVTbXzBHuLjFPrX7GRurI4yfxeqHSE+ZQK/dti4f/0AX3/idiYRptaWWSWdgCYyCLeXcrWb4SM+Q5lcSce9e8GwAEgVRHnzvx5GLrfY4i7ntAln0PdGAistsBWFbDiF1OCnZHwJ6dH/jXt4G6Vjqlm+NkT78vWYCYtEkcmORRKmJtGwwaag3cPepb00L+/DW+yiUuvkBG8Sn9HPyeo9tLimUJhpZbM9j35RjWntjyQXKjkfeZAEqE4ZYQgkXUfBolpqosgTZek6N7YngWXYOFwqmUiWdDiDpMiQNXH4nFiGjpS2KXiph85VYZIxFTN78Lo43eAr89GyOYVuKMjCIBG2SW1K8tg3VzNyboi+dR1Ee1NkhrMYGQuHQ8XlcGG5TLIxnf70AA/03M/u57fhKnDyou8Vnj/zGc67eR7xvjQlowOoWm69rb57D1vu34WvyMGx359N6dgPFqFcM7PkA9XL8878xwjNcTPO/3X+Hw888wAJM0GqMkXRQBFDvx3CX+en+vS/M9Nxnjx58uTJkydPnjx/Jy6Xi1gsdtjx3bt3U1KS/+KTJ8/HxsDrkOmD0uNg4s+geCFk+3NR1Kr3g/VRfUHOVsNMHCZOO9D4PFcB8Ai3scz5Jj3VLow9KVb1T0GSdtPVF+fVu7/MOZffcyCxYHnTI5T79mB5kzi8CovteuYhiCuvE5AWHxxAPjQ6FNmJOTjI8L33cvecF2mZIZA1jQu5gjkcw7P8GYGghEpqljRyfksXR/paKK8K0cqTPGE+TjS9hW4tQWVfGbt9GUL6RNo2exhzzGUcU3UMqZ0Xs7ZsCF2yeMN5M3PR8ddHmXxFmH4XZL0mCItOq4lrrPMpSJTS74siBPxpW5I13UmmmeV8tVDCYwqWXK6x/fk4U2yF4xdKvJZK0qNJdPoFEQ1UG4QEI5QKmguHiGbT6FoEoXvQ3AlqKi1c0jg8XxS0V3UyPK4XsV80lVSL0JkP4hndhKumA2+Zn8ZOlSFNYVeBQWMsy9aQxBpnD/LYDcwf6yI93IkrVU62wEO6YySUhPDUbMQhS2Tb6skMBelaO5+Ky5dz8ZcGqYnGuC1wB/tkgYnBWKYyw1nPi6uPJ2YLHLV7WFF3PQ4NpHkvYjKSV9nLCBr42re/wt233IumaRxTdAQpIkhIJIkToIBXeAwTg1O4gJ1sxMZmPNORkHh9bZob/xwF4OVVaW77YQlBv4wXP/JD3ybhehklXMXA5O1UzdkNQIBDLWi+dVGQWx+N43FLXHrW3xYp+n7sNnbTb/czS5uFguudK8naB9pYevb764l2pwDIxHTmXJwTscd5xzHOO45fbm/l8Y4eItEM6aE40+0JXNY5hYmn1DAUamK49SuEUJBGgammc8M6QqguB0OuyRz/f0fxwz9sYHsixZHbdtKdzlIiKahk8RGnRZrIBH0dDinL7hURCDnwFDlxuC3SEZ2BiW2YgSwuVSOiDTNQ3YevrIhYVwLVTCALicQenXV/SKE6VdyhYiaPbmT5TcsRyRSKlWXT0Sr91QAShR0ahe1gZCyQwOhMIhwye0MlFMt9ZIWXZm0msmc68awPI+0AUyArEghwOMFMm9hCITmsIysuZFmlqijCZHs7w/GRWLaMJIFt2Qw3RxCmDVLOuUOSJfwFGnZXBsOSQVdJmxZ6FgQqORd2iXTUpGX1IOmMiqQ4kUwb05QpGeFDAjb9eSepvgTZWBZZsnGGvJTXlnFW4Cye8j6B2qoxcu0Ethy/Fj2hY2ZNkv0pXvjfpWhZJ2bGZOYlkykdV0TbmgHe/M1Gkp0RANIDSS568oxDfL/zfDT827/Dg/ogD/Q9wGMDj9GV6SIdTTPwhwH0fp1wMEz5seWM/fpYZMe77Jh93CgKnHzywXKePHny5MmTJ0+ef1tOP/10rrnmGh566CEg9zhse3s7V199NWefffbHPLs8ef5D6XkaWm7Nlftfhmm3QPmJ793mnZCknED9PsSJcPyefdQNh7Fsm3SDxYrNOVGnOCAhwutI+crxZDM4BpbzraHxvBXczVDQwC97sQpAUg4Vls3Co3hxwypEbAdGcB6nzWmk/2f/TWzXFrYfuQGlOYBr7Fg28iY1jEIgDiSZm+qaxYULUiByXr8DnS+ih+Ksv+5T9HcH6T1uDdqE9dg+A/rBMHIJ4MK+QgSCdleKlAM22yto3B5Aai1gePjLSItvRypqAQS6ZFAXl9jlg0zfRAaGClHLb2JHfwWNw428NOtWlpdkcE6UGYhYvJyRaA6oDLlsTAmctsCSQJZU2u1Bxg94GF/zLE/2OdnXO5aKhZ14xjTRTxdOXJx//hdZ37+Kt8wXQLFzvsTeJN45ywGJEvksXq+LkCXD0soYttCxSONItkHJ7bRGR5GevIegw0vSEcbnnEJm/Sj0SJKismGGUj6slz4DZAl0T+ekovPYXbAZCUGcCAY6E5jN8d6zmHlJhG899BbJwlbinTpj6zSScoRtrCFIiE6aCTd2cv311x96TW2TB/oeYFu2k88Vf5/RvlG8zKP8nh8CsJBTOJcv09FrHmiTzgoGIxZBf07/yLY2EOj/IgAFw/OYNecZLExO47OHjDV1rJOb/t8/PlngX1iWWcav4r9CIBitjub6guuRPkDodDZpkBjIUDDCeyAK2jLtAyIzwHB78rB2GctiUNfBLdO2wE/1K0kKRwSZsKQaLV3Ly8OXM2XfE/gSEfaeNoPJjtOwkzn5zBXUiHYn8a/oYtpyHcnhQx4yUVSJrFZIn1FHtb0DSxj0qxqx9nbUfd1kKUW3NFSHRJ3UQIt3Na6gRll1IeXZcky9h5DYRze16LYXM6kT70lSWBckPZyhbWUPbjmDlOmnJVBCyiFhygItY+MfVHKbJiL3soUgoRUQ9Y9k7FkT6B0ayWZTZuPoJK5hmwXPK3ijOeE4WOYk1TlAVhiARNZyI2sakuxk0KpEPuZERhcMsS7jIxZXsbJZsHJ+2ggQskxBYxnFjYVIchcDnRaWbpFNG0iYSEhIsoIigyX5MLIgyaC6ZGTZjy+okhpMkwlnMKJJrFQGhEBIAgQoDoXLFnyRb42+nBdXvcma2HZGvzmJnvpOTL/OxPVT2ber40CSv+W/WsvZfzwRI2NiZa1D1oqe0P9moVkI8YHWZJ5/Y6E5Y2X4c9+febjvYZrTzbgVN9WuatxL3LDk457dh8Dlgmef/bhnkSdPnjx58uTJk+efwK9+9StOPvlkSktLSafTHHXUUfT29jJ37lz+93//9+OeXp48n3geaXmK+/c9RoWnjB9O+zal7n/AkwDJfQfL2X4wY6B4cr8r7xJ5+XaG3gQjCsWLQPW8b/UTOJdI+HdYSFQ6a7jo1EaQdtMwAmrnubmu9HnauY+R6kguVz0YZjfrXj6CPY5Sahr3si17BJeeNIUh+imiFIAVb8a4+cWTgJMAKJ8epWpoCIcpU9Hjpc+lA+DCzU/4ClkyDO4MMDm6mH0zt7PWsZk6vZgSKigyx/PmTT661lQhuQS9jx5DTVU7/uEiZs2bwzHH5KK1x1X9hJHJVrY7lqIpPhbv7aJheAuoLtalsrz0wqcQ51+PInRGJW0WaSPpE05aJReZxmcYSClYtYLvrj8NV4GbjJIkLQt2Fki02xpC1pDtBE7hoCDrpNtjocsWJVGTy3piYKeZP+cmbhsrYVWNxU8QDz5sbMoYwXXen/K7Xa1s19JsDyQRpf0IWSDZguU8yxHieFqGm9DdOsLpIi0lUNwZzGgRWdIINUtETuI0XRhtJbhGbkMOREmEelFaxqGiEihK8+WGs3GgMZZpgMQuNuPGwypeYQEn8Qvlawx8dhVIFmp/A8m0yghvPWEGDqyJIId7Ij828BgP9j8IwPr4ev40/k9sUVYdOL+F1ZzLlzl6lpsXV6aJJW0mj9aorTgoA114ip/r744AcPGx1RzFle+/nj8C1hnrEPvtG5rMJsJ2mJDy3j7Q0e4kT35nLemoTtnYAk792UwUh4yiyow/uZodz3WgOGTGnzTisLYn10nc0hYhpTuoa9Xxl7iRFYkN9zdz9JUTUUfXs2/nWFyrZUb2TCbREEQSFiX1bqpmlrPmtm3M2vU8GUuhQx3NnikXklSSxAsbsV/tYlgvIqlqhLIRXGYSWag4VANbVXF4NHz7Cvmf4LfprY4yzTONmks9vPXED9kjRmGiYQubVBLsrgwOrwNXsY9kxCARtclapUgZB5Nfttmy2MZ2mwR1nViJEy1p48jIKDaoTpXEjFMo+9UChjb0smPlCyhZhSQG7QsMLq2YQO/uBOG9gwjLxtIEQggwQNEkVKeKw62wWT6KVp+HC18dx5ZH9vHKf7+Bbdv73TYEtuolFbFoWjGIy+tGdesoUpJsJrfZ5VAEFRM8GLKHvh0RkEDzqYyeF6JmRog1d+8llbFwkEVPWUiSAwGYkozcmCF5hYFntBO36uaY/3ckbZuShDLVFN9cia2kCbp9+Bo9B4RgK5vbWKk/soyxSxrYdv92nF6FqeePxVv8/p+/f40QgmW/28HuV7opHuXn5B9Px+XX3r/h24i0x9j9XDP+Ci9jTx2FLP97C9b/lkJzR6aDq/dezfr4elRJpdZVi+uD/AMgT548efLkyZMnT56PkUAgwIoVK3jttdfYsGEDtm0zffp0jjvuuI97annyfOKJ6jHu2vMAAG3xDh5ueYqvjb/k7++4eBEMLgPbgMKZENkE+36XOzf6Sihe8O5tOx+G9rtz5YHXYNKv3ne4SmqpLLwMMbwKCQkmnc3Xj57Br6yv8aSzl35lHw2MZ5+yj60Tzsff+ybLMtXstAVSk58Ss4I28XmEZHFK5jhO0o/D7ao6ZAyPRyF04YX033ADFz4wkY4fLKCMefyZ37GddUSem074D8fTShGuWaVY3xrJ9M5uTnAcwzPPg/acgdzlImvpFE8PMH3GNH54ws+oZfSBMRyyj3L/cZTQTr/dRaZ/GDUhYbh0qsYvZ27XWKbGv87yphTjPWnGyEu5bpODbQUKXxo5hO5WkMJFRI09+OLl4BoCSRDXICEMbMtE0n14dBfl7gAeOY1KhnLLRFbi4MsCEqWywjjOYC2vo6LiwoOfArq9ArnKQ4MxxE5XBvMvCR5lMDHo7uzC/N8ylEUmkaoUdmAcw0sXIKUCBM94EKesI1mQNkwkp44SiIGQsGXBl+dNQ6mGZNM0nn+oHGNOlrHjdXpow4kLnSwv8TDbWEtLWRN2FrAcCF+YS41fMIdpbOJNNrCCkYxnGvMOuX67W3XuX9dOZ8CkskQlTZqUlWKMMoV+ugAYwxQAqstVbv1hMXvjXRQX6ahvE3DnT3Mxe2LOI1pzfEDxy9ChsxmKyiFQ8MHavA/THNN4PfM6AA1qAwXy+/e7d1kv6Whug6RvV4T+pigV43OWHwu+Mo5Jp9WgeVU8BYdHYv/J/BWTZ/YxMFhDsTmWEa4RSJZOrDeNJEtEWuJsi81AIME+iRFFSTJZhUhPlqa3Ivh2rWCSuZtmexwBO4LbqiZdWoFDUyj3DpGyJeKUUyZ3Mt7xJu32LAwtidPnZnjAQI+aSN96naqqGta6Quy1uojoVWRxIwEWLizbgZVSaNuSwF2qsmPpHixDQrLBnTXw9Nocfa+EVT1ASdiixV+HZDlIFtuEoiqFI7yUjg2y5q4mlAKVutdgyGvT3whFHgfb791McFQJkV6dmNskXmBjOiVQYVRYQ1YVbNOic10fAwGNgaYYqWgWS9aQsRCSQHY4EJqciyCXJbCduIJuLNUimzWRJEHWKbH1dJk5vhISN+beX5dPRdYk1t7fymC7DraNLZs4VIuspYGiIGrjbPnVMnDZmF1prqq9ikC5h2O+M43tz7Qz8bR6vD6L3U/vRdiQHEhROr6YI746FQBFlTn1F0dw8k9nY6ZNnB9SHP4L/Xui7Ho5d08NNMXY+WIX086p/8DtTd3ipf9eRmb/WrVNm4lnj/mb5vKvwr+V0DxkDPHb9t/yavhV+vV+qlxV+JR3SoebJ0+ePHny5MmTJ88ng1AoxJ49eyguLuYLX/gCv/nNbzjmmGMORAXmyZPng+GQVTRFQ7dyX+i9HyB6+ANRMDVnl6EP5RKRbfwSiP12BB1/fm+hObb9YDm+G2wzl1Dw/Wi8Gml4Fag+KJjKdl5nAAUVP3Ga6aSZGkbi9U6mYuTpOM6+DC29BwUHWlkGIVdBpp9XEr/kpD2vMKfsRM4//yw2bowxe3aQKVP8wEI8RxyBJEmMdzgIM0gvHWimYM5OnWz1SjZ0TqZrbQGDLi+vjxnL8XwRxfkgFSUtpJNeBnWLUV/bweTi0YeIzAAGOq913Yq3tx/SGV6Pq4wezqBWGWyszfDS3D9wx8s3omXcbErIFBQOc7xjGdl0HMtloWS9SH6LxJpZzD2imk0lN6NEunGbFnGc9HrBMhVSis0OuQ+F3KP/zUUazSGZkVHBgEdhR7EPnVXEiZAiydGcxlEs4T5+x2OhrZiY2MIGSwJbRgAhs4Z0MktmkoFlQvT2MtIFl2EYMhIgvXoSI098Am9JP2lLMDxQBqOakDQD1Z3lBOfJtAyN5vcvx4AMq7dm+PEP0rgLc37eGVJoOOmhFUvNIMkC1ZBxVnbxgOMn7GMRF/FNNFw4/8qvOKsLfvSHMHFxNIPj1iAR59Lxp1GilXAuX2YUE7Gxmc78A23Wu5/nYfctCATzOZkT+BSFFAPvLzD/xUIld1EN+M33oHUPuD3wjV/AiA8uur0bR7uOpkQuoc/uY642F1l6f2vTwpqc1mObNuGWKC9dvZTxp41k1hdzSS575W5+f9+dZENJvjx7CaPuXoFIpeg++1y2+oM4/cNUlu9l5PQYM265B0kShE6+knjfJLq7VCRZQggJS8hYlky4LU4mZmCZNlWWikBQSidJuYDkUJbxF9Sw9oFOJM2Dy2sTTZfToU1DC5UwTotQcN6R3PnzDJKVAWzW9E6gIJwgIvcQdlr4TBknaTLImKhIsoywwTAkjL4MtpmLInZLGdxSjLTkQZOSyO0KMbsUKSCwnOCJA7bNcEuUjXdvRXU5yWQkGpMwoMiU9Mgs7t9IfXQ58g4nGf14XltShGJIRCskqouj/Nepi9nw7CBLb9iKkYBEf4pMJIsishioCJ+XQIGTgiIHgzsHkCQ3CDCTOu5qD4WjC2laPohhgemQiYYUXpo6zE8fWMCrP9xM++o+BvcM5yKo//J5KCuEatwkB1M4AhodxQbB++tJT+9mr6+FiBSjoCbApFNrmHRqDQBv/HI1mjcnIGseB6f+7licvkMF5Wh3ipaVfRSPDFA768M/4eL0OZAkKTdXwOV3fKj2Q01hIh1xnH4NSZKIdiY+9Bz+1fi3EJqHjWFu67qN18Kv0Zxuxqf4aHA34JA/3AL4RJJMQmnucSf6+8H7ARNN5MmTJ0+ePHny5PmXQNd1YrEYxcXF3HXXXfzyl7/E7/d/3NPKk+dfDo/q4eopl/NY67OUuUs4r+GMD9eBlYbOB3M/qz4FzuKD55wluRfQ3OUh3ZfA41aomVzMe2bSKZ4PkfW5cuiIDyYyQ65e8UGhsIwRSEgMM4CBzjB91DCK0UwE4JiR9QQzwwhLJuppQ9gGUnIvZQkrl3xw4HU+85mv8ZkTmiG+EhLzwTcaWTsoyrjxUs4ITm9qpqxuC2mlm1GBMPcyGo/i4kK+iRc/n/70pxkaGqJ+1ACdS3bgWNzNdvp5KfsMsWWLAFiywM36zktpLdmG3gix7TID6938ukJBLbLoqXaipwMksk58uNEVB+2ZCewpeIakbGKpoAgdOeWl/v9dh10+hfmDozl1dQe/nwFpScI57CcdyCC0NLZiU5SRKM9I+D3jWT3Bz5PmNnpJo6SrWS+tQVEN/BTQyh62s46X+54i7c6CQyC7QBhuRMwHfaVk1RImuktZM2cZtm1TNtpB8x89SEoWSbWQZJuKsk4kVGolGfeCZbRrBo5AnBOHL2dMxRTWhOMH3lvDBJKFuArdOHCg4UICkiQopARDzhJwFlJAMRGG+CO/5BnuJUmcJHFmsIBfch8ONDJZQTItcFPFlI03coSWgRH38mO+xPGczZG8LQnkfpbxHAJBL53czs94kxe4iCuYzdHvuQxf5XGe4E78BPkK/0N1t5UTmQHSKdi44h8iNANM1CYycf96JjwIz9wDSHDaZyF4MAq7I5nhruZunAUyx35jPPse2YeSiSMJwY4nm+gY7ydSrLHpB8+R7vUAHrbe90NqRRExw2T7ll0Y3/wvuvd0c/Tm3ZwwsBNrvkZHQYaiLY/h+sLphCZVEg+3Y6Qtyup8jDpmBP3dO0iZcdSUk24xim55DKPtDdS6u7GK+tm2sho9YxPOlKJkXKRQSduVRLqDBCfVo632o0otSOiAIIuHIcOFYcuQNtHQ0MgQIExW8WNKCpYpkBUZy7AQ+/2XTaEyQ7xBodXLZhYwRDkmGs6YE1EA7oSBYmVBh8FmJy5PAsOKY3hNypKCsbsCjLRX4/AqZBNpRmbexJleQteYnI385EQXa//nGXb3V5CJ6liWhKyA1xsnJQSrzynElZRwjw9wethFz64kigrCBtkhUVAs4XKBv1AmFtGxFUHFj2IMj4zyvG8FxpCKlTX3C7cCCRtZUyms0qiaWshQl45WFMBKORh6yiS9VKEkVs7jjS9y6m+PpbgxRNf6XrY/1kS8J4GRNciEs/jLvWjeQzXAVCTLU99ZQzaZ2xg88YfTPrTYXFDlZdE3J7Dn1W5KRgcZc3zV+zfaT+e6Xl7/6VskB9LEuxNUziij8cR/zP3ySeZfWmhOWknu7L6TxwcepzXTikNyUOeuwyX/m9lkpFLvXydPnjx58uTJkyfPvyRz587ljDPOYMaMGQghuPzyy3G73e9Y94477vgnzy5Pnn8tZpVMZ1bJ9L+tcfMfYCD3+D7xXTDlN4dV6enJ8v27zmRRg4aNzAj3RSyZ9B59lh4HnvqcR3PBlL9tXkAto/kyP+J7XIgTNyoqTWwlRRIPXmawkN2uzQAcyfmM6NtFdtjDsR0ZsPZA7cUwvBp2/yLXYd9zMPVmcBYdGMOFm6/yY4zkuTjKWxhw9zKtIU774jhz+SxTmQuAz+djydnf5Mu3bGbHMzspiq2g9pwXeOSBNk6P/RdOOc3TXUtYe9KLVEcUht02Gdume2WCwWKFouNkPAp4vEkKy/Zi9s1E9VQwonwHXarCdp/M+LCgKSRTUuRHPOflrX1bGNHYz2KHRDxWSHPzLKyMC7m6A09tN46CXhRbYv5AkJi3l5aKIIqoRU8Pg5TGlGIgdBJSlF7a2cE69t5RTLb0AgLHL8VR0QMDBSjtJai3nUZZxzDrrnqS4nHFlJWV4XK6mRJO8coLPkzfEGWnvEyrxyBgmLjlQmoD07Czg/iFIFOxkzu4jtXzNtO9/hyKh6Zy3PQC9lQ9ihM39YxjD1uwsXAACipX8WskJB7mFtbxBhYWYQYBgQONTbzFGl5nHicQ9MucvsjDk0tTFPhUQoveZDWvouHkfv6PicwmQMEh62cE9fTSzhB9ePEhsFnB8+8pNBsYPMGfEAhihHmBB7i06Ovg8UFqf1Rm9ci/eU2/J3deB/t25MrRIfj6Tw6c+vn2VjpSGQAyZQHOOaWKtV1DAPRldJ7o7sMeVMloA7R88XkcWSfTHjdAhoRpodo2ao+GP11KTTbA1vAm/vyZHZiKoFSLc7Mzy+nXzub+y9OsYjXdtoJn0E1XQROBiAtJS2BoXpqlOdRk9iJ5NIrVGP7tr2H11mPE3KiKiW5KJHUZVc1iGRZG2iJW0ocr6sCR1BASKH4PZtzAkBV8jn4a2YgrI4io1aiuDL3RAgQyQuQS6CkKWJabrc7jcGeGaLVGYuJGIKFaMHZCCe1LW8il6hNIlk5WjtM2UcHRX0gmYFEnukh2h9Ai3SAEEVHCzGdVSvcZ+AadlBqlbPc5SDsshJCQsZGRUFxOTDPLiO1pBib7QZJo3xbBXeIlNZBG9ckEqguJdiQQpQ4UYeASWcyIG4ewKN6pEPFlcLhVbCEhIVDR0TSZiWdUECj34i/3UnOsn+3PdlKQDeD1VJLuDWJmoG1jlFeu3cyZv5nH0p+vxspaCASpgXTOm1m32f54ExPPajywVqLdKbJJE2ELkCQG98b+pqjmxqMraTy68kO3a13eibAERSMLMDMmJ123iILqwIfu51+Nf1mheWVkJde2Xcuu1C6cspOR7pFo8t/muZInT548efLkyZMnz8fFvffeyw033MC+fftyj1VGo2QymY97Wnny/OeR6QHAFCZyuovDHt6P7cTbfAunjU/yzM7ziGZCXDD9A4gGvn+MGDeBGcxgIa/xBAABQhjogJcjWUw1I0kSp5HJyJGfQzgMWk6sZMx/Q8/TBzuzMpDtPURoBqhnDJRdjdH+W8zgHlbXqbg0P1MGekjIv8UV+iyqVMDTy1LEszoqKkPL5lO65AUWmGsocfYAAtm+GdOOY2qCorTFNA8UnQvNZTaj0hqZvjEky+YSPFKwMfoEza6V/EE2OHGHk5O0K3kAAQAASURBVDHxBFtLBEUJibZkM733SZjDgl1LZbI/h0zzWNKPno1tyfhmv0aRq4NCp5tT2yUmRyVSkQTLypvoUnrRnRKSYiDJxoH/R4FggB5SzReQaW3ENa4FNRTGHepHiVo0RvawWHqOt8JuNjfFqK9tYI50LJ4TbeQTbqVXygm2KgUklAytZCjNDmCHmil1N7Cd9azmNQoKi5j9gwgzsydxiftrPIiOhISMTIY0Lty4cDCVuZzApxAI9rKNdbyBgoLJwTlbmLg4aAXzxbMCnH+SD8Vh8Q31XlrYhYxMPWMPJNV7OxdwOZXUIRDY+2XICmrfc72pqHjwkyQGgJ8C8AXgymth/TIYMRKmHIFtC7Y+tItoR5zGE+spn/QPSMAZGTqsrK9ZQ+quu5jXFGelcSyJ4hCRL9XTeNJ4op1x9r7cRsbrRA3rZEY52XXeUvzmMA6/zrpvTuPUJ0ooGMqwcsGJABRkBBVxwfJJdeiFLaiaTHhEJS3pFgri5Twy6y66GvYhnDav+v/M7H3zcIarkCwJxTJIRUPYyCAERtYiEbGIJ1QEObsLGRmw8VuDSIVT2VOxlWUnPcmUx2eimCqF6Wq0wQoyIZnl56ks7EiT7CwnunURyWwhTtvAo+mkTGfO0kWAMA0ccpawGSIqPFSzm3YmYKGCqlAxtYz+jV2kh7P7V4HEnqMN3jpWwx1O4kuYaGtLWRM5k7LhZaQsD01MRZgyVds0nFIG1RVnKOUjSRJbyCgKoEgYcR0ZjeI9BqHmKPpoE7Mrg2KBM+gkWBvE5XMQ78oS78vgL3eTiWWQbRuBDBmbhA5uv43TaWOaEpLqYuLpVQjdZHhvhOG9ERqOruaorzbiDGq8+as1tA1lyCYNjJRg27M9VE1vwspaAAhLYBk2ofoCAAZ3DR9YNsnBFJF9w1jpLD3bwqgOCfdXDrX3eS8ysSzr79iKkTaZesF4CmoO/ay3TJvW5Z2oToWauZVI0uEWNCVjQzS/1g5AYX0Qf8V/hrXvv5zQvCy8jLt67mJbchs92R4aPY24lXeO+MiTJ0+ePHny5MmT55NOWVkZv/hFLsqwvr6ee+65h6KiovdplSdPnn84VWfTtuFy+pJdrHCO5ZRIE2MK3iZM7PklAWmIeRMzyOpjbMp8kyVL/gGi2ofgv/gpWdIM0sdZXEIw1otIr+eldSPp7ndx4okjkCtkqL4Aks2guKDui6B6c17SvU+DEct5TftGY2HxIH+gmR3MYCEn8WmoPh9H6Ai6eIj17vv41Pa1uGJvIuFkqPYZSqqepqJYwYMPJ258gRina+cxo8JJorMHCwurOMo4Vwldu9txxsD9ElSOguNUQXTQwjXcRbtDxRmazK6C9cAwKQPGDDvocfkxzQwuySLbZyFVAGEZOyLRZRZh1rSRVbPoaRfm7UdQ9MJLlF0rUZ4yyEoyb1UV0bmnl8j2NI5xoDUKpL+Irwd+CIoWRuh7VUV1J7GGSqColcb2fk7RHyIyEUIuF9OeWMKlx3+WH/MlOmjClEzqaERBwcbGhYfB+z5L66r5ZF2DeK98CKM8ix0L0D3kJdE2gmMX5PSKEKXECNNLBw4cmBhoOJnFIgDSJJnIbEqpZED0oqDilnzYWAQoxMOhIpXXLdNLFxIyfoJkyTCaSQQpPGzdONBYzDnM5XiW8hRO3BzNae+51iQkvsKPeJ4HCBLiND6XO1FeDadccKDerqf3svnPOwHoWN3D2XecyHJjGY8NPEaVs4pv1nwTr/IhLUBP/Szce0MujHfJhQjbJn7ttdjpDCM3DaB7YJV+OtNXZVCOkwlNsMg+20dhykfFPS10XDGWETUmwXCCsGSw2ljB1y+Zz1eqv8Z3fMeypzfG4O076E3qBDrH0R/dSKDSxYiuKIXP3EVT5wTsAqh7cSqdc3eiFHYwZ0+EbNpBT8CDNhginvWwUj2RMZndZGomUVDmpnB1CktIxBMqhXKM6b41SC4XhYvm0VG0C9Nv8so3n0axFL4152es3B6g00yy19TpGZrP9GdTjNrlRbYEMX+K8tJu7F0T9i9aAbKMw6NgpHQcdooQA/SSRseNbchkhpOc/rujefqqN0kOGWSneumcIDFybYbhMhlTUxgzWEHSktgojspFSiugOmS0bASXncQwJAJSP8X1Gl2DHpKuAZTCLANIOPaUopgSsmLj3J3EVgBJxhdScHllBnYNYZuCwnIXdQtKSA2mMbpS2OREWGErGGYAf4kXhxHDU+Rm/KkNvPGL1TiDGprHwab7dqKou7EtQePJ9cT704SHEyhuJ+mYzrL/28nRXxtF8ystBKoClE0qoW/bINlolsL6IABNL7fy2o9XojgVoruGKakO4As5aX29lfGnvLN1hZ4yaHqxBYfbwajFdaz+wybaVuSSAIZbopx56wmH1F9x/doD58efOZqZXzj80ZYxJzXgCjpJ9CVpWFSDor6/9/i/A/8yQnO/3s8N7TfwWvg1ujJdVLuqmeyb/I67Bnny5MmTJ0+ePHny/CvS0tLysY5/0003cd1119HT08OECRO48cYbWbDgPRKd5cnzSSK7PwrS+bdt1GQCU/m2WYvirCEpaehtz3F1wTcOVrBzSQarR7ionhDi3AkfPDruQ5EdhI77cgpQzYXgCB44FaKEn3F37pehlbD7u/T0ZLB2BXly9bdZtizMbbeNR/XWwYw/Hjp3R0EuqWG2n+2ZFDds/i+aS99Cq0hSJ4+mlw7GMo16xmB4XDwlbsFpJqiMhYkiU2grqLF2zKo+ak7ejiwtJVS8i4njLT4n30rpMQqvrriP5weL6K/YzGme+xmxXea22y0GoqA54HuXOimb5gNkujOrqOZIZGQ8iQCD9LHd7WKSkcEnZxnygKMWzCEQssA9S0JMSiLLCYqv+gnZNxooqWpF9adolVXunDGeTrsJMzNMz88y+D5rYyfAGgC5Ag4J9E37+PaCk7knFaYnEcRULYbaFrF7zEZSP45SUgFL1s1k7o9/zF2dj/Hm3Z/GMCB03j20jd1LPWO4mKtIxGX+e5UfGUFNZiqhdRrBxQY72gWW0Im/cSySdBwrj3qZR/kj+9iBiYGOjoaGjIdqRpEkzi+5gmH6sV76NK6UjCteQdWpr5Ap6KCECu7gl1zL/Ugc1EAKKaGIUtT90s5xnP2eS8tPkFO56AMvxToa+Qo/xBY6CbGcJD688pxD6iQH0gfKVtaiL9zH7yK/QyDozHbycN/DXFx58QceE4CZC2FKzqoFhwMsC4RAAtqzYxjIjqfaZVPhcZIVzbR13oIuilBVlcn+CXy+ugq6F3Gn1cebjjAj4g5Esc4DfQ9wUvFJFNcVw08X8tBX36Shw8PZyy9DcbzGp+L9MLAV54ZlTCo8keGQRUFrKXUzexlds5nutgkUh6toE0UYGkSD41gtxuJvciFJAl9JP0GvTnBSDQXr1pFIauxL12P9cR1NF20mVdFLMFbEJGUS0z1HsbxoC0W2F6U3woyWHZy/fjedmTnElADObAJ/apjWih48QyEcugNJsoiUx3G0upGFwm4xA/EXl3jTZMtdm9jz2DaKpgeomhkk1psg8XQMNaNgIlE2s5Lx82oYbI6RjmRz3sVCYGUNdOHAwkfWcDLb+ybREWMZrkwSTfWCcCJ2FWOqOug5JwHJAD1j4y1USCdspi0so39rH0I3kXFhmza+ci+xrgQSf3FjBiudIevxc8Ivj2XkvFKe//ZSHG6VoaYIDo+KLEtkEwYIwYrr1+ErcaO6NLJpE1mVsQybzh0pLnz8zNyas2wev/RFjLTB5vt3kg6n2frQHgabwkiyhKLJyJaJqrnxFr97gtil/7uK3i0DAEQ7YmQi2QPn0m8r/4WezQNvK/e/a7+1R35wT+d/Fz7xQrMtbG7qvImH+x+mV+/Fq3iZ4p/ygbKQ5smTJ0+ePHny5MmT54Px4IMPcsUVV3DTTTcxb948brnlFk466SR27NhBTU3Nxz29PHnem55noeWWXLnhK+AfB4oHXKUfuAtN0XA6i4jqOauAUlfxoRVGXZ7zcVY8UPeFf9TMc8T3QN8L4K7OCciJXbnj+hCM++E7t4lsBATptEWxt4+AK8LgoINk0iIYfNv35chm2P1TsLJQ+1my5afy7VWfYW/FcmRHHDVlY/p0xjIVy05D262kpbcoqRKEVYmOoMy4sAlWAlMtRhVlPNjxG5KznkZ4wux2yNzGz/iy+A3/Fz8fU4NYeyO7/GH84kV2dvXgc0q4/GWsGijkBKmDiNvJ3pISPsVxxLoTbHh+F8a+Yh6uNNn2qRgpJ/R5cgHZ1Ve5kWIqoepCHEYUr54kWzpE37Qokk/GudmFr7iMzs4eEraFPCSjmhqQSwAm3qYRZdvqSCw/GqdboHumUNcns+lRB0a5huyLM2hdzMDJT/BEvB9P46VkJT+bHpmJ3rsVC5Oh+y4m8KMf09/l59rIw3xt6HbqM1l6hkw0v8qJ6hi0aDFtTaspbJmGa3A2espBL+10spc0SWxsVBwECVHPWNx42ccOhulHCGh+7gjK7XqcVinpkb2UH2lDphcrtRna/wvG/pDfh5/hqZ4VhKLj+f6kX9BV/CYV1DCJ2Qf+X01TYJgCt+vv1056rZ+SEhsBCImLCCnnHjg35uQGVv1pDwPNKUrHFqD6NYgcbPsXqw6A7du3c//99xMKhbjsssvw+d7DSsBxMLGbpCj4vvlNOn7zAD3+BjJyKZIAf7mbtNhGxTGDdL4cINMPldNlpkyvRG79LNN+v5ef1m9jdY0NDiflznIA+ncOsW9VG73BZjJ9KqXhSqY5GkgltrFrqBOp0EGg1w1xP/4iNwvbpuLIbGCq2opUU8r4z81k9yvdJAYz9GwNM5RIYFuCeGEBC395JCCxtDrL+sgqRt3vYPPMrewJpvD1BMErM/P/FtH2wk5KL9ToD+jMHUjyuVfXUpLN4HGuJmqWo43cy01Hw5B/K9WbxlO9YRzlZilDtpuA7cbY73Ns4MJGAQS2bWPFIrRvCxNLZwjGBigerCLpV/FmDSZ3RRhzUoBtT7VhpE2wbUCgkkZFR8VCwmZP4GiSOwWWSyAXy5iGiSwEpiuDmlKRkHPJ/1QZf6UXxSHTtyeOSMSxdYv+bSnqF48iHc5iw4GtEYGEJVTSEZ0nr1rL5JNLyUazeErcRDvjuIJOou0xbEsgbIFtWKQjWXxegexwY2Zs9GiawabwgbUxuGuIvS+1Yhk2/govLcu7UF0K6ayDTBr8xQ4mLKqhaGSQ6Z+deKBdOqrz+q+30bdzmNFHldG/66Bdy+CeMNM+N4Gl/7sKM2My85LDo5WrZ5ez79WcLUb1nIp3X8f/gXwihWZb2HRlu9iS2MJ9vfexMb4RTdZocDWgftAsvXny5MmTJ0+ePHny5PnA/PrXv+aSSy7hi1/8IgA33ngjL774In/4wx/4+c9//jHPLk+e96H7MQ6ErO7+WS56V5Jh9LdzlhHvh7CR997IzVoXG2SVlvJzOH/Upw6tEzoi9/o7EEKwZk0Uy4K5c4O5J3TNJOz4AVj7k8CbKSzJy3DMSaE28O5f2gtnQt+LlJRo7O4oIZopZMGCQrqD22ghzSTmoKBA1yM5T2aA9j9j6wkuSa5lSyLBI0USS7oE0/Uh6gorGWVthp6ncatZznAbrCqqJFzjpDQZBMVB8XAZspUlursBZuQivK2Eh7B7gJQhMPdfggA1qJGjuf0PTzKQ9jBkuBkKqBSeUsS+qSphNcsJ8hxClFDSWk/fEylsTBR09rrc6EEbh5DwWW4yhhMcEsqtFXxjscWmERl2FliU1oaYJS8iu1Dice+LJPQkalsQfddoHLXbSK9P4Z4BSig3Jyvloe/3VyJSPpJI3DDvBsyNXyEzOAEzraP4U9hpLzFT5QLbQ8on45BfY5xzHA2Mo529yKqE1V9BLCajySl+93gvkuRCkZxkdcHsCRrZknI8O49h9aslqJ5eUmXfoYp9JIjhwo2JiYaLGkYzk6OYwEwiDKHhQpcy+MqitK9wEw1nqDPOYNSEIZTsJs7uq0VKtbFy8H+4S3oTO+AmrHXyP+3djC+Okd03Gv8b9Rw5yUdpocI1t4ZJZwUXneLjU4v/dm9YIQQpsfnA72mxGTgoNBu6QCsMUDHVh6zK9LyQ5LLFl/FYf84645zScwCwbZuf/OQnJJNJADRN4+tf//qBfgabY7x58y4kWWL+V8cRqjl0zs758ymonIzrG6tw7T/mKXDilibjLpKZd9MerFgRo0oWM6CnWaqpVF3+U75hp3jAsRZTsjmv7DyiXXGeu/p1NvVvIZmNs3PxFk5pPRv3945jy8/uwjlosXyOh9aBbhrXzqDYH6Rw8RUMX3czpuKgv/Rkjplfjiuo8cZvdyCrMnrSQFEEVjzJQ19ahjPoIVuawt9cT9qMk3XkNj00y4MxKOjbp5Pc3cPErmKO/vk06iJbGUxEyaJT6jUwC9oZrgwwXJLCEg5a52zB0gxmJS8k/VoHNfZuZvIaEoItLGAvU1GwMHCiCzfSICgpk8Eyk8p+F85+QZoA+8JZune9TCbqB9NCRgAyqqwjyza2JSPJKoP9MhZpbBu07hKyBRGS9b2U7KvHVsG0QJYsVMkm1hFF0VREIoaZtbGFDAje/L9tIAQyCjYCgYSJBpKMsGyscISdT0bwhTS8xW4UTcFb7MZGYqg5kbsnVRnFqeD0KFTNCNK+OQ42eNzWgXXR9FIriqZgGTbxniRzvjKVbU+0gObE65EpGhOien49406sQvMc3LzY8GAzO59rI9Iep2VZNw0zfcgSIEHDMTWUTyzhvPuWYFviHS0vjvzGDGqOrELRZCqnlv0Nd9a/L58o1XZTfBOvhV/j+cHniVkxYmZuJ7lMK8Ov+j/m2X1MyDIcddTBcp48efLkyZMnT548/2B0XWf9+vVcffXVhxxfvHgxK1euPKx+Npslmz0YJhiLxT7yOebJ8564qyG7//Hl7EBOaBY29L34wYTm4dUw8Do+CRY6TBYWVYPyj082/6c/dfP4430AHH98EZdfXgtG9KDIDOieiXznuhHsiam4P93F+ZPu5FTnp3EekNf2E5oDk68nkOnhyJmTmfAZJztqnub33APANOZzCd8F59t8pCUVd8+jzHYXUzQ4hOoyOT6uUiuNpjLeDf5tADhMJ6PaxjOi8Apc6QgO636wyL3Pqo+TzIvofjVBcvYjhNRClnAh1QGVUxo8PNecojqg0fzAFoZ6nEiKhPcSncpFfvpn76GwdzrNd57LfdlSKuZsY+xsP2MLk+zrTiENuZjuOIpBfRfHt4aZ26Pxwus2d400sRe24h3QODHpZq4/gccYpr3kBe7xJjFtDVuxKA1lOSOTZFX2q2w5+X4iQy3Eb3bgrHPhnFWMSHtAyCBbpEUK72d+g/Kr72AkDcyMH8VpUI5GW0cFhQ1NCEUmpq3n2IajaDVUkmc/QocjhVGxE6ttPOkzrkGZuBaH7sX//JXsTM3lBf6H3ZHPII1vxZQstr9Rgz79OXwEGcVEnLg4h8tYxKkHbDCKKOVKcS2vDq6moHEkv3vGgSwLhppL8N5/DT+YOgC2TlwxuCv0BrrVj+2VsXuq2RnpRBpM0ZpuJ5CuY/W9R1FXqZLK5FT/e59LcPZxXmT5b7MdlSQJrzyHpP0WAF559iHnHW4VSZEOPHWueVWWFC9hSfGSQ+pZlkU6fdBmI5FIHHJ+6Y3bGWqJA7Dst9s541eHWnQAFDcEOOILjex5tZvSxiBjF1ehSDLV6m/JKvtwl07AtP18bcPLrB8OYwrBtxun8Y2GLx3oo72jm/Y9vcTUOMKycUZdtI9ooq91HPd8dzydfVHizSmmPSQRqHAz8oRK7n6oE0k6DbNUowEP7gKN1LBORTCKRzQRQyNl+bBMBTObxkhZqFEF1VJJBGDk1jk4Tw/Sa/dT+qd6HGEXttuge2iIZ65/gLmb36S/dxYO2UarqyVWM5MR0g5GbtpK2J9iqLabhsFGak8opOm1VhqlDcgiFyk+lnXsZQoSBoJcMkIhJJS0jCtWginljplCYyDpgiSADShI2KiyQeN33yC6ppJ0ewGZfj+pmA8h7JwMnXGj9QUJJBV8XoO0QyaTEmgijWxbOFEpHVVE9844lviLZiVhZAQCGRUVBQMJKKnWGOwD27SRMLAtE08FKJKP4jGF9GzqJxZV0bMqIKMABT6F0gnFDDUNUVSiEqj0UzEldHB9qiq20wu2QWmDhxmfn0TNkdU8esUqVJdKNq7z1u/WsfnODcy8ZBLjTz9oeZQazmBkcnOzLZtTbjwG1aVQWBs8sPYV9Z3vG0mSqJ6dj2R+Jz4RQnNHpoNbu27lxaEXGTaHcUpOChwF1Lhq0OR//B/3fyncbli69OOeRZ48efLkyZMnT55/YwYHB7Esi7KyQ6NyysrK6O3tPaz+z3/+c3784x//s6b3sWFZgt/8po1Nm+LMmRPkq1+tzueI+SgQAvpfBjMGpSeA428IMmr8NnQ9CkgwvArSHbnj3ndO/HQYf/29U3Z++Dl8ANatix4or1+/f4PGVQHFC2FwGTiCbIxfwr6kTvSyGxis6uCR2FaSJcN8jisP79A3GnyjKQAKiuBh1hw4tZ21uUL9pTm7DysB/gmw77fUeKsYISqY5pqMK7EO119E7NC8nEe0PoSj/LM4tJPZXrae9b4G6jMFLAh8i23SenqW/Jl5PQFm9zzCsZNK8JPzPv1y1XouLRpCLjuOM3/fxMiRI+lMt1Jwos342aMZpJu9OwqIthfSsVXjs8+EOWbEY8y6LItcZSBG2GRcUf6v7ULUwefIxHQmzd1MwWzBsCnx5HApV+9OUjcocGCyzx9HTjixvGk0JxRagtKUxpm+Fbz0y8txL/p/uGZKZDsM5Oc8uKJ+Uu4MSiCFd8wuzN4RCAEBrwN3KIuiZyhNGEQq9iGEQcqS8VRvJfTF+xl2R2kf3oDtjWENVGCX7cM5djOmCTjixM76KU8VjmGIHqTSNrx1m7BNBXQ3NjYefPwPt5EigYFOkjg+Ageu1+23BHlz40L6hg3Uut1YWoqM7sbpnwqNV0PXwwz4JVSXREVWprnZQ3LjDOLLjiUyfhdlxy8FcreT03HwcyoUkLFkg+d5hDgRjuVMSvhwAlm5/F2S0loUfLjliYecC5S5WXTFBHa91EVRvZ8Jp1S/Yx8Oh4PLLruMO+64g8LCQj7zmc8cct7SD1psWIb9180PMOXMOqacWXfIMU2qQpNyXri92ThvDe8jYWbQKOTu1ja+MWb8gbolY4uQsg4URSHpSTNcOURlSxV1BQ2YmVlEeAvhr6Z25Dx8ukbT691Yso2iyVgeGXVhEd4iFyMXlKHc9jIedyvd7gZaohX0ixFYikGWBIrwEZA9KLqCNeBk4S1HoKaGSGzcSYww2awLoy1Je4+b7uyJaFIcpynwDZQT2Lceb2YTXzeTrAgdi1RRysU3nMydF76CbEJKFFDIEAKJOAVI2NhoKBjYqNiSjCQEvpiXtKxhW3/9d0tCJhcVHBjZSdGsdopmtQOCxKM1rH/oDGwjlzTTQkaSJIpGFTDznCq2v9BD16YhpKwAJIRlYbW2kkmEsCQHsrCwUbBQkMlZc0gIFEWQHUwQKvIQHUohCwtFMejdaOPQLCzdRnLI6IaGhYSEjISFZVg0vdgCQqB5HTSeWM/Cqw5udvQ0ZZCcLiRUQhOrUDWFiklFLP7+NPYt76NvYzeyKYOAjffsOCA0Tz+vgRU3biShm2guGzNpUDImRJ6/n49VaH5u8DlW9axiZWwlYSOMT/ExxjMm77+cJ0+ePHny5MmT5z+GDxMNHAgE3r/S38Ffi6hCiHcUVr/3ve9x5ZUHRa9YLEZ19TuLC//KvPlmmNdfHwbghRcGmT07yKxZwfdpledD034PdD2cKw+thMm//vB9qD6o/VyuXHk69DyTO1Z+ygdrXzgDRnwawmuhYHouWvgjYMaMAPHsPpzuJJMb948hSdB4FdR+HlQ/hftMJHkPZtEgAE6XTL/oAOycHch7MJ4ZtLL7QBkAxQ31OUschIDkXhhagRyYSEHDFWDfAJENUDgLKk+FqjPANkFWGaCHW/kpltdkjRfcbOQ+fodOllSxzU1GFzfsKWVMkcJcdzun7t5KcSpDbNftaFqAwcFBRtWOwdOZpXNwmNDiANV9i9C7yulNOsHO8OruCWy6bj7Fv34Fp9tmQFrPLm0MR1pF7HRt4IHJgpg/9zYtK0iQ8EjM6NVY0mswtUXmDZ+L/gGbYlvmnLfqUA0HWVvFcu6FcoHIqjirZZQVZdAbwH3yOrQJe+i89b+wYwEClWEKfA7qJwxxtNNmdOZ2horD3K2OoU+TSR//Oss0hcSQIO4dBhm0qg6QwIwVIEkgaya6iNDSlyLmTKGd9ABSyoXk0PGM3YWKm0/zVdx4+R3fJ0mMIEV8lxsJUMCra9Lc/HAMIaBo4l5KTv4Tyc3TCZUlmXRuChxnQmgW1ehUcxWSW6Xpns+jbx2PwxvG6krj3D0PV9M8Jo/W+O7FQR56OUk0YXPuYh9PcSev8yQAO1jPNfzxkHVj24Jtj+wm1hmn8aQGSscdmlBTkhR80rvbxjQeXUnj0ZXvu/5POeUUTjnlne/JBV8bx9LfbEeWJeZ9edz79vVurIy9QEbeRQYfhhSmXBt7yHl3gZNJZ09F3e5mb8l2zh/8HEtOPw7P7CI862cwRp/A4GCcdF+C+J4syBKBqiBJy8a9I0Wqp4MHNiWYcEwRgfI4nqBOZUGMwQ1l9Js2uq3TP7Yb/eQBZt67kMSgAx2Jt/TnqA68ylFegSvu41XXKegUoiYVhkf0U9bnJK3ZSH1hTNONSSMj2MfM4TV0T7iMrs1hshGBjZN1HEecQhQsdjEDkPBKUSzVQ9aUkAQ4VIE7oKJH/vKZkROGIfcxItkCBROjN4AR13D4c1Y4PU2jwOHIpe4zclHNimRz4v+bgmSbyM+24Q050CMqIpNFNnSSQzouOU3a6SGrKyByfcvCzP2UJRxuBdkhYybSFJTHQDaxTRARF0baQtgCy1IOJH1EknC6IBs3EJaNJEtYhk1xY4jl168l3pNg0rljSUd0gtX7Nydl5cB1bjy6ktGLKvjz2W10buzDGXBSv3DEwXUQ1BhzVBF9IYFt2hTWf7T/vvpP4mMVmn/c8mNst02ho5DRntEokvL+jfLkyZMnT548efLk+TeioKDgA0fJWpb1/pX+BoqLi1EU5bDo5f7+/sOinAGcTidO50cT8flJQlEOvS7quzxCm+fvJNH0tvLenBj690SOO4JQc8GHb1dzwd/W7kNwzsW7mHzaTQghKApt5VHqKaCIReaxKEYYVB+NjV6uvrqeB8On0z/hKSamOvn0xl3ARph6EwTGv2v/J3M+NYwiI1JMZe7BLFx/QZLY3DCNaEMNM1mEBzeM/e/DO9qfGynMINb+pHoAA/Rg7Y+E3JeMMODbg26NoDNjQibOXGM3xUaAnvYOSrRpVFVVYWRM9Ht9dEsDtK6OMvnyl5GWF6B01iFLrSiVoFZoRB+A4I8EqmVwtfkYp71QQdtFGTYW5R7Dt5MCh+pgKKDybCBOPCBov99D664L2ed5ha5tLew6Oo5rYBQPbJtN2LDwGALVraOMtHGWtxCc/1Na/nw9Y9dvw9PvwExrdDkEDXUvUX3CzazZchla0wRGsoHqBRtJubzgcDAkoiQDCRBgxt0oHgPVaZN8axHe2k4kBTKGSXtYxpIqcIWS+N1eklgU6TU0uCrIkmEnG0iS21yMMsRetjGd+bz8VgqnJpPJ2kT6PcyZFqXsuDdQVYkQCw+8//GowqLun+CqbaVhdjG/3mJgRFxUu2v4Wf1ZzDrVhdedExa/eNZB4ewZug+UwwxgYqK+TQ7a8XgTL/1mK4Yp2Le8m/PvPQnNezDKf0VkBWtia5jqm8oxoWPedf3ZtvibLToqJ4X4zO0fwObmfWjPtjG9rJU9MQXI8v1JXzuszik/ncmoF8vZ+1I1GBZ6BoKmg1Gvywy2WWh1Lir3JAlWupEUGVdKJ2Y6yZg6g32DDA70YTy3lgbRjqpksE4Mc86Tn+H6HyzF2JPEm4JwZ5qai2rZdH03TWM3sf2UpbTTw66pClfdqBDytxJJlZIOJEG2cjYVpoKwwcRBkgLiFOAWCTqXt9CxKYwkS0hIGDjZxpEAB+wvCipjVFTsoy88kd52FcuEeDqBsP2AwsEPAxuHSOMiiY1EOh5k/ffOpnhOK4mWYqLbG3BrCbxqGFm1iYtCisaUEG0ZouWNTqxUBmMohqRpqB5BkTJENmmgWg6CXhtpVB16JEG6J42EheTw4PJBUb0PiZxdhewuIJPux+lNI5JesmmTLB5khyPnwexXwTSpGh8g1hkmGxXYtkDRFJpeaiUb00kOpNj19D5KJpRiSS6cATczLxh5yHXuWteLmTbxhNzYls3I4+sOOT/hrEbi3UmEEEw+72/f3MhzKB+r0FziKCHozUcEvCfJJNTV5cqtreD1fpyzyZMnT548efLkyfMP5vXXXz9Qbm1t5eqrr+biiy9m7ty5ALz11lvcddddH2lCPk3TmDFjBi+//DJnnnnmgeMvv/wyp59++kc27iedI48s4LTTStm0Kc7s2QGmTctHPH0klB4D0c2AyJX/je1JkmI5hQU5z9Rd4h6WiskI2yDV9D1ObU2BqxLmPc+RRxZyJF8lkpqP943FOGwB7ISm62HGodGopDogshG6H6OjR2XtttnMr34KUavBuCtythz7WcrTPMKtAKzkJb7LjQd8gt+JBsYxhqnsZhPFVHAkiymkhKe4CyUrY2ZlxP5IyUyyGEPehYUgDuAeIC0fw5aeXvSp86Agi6v1z/grXqDsVxuY8qtbeGlHCqk0gfuEDdQMQkxImGmBPmzyWiLEoN2FmVVAN5GQye6RsWeUMiineLnGTeRclaHbH6DkLB3feYKHkzXsenQW2aYkwu4n8ciJ1F7aiaU14ykTiMIOJk+4nxOegleTC0EKUxbo4NqjrkOLDfHirJ9xz57PI56bTCqcpviSbmp9JXSm95B0JkiunEd0+fEQDzLjU9sYNWmYxEM/YsuLY7CPvxNn4070bRNJRUJUXfg8klDBnaCVXaxA5ShORUHFwkTDyQgaAKirdDC2zsFA2KKmvIHvlV7FemkZtTQym6MB6Bsy+eZ1Q8RTglCgnBu/U8TsUTqrt2VJpgS9QzYSMDBssXpbhvpKBxNG5cTiYzidJraik+FYzjpEZAZ4/fUwrd0GAMNRm0xMPyA070nt4dq2axEIXg+/TrGjmMn+yYetld/eF+WV1WnqK1V+8rUQAd9H+6T6lifb2Pl8J0UNfo76xgQczlzg4uLQYt6KvsXkkM6CgmOYW3x4pLXDqTDcPEDfjgH2bkvy2oPtqFV+akJuKl1+5L02lpEgNhRD1RTGntFId4vBjo2DSEgo6SweBllvnEAsW4zxmiCrbmVkVy9OKUG7pFG3ZRSJPhvFoVDcUsn0B09gePYyhhr2MFQm2DSlkB7LZPRbDprn72O4XqVhwyiUjIaEgomKgyy7mY4lZIyETvFIP6oiM9yeRBI2ug5YICkChzNLzbi9hDdXItQyOiftYcvZLzP61TnUbJiGbehMsNYQTGfxiSgldJPFw1LOJt5dQPvjMxCSjCwJZnpWUKL1MKiXEnJFaK78Ir6ynBYlyQLbNBECrEyGIUuQJZCzyRAGLkunsL6Q7HAap8MgbcgooSCppEXF+ACF49w0rx5CT1eQipmoDhOt0MIImyh6ErdPQ1ZMZNmif0uc0KgCVE0lE8lSNbOc3q0DuApcDO4ZBiQURdB4RCFHf3/uYUn7ZFVGVmWCNX4G98VYcfMuBjt05n5hNM2vt+MudHHOXSeBAHeh67B18knl6e5mHu3cS5Xbx3fGziDo+GRt/H+sQrNH8Xycw//rMDj4cc8gT548efLkyZMnz0fEUX9J/Axcc801/PrXv+b8888/cOy0005j0qRJ3HrrrXzuc5/7yOZx5ZVXctFFFzFz5kzmzp3LrbfeSnt7O1/+8pc/sjE/6UiSxKWXjnj/inn+PkqOBl8jmHHwjfm4Z/OR4pLGkRIbENgMSg6EJEG2lz6pE2wvpFqg9faclQZQoNuABmTfucOht2DPLyC8DowoP/nD5Zwy4wHCgyaScDDKfcchQvNeth0od9JMhjRu3v17uYrK17mG5TzPWpbyHPdzDpdyBMeyy5ngU/1XkXXsxOgrIVZYgS8g0SXtJlNlseJ5iZbIPFLTXNh+E8WXwGy4kKzxE+Jhk56Zj+IaOQtD9zM4/F0KvS/T88NjKZz9Ou7MDhytfrSwB9sOkbT7yawoYKycYE5JMy2FKv1hEJaDY92zWHb3SMzvPo3Pn8E5UiW7+3mEcjGRlQsZtXgLypg/U6D5GO7SKR+5jIWhFB5HhEjGxeIFT1ISGELRLSbvTfGHDfdSVzAK/6ZRfKHzcywcO507pGt52r4XI12AnQxihcvYfH8Bx153G4Wfv4n6MWPY8IOvoFs5GXn0hHV8oWs+Ty98hB5HHzYWKZL8lu/xFX5EFy1s6tvH16RLqPNXcMUZ11BSWEAiJThtkYdCqfyAwPwXNu3WiadyCf6GYzbb9xnMn+7mzc1Z1u7Ivbbt1enoNRmO2UgS/OhLhcwY72QMU/gpd6KToYCiw67zcFUllrMTJZtloLQMT8nBALd+vX//ZkKOPr3vsPZNbQYvr8ol+mvuMnn+zRTnneB713X116zrzbJ1QGdWuZOJJe+fpyvSleSt23cfKBeP9DP17Jwf+2T/ZG4fdztRM0qtq/Yd29/V3M3SnZ34OhIIQyClQN+boNOVpmZSiNRgBk+Bm9RwGt0UJLpjTFgyik1iA7Zi0qt1M/EVDxnhw5JUhO1g36uteJ0qRRkf7qybwJTJWG2t2AmBR7hRjQoCxgykwThr6ieT1AM4/Tvx2HMY99KRDNV3YuoBMrgxAY0UfVTnLEDQwIbEcBaXx0mwykdhjZc9r+Yi1WVs4r0+9HaYcdRGdpVPZuvCV7Blwb6z12EsinPaTUkaw01oqk2JOcAglThJ08BWNrIICYEsLEBmZ2wCUXeQ6aH1qIpN6PMT8Y0I4S710bKyN+fiI1mkLTcpvCgYqGTBkDHawkR7stipFGlsJDKkwxqmW2O4NUlsMIrqc6L6XKR7U9iKip6wsCwVExkpbSBjozhVZFUh2Z8m1BDEV+rB4VIJVPrIRLOYWQtFU4h1J3AFtMNEZoDKaWVMOncMWx/di9BcSE4ne17tpuetVsxUzipk2ucmMOmcf52/O2E9w23N2xDAkJ7h4Y4mvtgw8X3b/TP5RCQDzJMnT548efLkyZMnTy56+eabbz7s+MyZM/niF7/4kY593nnnMTQ0xDXXXENPTw8TJ07kueeeo7b2nb+o58nzD8Vd9XHP4J9CoXweDqkCiyia1AQsxSH7mT/wl4g0GbS3CYGBCVC+BAZeBy0E4/7n0A6HlpN71j4OwiCccJPMOAATwxDgCNIzYLKj2WBcvYOppfPYzFsIBOOYfrjInGiCjvtz9iN1l4DqI0aYR7gVG4sWdlJICSdyLmMLfPxs7U/48Q07cJkuvGUy/+t5kDNPXUWZT+b7FxRyxR9lUo4SJE1BLW3BN15DZNzYiQAxPUh8sI5QRT+pjJvWzDgCF96LkP0sjJxF8ZEuGtxzuC3VxO5VW/DdbXHJcVlmd/j4vTuJ5UgxqdvL3GAni5zt3LasEeWMXqzv3UrzpBL6fzMC18QBkrVr8QyOIBFI4AzX0Vlm8OoRSWY1PU/HlkoqK0fgtPuJO6BatykvTLK142RkRvObO0uZNsXD2pLX8RNkIFKM0VONJGTShovhXTUUVkWxarYTahhiYG8JJac/hPOUp1k2dg+a4saNlzRJJGR66aSHdvwbynhQ+jkI6NISjB71EJcd9w7JHt/G6BoHqgKmBU5NoqEqJ+e0dBkH6uxs0dH3/yoE7GjWmTE+t7Y8ePHwzk9IH39SCdd2z0XoJkcvCB5iEzTTP5MxnjHsTu2m3lXPkQVHHtbe55GQZbD35/ALvi2auSnVhENyUOeue8exdwzqXLMyjACe2pvkt8cWUx14d6kq1pembc0AlmGjOHLjiL/KHSj1awy/aSOPHKJmRvEh56K6ySPt/ajHl6PsTOAYzCJrMkKTkZ0K6YjOyPll9K1pxeF2oDoVhAWTTqjmS587gft778fsKGRt9xT8OwywNTxYGIkwGU1Dc6qc/Jliauc7uOdruzD10Sgo+OIKAdPFmO4i9o0fJDnWYPLwbkbbCnsz4/Btq8FERSgCgSBFAVm8yNhoZNEVJ3ZWkExlsAwbIQkU2cq96YZACBt5R5xNXXOZeNk4lvmex0qYuHYVU33PHApjr4IDLHLvmY2MBCQIImGjYKBgY+BiKBtCAK5ImuZ0I0MXvoXDpWCmDSRkZFvGtmVsKeepbKIhYSFj0V/WR8SVpSpSvX8EGymRRjKyuMpkoraL1FCWVETHtgWmYWLbEhI2AhnDlFGFiWVbyKrEjPPHsuBbs9j+6B76dwxRt2AEe19pAwGJviSa18HMS3IR9kbGxOE6dO1Mu2gCwZHFvPzzzbm1YtnEexO4A7kNjYFdwwfqCiGIi9ewSRCQjkeWcp+PqeE0b96wntRwmumfnUD1nPf3I/+okCUJSZIQIrf5o8qfvBx3eaE5T548efLkyZMnT55PCNXV1dx8881cf/31hxy/5ZZb/inJ9r761a/y1a9+9SMfJ0+ej4M3N2ZYuTnDpNEaJ877eJ6ulSQJv5R7iuF84Bg+jdflx1fye7BfgMKZUHPhwQayA6b+HvQhcBQc8E4+gH8cDC7PnTNiXHLSOv684nRO8O3juGl+Bkq+wDd/NUQyLXBpEjdeMZ6ry39BRE0zhimHT3DnNWBE/jJbGHU5OllsDvrDp0kAIITJrqYXKJBB1YpZujKO79RdfLq/mKhTp6GqhbpAJ8k2P+kGF77WOF8/3+bZngkkBz3YDhCFwyRtDdmUcdQ2YyoKlmLTP6WVs7LlTI+sZZ4xgq+1PsaUk5/kuKn3UJzq5potfvYmLAZay/C5EjQUD/AdZy+7d1s8MKIO/7Q0xpgEtlsiY2cwwyruWBn2lrn4p61k2UnVDE8/kiUnnYo2Zy+JliYMsqQKdUZNrGVHVy12QKfLTPP/nn0U+3MCRVJwuLMg2UiShJT20zOcJYxJmbOQmtGV9PkUMqc8i8+bwWeppLDwGSFaOxM4DRhRrhAMhNi9eSvSeAfCYWAaWbIRL5S/99ppGOHg2iuK2L5PZ+oYDau0jQ30cPzC8dz1qIUQcM5xXpZtyNDZZ+FQYVy9g+5+g/ueT+JQJT53qo+CwOG5sY6c6uKW/yklnhSMrD50jbkUF9eNuo6IGSGoBpHfISFlRYnKty4K8srqNKOqHSye6wbgj91/5ImBJwC4rPIyTi059bC2rTHzQLy0KaArYb6r0BzuSPD4t9ZgpE2MtIm3yEv5uAImnnrw72M6pvPkVWvIxHOK+4k/mIadybDxnh14ilzM/uYM3IpMuthF3zUTqd2nw83teB0yVQJGH1XKzIvH0bOxhJW/24jTp1E2sZjChgKKlJnMCszi1ae2sjazi6gzidPuYa64E49iEjZ8DJacSehTS9i7/VWGYhKqlAIhodoGVrKIvdJRKFvTzNrroTxbiZ4FFQOBjIyFVlhAeiiFLGxUTAQSChIqTqxsLlId2ybZFcZVlME1HMVppXCZSXYOTCMlCphXOJVjXzmTzmgbBRtH4ki72M00irM9yMJgJUtwkCWDm1bGIe3/zwJskZO2+7IV9GUrYL9YLPQ0KjqCnF2OpTiQFQnbtLD3i9fx4hiWnKJ94m6S3iiN66YCCmY6RYE5QHHzbkZ6MryUOBtFlbAzAkmWUGQQdm5zQ9gCAxVhqqiak3FnjaegOsCR35iBEDmheM8LLQy3REGC+kU1aH6Nhz77LJ2reyhuDHHun0/BFThoJ1E/t5QpZ9XRtWmI2jmlxJr76Vzdk2u/cAS2LVhz8ybi7vsIHb2WYJWfhLSSEeovAdh493Z6NvUDsOzaNXz6wdPeMYL6n0HQ4eTyUVN4rGsflW4vnxox+mOZx3uRF5rz5MmTJ0+ePHny5PmEcMMNN3D22Wfz4osvcsQRRwCwatUq9u3bx6OPPvoxzy5Pnn9dmjsNfnlnBCFg2YYMJYXKgUjPj4R0NyT3QmBiLhL5nbCylCn7I7nHfi/3+v/snXd8HNW5v5+p24t6lyXZkmzLvWGDbTC9lwAhDQiQepNLKgRCeoFLbkgnAXKBFAgQIEAIPTZgA8a9y5Zlq/ey2t6mnN8fa+w4NiUh/EjZxx99NJpz5szr3bNlvued73s0JAkcxUdvqzgnN36sDVJ9nD7dz4LJfmLPhmF1kFbFQyKVE9zS4W5an/k9p8zopmrq1yHwV3KAsMGMH/rbiABQQgVzOI7nxMPUGU2cqJ8PQEQ8TfPClTz3zCKyZgJzSphFehX16no8ZBgLFXHijQ8i3aHS1Jvl0jkJyna2cJI4lotevQKO/xVlMx4gFQ/i0Hdi2S5kV4K0y2ZPp5fu/i5UNUOLfw23v/cuhkaSRBJ+kFSKqxqZ2vJBnPatOK2txHQXabeKq7eIqKcYyWVASykVTfdAphzDCqEMTKNm80e57vgPM2mSRc3MXOGw27t+To3spNzUGZcSDJbqBOcPwuT9OKfto69mgLmpKbRNdOOd9yqJPVPJdDQSrAhTuvUDWAWDeAeW839freGBZ+K84KjHWfIiOi7ex0fZMRgnHn2BGGGGuk3mzDiWxJznUbKQCYYoaZ/Dh6Ze+mYzCoDGSRqNkzR2sJ47+A4CQeXyOn4+/fvItkJlqcq5J3jY1pbh4ZVJvnl7mI4+A6Rc4mvXgMEPrzn6XCorUik70lXjwBSUKMiqIItcXbmjsHy+i+XzXYfte6r/aRKRJA6fzsqJlUcVmhdXOHiwTWYsZVPjU5lZ/PrWGX1bQxipXHFKp1/n+KtbqDum9LA+oa4okZ4wikNDdesMtU7Q/tgubFMQH0rQ+rs9fP2KqTzaN0qZU+eyZRVYF81h469a2fNYGyM7hvn9Zd00nz+d99x1Jpou4Sn38NQ3NjOwfYLahcWkwlksw0bVZJYl7qfK7kCyHGiZLKkZTorm1LJydwtjZhhdEtiKjWUqSDgwhZNsuoYCc5yU281QjYnaJyHZucJ+hTO8dKSHkLbIqBkZGxkDHUEGS0jItoIiMpiZNAl3GpfHojnVxRxrE7IksbPU4s7SqXQpPma9Mg0tKpGVdaJ6PU+mrkTFwMCJSgYVI2eZgUnGAbZwoBggib/0bc8tA7wmJssHioMKy0Ymi4xyIJtZkHInsW2BN+JCyzgRSMhYWOikTAe7wjNYoGxATseRAwGEECiWgdOr4CjykxiKY0RN0rYbgYwkaay9cy/9r/Sw95lO4kMJCicHSYwmKWkqBDkng+98qI32Z7oA6F0/yKa7dnDcZxccNn8XX9F08G/bbmB45yiuoJNgrZ99K7vZ+1QnpR/cT2wgjjPgAG/bof7WIesYYR/a/mv6Nw3Rt3GIitml1C5+57KeTyqr5aSy2nds/LdLXmjOkydPnjx58uTJk+efhDPPPJP29nZ+/vOfs2fPHoQQnHfeeXziE5/4/5LRnCfPvytjE7mMzxyC4XHrjbq/PZLdsP0LYGdymcazfwp68FB7dgJ23QCp3px/cuMX314BxKLjcj+AMThI5N6PYZkmPVs2M9g9hjPwJdJZcNm9zKgcBCsNg49B4C98PSM7YWI9FC2F8ZdA80FNziu+lw5e6X+e7V8ZYv1YL8aib9JSOYuGWWNMnzPGV3/0IqNDHu5KOLl49yba4xX4HCk6nSprmwb5yH8XcmJXFHNExpl4mWvHzqGiNsv+gWX4MyYnFT7Fnlen0yn8+M5PE9m3DG3bDCYXfBfdirGlbYJ9a35OSXkLqsPP88kTaaq9luW1LpprziDZdyev7L6Nm9s+yrhVRM+wk5YSidGmO2nP9iG3FaD2XkvNuIPqUp2FlZU4Djzevwjdxu2Rh5EnK5QkZGJPtTBzeADzqh8RKU5jTSQY+bXC87EhHJkLyZ7dR3DZC4hlqxFJD50//hlT6zVmzHbiccm893w4nZvYLTbhknws4WS67e9RSCmFlKIKFVvYrJk9QEssRSrjRZsc4hf3/S8XnXoJTdVTj/oUr169mp///Oe4XC7O/vYJPFr9S0KMUEMDA3ThKA5RQgUAHpeM36uwtzu3wDAwamGLXEb7Uy8n+f7nBYryN8w3IeA3P4ANL0BBMXzmJih+k/RrIDoYx16lMFEYQVJkTj7m6DZMhS6Fn59czGDCotqnor9BbOXTgyiqjGXaODwqxZMPL9BqmTabfrmVZP84RsqiqKWCuiUltP9RAgTCsjD3ttG4X+KG+fMPHRjQ8Zc50N0q/dtCJEMZEtl9jLTH+MBdy9i7apD+bTmLhe71o8w6v5bBnX4Khh6kLr0PRbIw9QyOQJyKb05j5dgqhu9NEg0WIFJZZFsiGM1gvuZ2bZvEDTcZOU1EdxBQQEbCFA5eza5j27mrUE/ROP3mC3GbGQxJIeMEiwx6UkMWB+TfpJ+QP47u6SQZtwk6AxRrm9i4ay7JSRbKCRILngZfpQMzkSGSUnI+yAhkrAMSszNno5EFVQiEBEISSAJU2cSyD60sWCjY6AhkQELBQCbndSyQcCacxApjjFZMULGnKVcgEMFrYrWEQJUsDFtFxC1sUyC7nFTM8OIpcBA8u5I1PzxgcYGMsAWdLw8R3gPZiTjpSAaHP0kqlKakOQiSQmFDTrBGOnga5APZxt2v9PPKTzajaDLHX3cMZS25RRZZlqiYdWiB4jXxOLFzBo6aXoQQ+OQTDrbPvXQ68eEEyfE08y5vOWo2c6gjzKpvrUXYgrYnOjj95uMpnfY6Kzf/5uSF5jx58uTJkydPnjx5/omorq7mxhtvfLfDyPOvTmYcRp7J+f2Wnvr2hMx/A+ZMdTCj3mLn1t3UFfSzvMgCrvy7x2trS/DUU2NUVTm48MIyZPkvHt/wtpzIDDkbing7FC481D78TE5kBhhbDRXngu9QMSr7wD/1771clyT2d3QQCYfZJr9E41m1nHLJJ5kafYEKdzTXx1lxqH+qH1q/CiKXqcj0b0NwzsHmfjrZ/+gA6bEslmXx29/8lnkNC9EfU7nmpklUN4eYVnscM62lbB+9EmfUJq04GZ0yhCFsFDONMGQKpPFceLaBW0nTbJVzdWg9RSNJMskOvqK3kHSk8E1+nvrQEAWpME45RlGxyS9XGZyghVG95bgccSaiB0x5JZnHqwTfe3gOe/qcmGoa4ZzG1q27iVcnwdGC7RjAWbeaD654L1fPL0TTBI+sStI9YHJfKkPHlsuQVIPx8x5BLSomJFYgJ1ahFvQw+oMoRqdOLCFwj+1DnTsZPdCJrFqIPQso9MssbHFwzYeDbOUV7uJ7JIhSu/7TFHUuwjUny5n1p7Izsw3LhKsqrkKVVWR0HIEqxob72dO6nuf/sIt7nvsNz9/5MmXuI0Xcn//85yQSCWJmhNuiN1JOCQmijDDAHI4lyOFZyoV+GUUGywafRyKeFMiyREmBStYQuP4WoXmoNycyA0yMwZon4YI3f+2M7h7nzLXns71uC5qlcvakc6Hl6H1dmkxD8M2tCEom+zn/lkUM74lQPacQb7HzsPbEaJJwV5Ty6UGycZOmU8spay5g2RcXsuW3u1C2vMwUazuxb5i4P/YxXOccyrCuP76GdXfsIDmRwUYhMpjBW5rADMdw9reiZaMYek7YrltcxvwPTCHysd9jri7GjkWQsWn/75O5I/lTsuEs7hMqsRYqdE5vpThUzoqfnI293zgohhqKRFqTwFAZL9JxRXQcaZuyTdUsHTgFszCOVGmhuT2MDdm5nGFh4DFsPNkEQdHHXqYiGyp7F4Up3Z2gtrCa9JjN1F+ppDwSmWAWMyMwIzFqF5ayd+UAppnLSpZUFUO4EAfW3CRhoWJiSjLYKppkoJElQy4zWUJgIx+wzsiJ1dJfFImUEPjGgySdNvOePY6CwbLc544AlTQ2Kk4lSZtYiKwrmIYJtiCbECRCJsOdBsUpJ3plKbokSIxmcfg0AlVuEkMRRDyLkTKJD8aZI61mysAQ1NZTc/GPkFxu9jy+n95XB1E0mVBHmJHd46y/fRtGwsAANt21gzNvObzA5ms0rKhlcOsIwzudeLsXM3lJLU7p0GT1lno443snvOHcjA7ED2U7C4j0xfJC87tByAihGnmt+w2RZViw4NB2njx58uTJkydPnn9rwuEw69evZ2RkBNs+vMLRZZdd9i5FledfCiFg15chPZD724hA9Xvf3ZjeZXRN4sYLVhKd9Tg+RwY5LCB5Crj/9jsFEgmTr31tH8lkTqHRdZnzzvuL2/cDM3LeyrYBqg+8k/8qmL8QHyQll/V8gHZ2cgffIU2K9/IJlnHG3xSbVlFB8Uc/ysvXXMNQYSF7ysooG2lnxSI3pK6DgUdBL4CSU8BMgurOCc2vicwAqT6MYAsreYQYYRZwPAUFhfQwgmQqqGkVSzGxhEJm4AIaWk4BoFiBxgv+wHDvrTyrP8qmSkFQZElXlLI7k2KocJiGoWLmudtZq85nrifK5AlBZLwETYGKs16l35tEc08gzx6j6+kqXKl9SEJlcELH41KJ2Q4cniCn1D8P9un8X88Ofto3wd6XJjAmKWB4kOIxtJSMKH8fwnIjZVP4y0JUHvMy12c/T9sejbEXP0Z4VyOjzknIwXGEJRNdcyrOE1oJdZxJlbkF54iFORrHigWQRosJ64twvjQXVgdxN7fR3PtefCUKxy9woWsSz/IgHdYW+nfV88d7k8xmnEfWZam77kcEmmM0MZsTORGAD4j/5qvtN9HZ0UrsDyrJhE04HuUL9/6Zuz/8QTTtcCHY7XaTSCQwTUE6KyEnAtR7ptLEbK7mO2hoh/WvLFW5/qogK19OUDkyzNa4hOZz87ELC3E5D+kKQgjiSYHPk9tnGIJY0qbALyO9tjjlDYCmg5HLXKXwcKuK16O0pRiP08OC/cegeTQqZ7x+FnTfhkH2PNFBsMbH3MtnvKH/bXGDn+IG/1HbPMUufJUeYgMJnH6duuNy9gXVCyuw0iaO3T/AqeceK2PbtsOEZn+Fl9mXzWagfR3R4QzaRBhr2GTbJV+l3tHB8XHYv+CTVJw8g4qWAgBcC+eSHu7HGh5G93h4iJfY3DWOP+bglMF9rFuqIrwusktG6dvRRklHPZqcQbZ0TMlGTwjSLpNZ3mdJj87EEC4iWT9FvQVMuLLIERm3r4yiTw6zv6ubkgcbkbMWGdxMt7ZiZDysWRSldVo19WMLsJIuNo9MI4iM2yXhiivYUgYlGiK7N44i60iY2JKK0NyIlIFAAQQO0gjZRgcsHCApyJKNRgYbkLEwcSIQSNhI2JjoyBgoCGwUBBKl/SUIZGwO3UViopPUvdSePpfCWi/u7gitTw1giVzGcyphIzud7F89hJGykBQJ3a1ip7MMbRvB4zHQVBlh2vizA5RYe6HAR8AaxXx+Ja4LLuCSe87m8c+spHftAEM7xnjxf9ahezRSoTQAuvfw18hfoqgyy69Z9Lrtb4XKuaUEJ/kJd0fxVXioWVTx5gf9m/KuqrySkP7K++Xfi1g6yfWvfofvSUdWDv+b+GZ17vfzH3j7QeXJk+dfGiEEljjyVk8JCVmSUSTlQCVaGVVSefjku3Eo76D/YJ48efLk+Yfy+OOP88EPfpBEIoHP5zt0oU/OYzAvNOd5S1ipQyIzQGL/uxfL34OVBjORE2slBVTPP2RYSfMRcKUP/KGA4nrjA16HaNQ6KDIDDA1lDu/gaYBZP4TYXgjMPtKjufTkXHG/xD4oOQmcZQebnuBeese66evrZ4/8Oe6rXEhx8ev4M78OgXPOIWDbPHTnnQCcd9559NPFoKuHaZMvw9PzR9h8JcgOmPoVCMwEdx0ku0AvhsLFPM5veHDs9yzZ381A5nvcN/8qfpI+iXBXklWBp9mX3ola5Ka11EF8b5x9ExlqBu7B2/dnrLJzmX3hZXTwCyIizROOdfRNsyiOq5RXjPOpXfdQ1qex/ZXjcVkh6srTuOdPY0/tPLa5dyElZRZrTubWqeyNNLHKZaHd5CZjn8Xi0ZsJ2g8wvs5Jl/g4v3TuQptsUPaRHQz8qAScF+GOWWRoQK5MIvxRNI9JYUsrv5LuJDVWRsLwk1h+BxHlLJSohh3xg5FBmD3ENsxGUMzQnz5B+XtuQao9l+zGAQqdhVB6Pn7vBKpuIlsFVMzZiNE2xI77nJQ3z6VV/j3+7CBTlRir5j1DT81DECpHmUjSWCbYyzaiTBCgkCcecPHcTy/A9NSSzP4IxbbwzShmrHs6T/ZtxKjfShOzmMUxAFx//fXceefdrNok4V75XvYmVrF88iw+XX4dHnxHnQfHzHQibe1lS2KYOUEwsxLnzD0kfoWjFtf9JET/iMWiGQ6uPM/LDT+bYDxic+xsB9ddGcx9BvkC8MmvY6x+mi2RckZZwWmmQFXfWMvxlXk45ycnMrI7ROm0QrylR38dpyMZXrhpHbZhM7BpGIffwcyLm4/a980QiuDUzzXT+chmChY2U7U0p6U8/e0t9G0Zp7m/kLrCEXylLvRjjjlygGyazEQK1c4iC4N4zxjr2hWK5pkEC1WWrcjiOueQN67nU59CmzkTKxQicffdxKK7URMOPv5biVjfMZiLtqKO24TWJxkfieKt7MUKleJ27ccrmQw5CijwDlCd2cdIgUYs1Ixq+5AslcL9VbhcTpKhLNJtAZodc0jZcTRSOEgSlwqxJC+z1lSSWj2XrZqNrICSVVFkgTeUu0YESJkO9ne50EQaxaUjZS2sbIoCxpjOBvppYIhahC0fyFMWCEkGpxMplUW1cwtRKmlMHICMgoFAIoMPJ3EyuACBTgYZEwWTLA4kJGx0sCQSPSNUNnuZfm497U+0IwsJWRIkJ3QScQMrk1OmhbDJRNI45BSKbZCKg1ziRnWpWLoH0hLZjM3ghI+CqIMqctYV7U93kgpnkBUJh0/n5G8ex6a7d6DoCgs/dpTip/9AdI/OWT9cQXw4iafUjaq/jpn5fwDvqtD8xNwn8PuPvhL178CKJ85jIDGM6syLPHny5PnbEAJiRpyUlSJjGwhhoys6DlnHqTjRFQ1d1nGrLtyq6+CXCABN1tAVjVOrVqDLr19MI0+ePHny/PPxhS98gSuvvJIbb7wRt9v9boeT518V1Q3Fy2BsDUhqTsz8VyHRAbu+AvF9YCXB2wiNX4DipW9/7IpzcgJvshvKz3j9AntvNkyFgxUrCnn++RDBoMaZZ5Yc2ck9KfdzNCQJat531CaP4WN8oA2fapEatPndC7/j6quvfv1gRlbB4B/BXQsN/wVKzkrgvPPOY8mSJciyTKh4kJv5LDYWJaKC6wYGcCDl7D0GHoHp34RZt+Qym53loLhoHe9A2zPC3OgoNpBJvMiXzrmOaMkc0onN1G5OYDhk7h/fyMD2Ihocg1iJINcoXWjt3+XBoZlsLxtmjAQJWWADg54sZZksTgPmJp6kcOVK9o7phDxJXl49m40rP8yyK3/LZB7j1PEK7gwv5I41zzEw3EfRiiJ6l9/Gku4kliyjyxleGbufVKMHM+VAqyjDH8hitE1QVllL/7iFFskSmBIj7UqSUbeTTuikFAulaAwrNIOUs5nS035E8plJyEoCqW0d6WcDqKfW4pm6C13Rqb0oS790JQ2pJZhqilFlApCorsrQN/UGhlqCrHn4ItY9fjX+k8ewVIn+sgintDzDw3oNSs1exhp6SONmESvwkNM/tu+ZwLJspOhcnKU3EGhoR05+gJGwwRMV30VH8CKPczU30sgMGhsb+cwXvsX2b/Qz/OdnEM8eS9kHzsN3eeCo0yJDmgG6Ea7cXTGyBA4FVMch8evP61L0j+QWTNZuSxOJWYxMWCiyxCvbMnQNmNRXHcgCbZrFd1dWs6k7C90xugZNPvW+o5/7L/GWel5XYH6NbNLANg7dvZPt7CZy7Z0I08Tz8Y+jNTfDvl25rOpJjUccL4RgODvMs6FnebDnHryb9vKlHZNxbSnCavkxlJTRtyVn27K36UNQPsJx1y7JjfvXj1skjddjksEmk5CIRyVMEeDZDXUsqdzB5IkJrPFxsi+9hFRZTWtHAeOdhVROLsU3YbD04Rb08klU7WplOFTFol8U0rGoG09XDXWrJlNopNCVQURapVZKM1pRTLI5xj0NY0TtbTQ9LxPcXIxAR1NlTFSyY7lijiJuYlsybjIUMkKfqCdieBGASgYFJ7KVZcN5NkONAt+YxPLf2UgpmzROZGFjAxg2nmKdxLhBM5sooY9RKnGRIIkvZ3Ws6UiqQlZoZIWORhoFAwkLTcqAyAnSFhoChazkAVlHsjNIwj7gzQw6GXKGHDpYgp6dGQb37UUWBsKycyK0kEmGLSwrl1mde1JzhRElYSNJApCwDAvLtJlIetiuLifg9TGRLEZ+KMXi0g6EJfBX+zDTFrZl03R6PT2vDpCJZamYXYqn2EV0MI7Dp+PwvjPXyIqmEKg++sLPfxLvqtCsy/q/tQgiI1PqLKbU9fd9gcmTJ89/BoZtEDXiZK0sWdsga2exhI1f81HpKafSXU6xs5A6by3V3koCmp86Xw2lrhK8qgdF/s9dLc2TJ0+efzf6+/u5+uqr8yJznrdP4zVQeQGoAXC+tVvd/ykY/BOYsVxGtjDAqoL+B/8xQrOsQv1H3v44wOc/X8cVV1Th8Sjo+luzOBwYGOC+++7D6XRy2WWX4fP9hSBhm5Ad4+KRGsZCJhnVZka7xYhsv/6AmXHY/2MQdi5r3Vl5mIBdWpp73l/iT9jkBMVRaZARr5eaaCKX+T7+Cmz9b6j/+GHFASf3nUKb9RwAykQRhleAJOPCzVndQ7itMFYCOrduZ0tvA3KxhqKW0kUNC92bGUoJbENgq/Da/0ACmsJQkpKwSDHV2kva56Y3Vok6OE6fcxjj9n5OOGYUd1khL23op791GFs3GXxkgB1VMifGNUr9NoaQeaJ2FOEfAV3DGizB3b2HhHwqXQMZFEnBvydFtqAQ5/RXyMYsQpEWpKEy5NIQ0f6TUYJJQq8ch0u6A3v7EEa/ihYIU3TMD0m9vAxzsoythmn48G9o8j/IthEJc81xLDXOQ5x2Kzs6vViSgn/RRkYHGvCar+C0JUxZYBTGcZbvxU65iG+ej/AZqNO0g77bl5xZxVMv9pFIZnENe5GtL+JwOnHO20I4YVLqVBAIhumjkdzzUlKgEOv+DX171iABu17phctvOmJaJInzv3yBUQbwn1vE8uH/It0FLWfVHOZpXBzMXUNkDcHuzixD4xahiM20Bg2PS6bAd/i8fq244F9vv138FV6mnTeFzb9tBUmmcMsfMePdAMR/+EMKTp4HLzye63z+FXDyew4eK4Tg+z3f5/mJ59kW28bUVClZLcUfGwf51GY3RmsrzpMqqJxZyMCOEEJWKTx3BVFHIa0/b8Vf4WbmeZOQZYmudSP0taZAlrEkDaHamEBaSMTsNOtTy6l86CHSTz6JlUgSHkjyytCJ7J+oxk2UU41BgmIJLZ2ljOjgtC2qNjRQum4qGcXBeLlNNq0SCAfRRJYR4Sa438Vep5OQdzaN65owhAyqBTZkhROn2wnZFKouAwJZJEgYASIiiHLAxOK1KniyDaFJNkMtJqqpkCyG3lkwdZ1AwcZGxkRHFzauAjexmIHLjFNCPzNYy0ZWECrWCVWPU7i/BC3hxxAaHDhOwgBJR3XbWBkJy9Sx0JAlgeZxYFkCYeuQTYE4ENPBdx6BLSSEAbZpgBA4JYEkbDLoWPZfVPI78FvVJTAlJCQ8ZR50l4Lm1PCUuYhM+BhP2JhZEOEwrX/s4MSvHIOn2IXu1nAVOimZVsia720AYLw9TP+mISY6o6gulZO/dRylU/8z/ZP/f5A3SP4nx5E2ufVjTwLwqTvOJOPMP2V58vwrYwmbUGaCmBHHEhYSEpIkEdD8FDkLKXUV0xKcSp2vhvnFs5nsr0eW8v7sefLkyfOfwmmnncbGjRtpaGh4t0PJ86+OJOWygf+VEAJcOU9VZAfYIpeR7fzn9LosKHh9z8+j8Z3vfIfe3lwRwEQiwbXXXptrsNKY275EdKANlxrhE+Z0+vqH0N0Oys88+/UHFEZOZH4NO4MQgvWDGRyKxJyy3J21U5nDSv6AQFBIKSWTb4CBp2Dk2ZzAneyC9lsYr/8+P/3pT4lEIrz//R+i9M+3sdH+HYsq+vDPOw6KlqEhsSQ7hx5hEU6qLEm8wh9c5zNgV1AkIjxunIozZnJZ5X/zK2MLE2oWFRPJFuiyl7nZKkq0IbxFfXTVO3B2ZyjxjfGgewrn1d7DqfUrGQoNY2lJWgrm8VyoBhHsQJImWLfmZG5MFNPclGW1MoUh8SvUyAToYWKvOggvvABZzuDcZeIIpQhPKqRwzzjW5osYKloOMRclnhCBgjBKQxWmpZHe34SxYTau5ABUywTeUwPCJrG/jsxYAYWT+4mH/AxfeBeVBTaJpUlefMpHxdYmsoVbc9mYbS18QF1LsENjwpsllSrmN5MKEfEQ0ZeWE111MprpYsdHV5Odm0VBY/HsAC/ecxyf+PpW4tlm9vZpVHgkCkIzcMdqoaifQkqZySF7B1WVmFEzjB3VcDogm+w76rTYyw5GyVnnRPVx3J8a43TOBKB/e4iV39uObdqs+PxMrjzfx+MvJkikVAoOFBBsnqRx3BwnL25Kc9wcJ8UFOUH65MUuHlmVPLj9j6TuhDo2PzYEQN/6YSZPMnB4NDDNQ4UIATa+eJjQPGqMsjq8OmcjGFUZ7E1SHDdwjAsktxtt+nQATv/6XDpfGcYV1CmfXsDvrlxDOprznBa2YHy0j4fve5riWBUVc+qpL3cx3p2gb8s4cnIC1e0iK8GruytJDIYpkkaxJInRtIIlbBSRoItppCQ3ctZJvzKH0blxXOkS1A6b0XqDjedNUNGuMHmDTHm3jzF8qJiUdLlxR6cRHCogUhpGqCakJYyswBpPo6gyRsaisNqBrJUy3jaBJTSsAwX6gJzgLGw8KQMtJSObAtMh4YodaAOsA/KfjUJvuwmWxS6OxUahiS2Uavu5+1ObaF49nWipINDpAaHymvArSSo9c3ex85SN1L+0kJqtjXjSAlkCsgZKNouFShbHgQzo3Jk1xUayUhhoqJggBDYqQuTuyZVkFelABjPYaKSwJBf+Sj+uwjIWf7SR1gd2MbAnRbIvg94Rx+kC08pdI6sOlcE9MQJVPs756UmEOiKUTC1krC10cJ5YhkXfhmE8xS7MlMnepzrfUGg20iayKqOoMq2PtdP5Yi+l04qYf9Wswwu/5jkqedXyX4CykcS7HUKePHneBqZtMpgcJmmlAAjqARaVzKUpMIVabxVlrlLmFM2g2JlfVc2TJ0+e/3TOOussrrnmGlpbW5k5cyaadriQde65575LkeXJ8w4z/Ax03p7zTS45GQqPzQmpzkqoef+hfskeUL1H+h6/E6QGcpnV/hkHLSneDuPj4we3W1tb+epXv0ppaSlXXdBC+6btJFMWXjVLXa3GzJkzoWABlBwoJNh7H4w+D76pMPnqXHa2sxxqPwQDj+WsMyov4MeboqzsyX3nvKTZQ+qV+3n11VepXzGHEz+wlMzwLDZaQZbU/xdKegAi2w9EZHPXT7/KpuefBcXJLf193Hf/A8Tjs/D5FEZHszx8Wx9er8J7T7qSaakYSTlFYXUbF46u5FVzPtG4h1b7BOpOv4yp7gwzoguZ0fsyz7oLURIrKCmPUDv1v1FC38CrtNJyVZbde0pJq1Oo7E0wu6qVCncPwxGbzR0WL41eQFmxm5iko9ZYqJUSf06exXPhKYiYjfm1FhQ9TODsP2CULUa1q1CcNrakor2S4cSunVy/8GdYPvjh5stZY9ST9maZsnQtS4YqeTSmIs24m6zxPNZLLoquKkSUOjFChaR2TcVOFpJ6wSZQNoR84lO4i4aQHQkyPXVk952OaHiJ5KiO3TqTl5s1vtm9g5gZ5JWCes4/tobtNwd4duUspPIEGdWkc4OD/47cyPhTH6et02RBiwNJrWfSnm5KB+KMxIupnzuJ88duZn9XPyc21RCozGW9b9iZ5o6HY4xkluH3dqMquc+Lo1FBLSoaJgYSEtUcWrh89c42UpGcwPry7Xv4wJ3LmFqn8aUfhxACqstUjl/g4q5HYwA8sirBL24oxuWUufJ8P8vmunDoErUVbywlCSEYD9v4vTK6JjGyexxZlSluLDiib9bOsrO9DVOYqJJK16QzqfG9gKvMgffTn4a1j8GO9bnO9VMPO9av+PEpPmJWjMVPLSNSEqYmsYjp7VMI/PrjKOW5AoSaQ6FpRW4RKzGePigyA+zZ0sGtpd9l9OwxtIyDC1/4CI3TlrD00zPoWjfC/tX9RNZuJZuIszE6BSmToQIvpXRTSTst4hXGqCRCEZYEtiwwNNCTCo7xFANzHLx8SSdxv8Foo8L45EHOufl4bFkh7hwFSeCeCGCqNt6xApSUgwwqca+NIyWhWhLFNX6iExnSkTRCOvReZEk2hjODmtXQLEHhmM4Zt2dJeyDpVinvkLGRMNARyPgZxbIcpPAccGKWaGMBRQwRdqskHQnivijlCR+ylMRGJXevfhZFZNlx+gaan15GadtkhCVjWCpOksiYB2RlASjwF7aOWCYyChoWMhI5MTmLQEbWFXzONMm4giUk1AO+z0IIEqNJSqYWUtZcwOqeLJYJsgKZlITDaWMLUH0eAnUBfDW5z4O/tGqpWlhB/QnV7PpDO7pHwxXMLbyl4way9vp3BO94sI0tv91FNp7FtgXRvjhFU4KMt4cpqA8w5eS6N5z7efJCc548efL8w7GFTdSIkzSTJMwkEhIFjiCnVK9gSekC5hXPos5X++YD5cmTJ0+e/zg++tGPAvCtb33riDZJkrCsIwvC5snzb0HnHWAbuZ/sGLR8+8g++34EIytzRQKbb4CC+e9cPJGd0PpVECZ4JsPM7+fE3bfB5Zdfzm233YamafT19R0UnvtslRO9EqoXAqTYNnoaS4+/PJeRLkkQb4fe3+UGSQ9ieqbyf7um8tjD45RlWvjYR0/j2BlBUqkUT+3qxFbdOF1OntjeS/yPfwRg5IERku7z2AFAmBU1Tj7f8jFo/yHYaXbG3sOvfn0noaiL2vI44eFRPnj9MBec6OO9p3n5xjf209ubJpES7O+exDeuvw/30NM0ih9woVjHnsgCnA6Zslgn82e08BT3sMk/Qrtdzb4X/guXVcgUbRKVp8wFVw0PlOzHHxvHKPTw8z9cQXPtFu7hAnxSFNkV4uG9sxiP6hR+eRiCKdTJbTBRQMXe9RQNW+x+ugkzNBXFP8L4PVein9GB5JDAlihr6ub66YKKzU9SGRjDRuKHy2/kl1N9PFdrkKrvJCK1MS0bJdJhEZ1aTLq8lpEv1+KcPo2JobnYFWnot7FMEEkPA7/8b3yL15BJFiAP1yE8OmOvLkIrGaV8RgQctRiuqei24PyWj9HXfSwvtnyU4JTniW5ZQnx3JZWlE6zpHCa1L0Qy6uHJl5Is10M4+0O4JFjoGuG4xfV87zcpoJBVziS/uMGNQ5f4/C3jB+wqjmHGpGn88tuFVFdXH3WelVHF1dzILjbSyAwaOCTO6p5Di5cOb24+T2vQ+drHCtjRnmXhDAevbk8f7DMesRkJWUyqlOkbNukdMnhhU5qSAoWPvseH03HknZdCCL77f2HW7chQ6Jd5f9kII8/uBWDuZS2HFfpLW2m+tO9LdPp7KHfNY0ZyDoEpjZR9/4O4/AdsVqc2w9rnyKoSd9Z0MdrxLS4svZAWbwtOxcl3Jn+HZ8afQXgdeDYGcrVrmgMHRea/5jn7ae798M8QvTrv2X45BcudxLujaKqKKWeJzB3imA834it1UTY1wCP3DxPKNqInorizUXThZD8zyMgO5kgvIVk2lXSyy30iPcl6LFtDiQocqoonITFN0VlT3EvGvxk96Wf6qjOxVAcIgZx2k6gexRH1knVYRN0ZSqNlZDwysSKBGQPTaaN0x7Eki4wjjZbWkZGxFJNQ/RC2ZCPZEsGRQjymijsu4YoJgghSuHPvIcKkQduNYmXotqciIbBRiBOghAHGqKA3voiC4QTL7FeZY9pIVi0vcBEpNF4rEeiKunCGc97cksjZdryWMZ3zbFawUZGxEVgHjT0UyUYWuVAQAiTQvTJVc8qJDcaRlRRGysBKWwgkTHRsS6A7ZcyMRTolkYwYaFYSRbJJR3L2IkJ1IoTE8Z9pOeJ5lmWJspYSOl/IZf5bhoXQdRJxi+1Pj+Cb1MPMcw6/Jrctm633tGIkDXrXDSIECMtGWDZlM0ow0/nvYG+FvNCcJ0+ePP8AhBDEzQR9iUFkSSKoB3CrLhYUz+H0mpM4tnQhZe5/IX/EPHny5MnzrmDbb+DHmifPvzOqPycwA2hHKRhvpXMiM+TE6OFn3lmhObQ2JzJDzv84PZDLGn4bnHnmmZx00kkkk0kuu+yyg/tfzDaze+xTfKH0FpKSg2nFm2F8CvgOCHLi8PeFTz6V5b6tfRg4KB4fIfFDi/nzXVx77bX0mA1MBKcwtXkq84osNgOhUAXxeAGZvRKOptwYG4czRGbVcGvq6/SMGzx70z7s5NmcMssiI/bS57mEeErit0/EOX6Bk8HBLL3DFoOjBv3RELOPLeWCRTORVSdpdwHxYUHKSvGRKesptIvw4CdCiMRYC8JwYSagd1Dhh/Fhzj5/Ob/Q7kdIMhZxuvZtY0vvmRToYc7tux01O4CQoFkvxSjaiiRlkeUssidBZcWzNMlpiitl2qLlGEYNSasQn7mK/kgU0eOgdGQrK27+AdHULjRjEwiB5kljtIQxS5LEBOwf60ErFhjOYiypGKtqKobzQsrHOrFqWglHzgZJxZIFkWQAracRzSwmHXPRXKXR223hWfQy6Qkfg0IncrJBW8PxFFSo+EUDv37501jNbbhCJv7mB7C3VzIwYqPEy8kmch78qiIR9MnUValEEzaWDZ19BkliCASk/QyMWlSWKIyFD82BoUgB6/YEGU9kmN3sOOpca2DqYQLzaxz/mRbW/nIPlilYclXTwf0LWhz0DBl8/vtjeN05az8hYHK1SmWJyr1PxPjdU3G27MlSW65SUqjgdkpcdcGRr9XOfpN1OzIAhKI2j28Nc8yBBNfOF3sPE5rbkm10pDvAC4PXbmSZaObCWWegDe6HlS/DpCaYtxSOP5vfDtzJH4f/hCEMdiV2cU/LPWiyRoOrgU9Wf5LUdWk2/2onmbjB/CtmHBEX5ITtuwbuIjDFhVljYZzdw4raD3PXylJCoQm0Yo35rgXsWz1E0bkK+14cYWJ/BCNt4jYMFNtGQmChgVBwyWnQZCQEaUM/kAGc80v2hgQOr0R1rZOpFePsb3WiJk0mqjuo3VhPtGKQbec+j6VlKdtfia0pFHc1MDajDz0RILY4yeCkDOq+AqY8GmGw1CCm6zijPnxhjVTZGG0nbKT+lbk4ki5Ml4EddyKknKWOQEJzgpkVnFT0DDM8m8kIF48PF9CXqQVsEpqCaUximBpMS+XM249nsXMAyzbQidPALnazCAALmWPuPZXexlH8QyVoWR1FtpCFhS0UTLRc0T8EJo6cTcZrthuKoLipkMRQEkmRcRXkrJEmuiI5gdmwsa1DRiAOOUFxfQllk3X++Ok/o5pZHC6BmbYQShpMGU3T0K0ExrCNIplHfb4To8mD24qmkE4ruMtzQnn78wNHCM2yIuMMOkiMJxG2QFZlUBQsw6ZyfhlTTnmdAq95DiMvNOfJkyfP34EQgpSVJpKNEjPiZG2DgO5janAKF9SdxdKyY5jsr0d9m5kvefLkyZMnT548/xFM+yr03JOzxai76sh22ZGzikjnfFxxv8MX/P4WGMxlA6MXg+MtJAykBnPWH3rwdbs4HA4cDgeXXnopd/7ulzhKVBbOqmBfZCrC8uNweCkq1HJZzK/ha4bq98LoC+Br5pVhL68JOGGXhIygv7+frq4uGuhhItbNsXUZvnH2hXzl1Yu55x4bv9/PxEqbgjITR0BlYQn8ZkeYtQNZ+vvTxGfrPHzmLVQGR4gYRayOJ1g5DLIMmipRe3YRW9d18OHqJzgruJVtOz4KM4uh9nJ+vNaie8QEyeD78elcOesxzij+Llt4iXhJG4mMzEXWWhpKH6U5FqbPvgiheclaAtMCd8kofd0uxid82MlRtPZuZi2Zw/XLHmFzMkRXzQB7Uhq9NyXp3jzAxshuprcsxV+8iZHpe5lyxm4irQ6Cv9tG0awV9Fecy/ufTdBYfxnvS+lMZEPEg2leiL9MMtyF5QgRMyfwZv1oQqDiIrn6VHTPZMomT6Nu6jAvPK4hsBGSgiwJQCXaV4TiSdC5X8U+UMys9mP30LPrQ6xJ6Kzd1cyS4HPc0PseJnlkhpyDSEWVSO56YoMR9B4dfUcYp/gh4/J5WMoUtisF9IyGqZDTdJeVkp26ip6dGmZKZ2plgCk1y3A6ZC5Y4eGux6LUBEaYXdHOY09NZ8Ko4IuXBThmpoNI3Ka0UEGS3tg/1l/m4rSvzD1i/9iExWf/d5xMNjevzlnu5pPvDdAyWUPTJJ5Yk8QWYNmCkQmLkkKFWEIcGiARg5EBqK6n0K/g0CXSWRtLSVLX4IbOXLfi5sMtbyodlTgkBxmRwdIMXnas4snW+zlhdRcf31eV66RqMOsY9if3sz2+HVOYBNUgGTuDJh/K0HYFnZiyi/Z1IYY6t3LOTQvwlR7uJa1ICg7ZQdpOozoUAk4/JXoJv1xxO+vHNtL+rRiJQY3HrZfYFV+DWZukQDuDjK1jSfJBH2FJkujTWzDVtZBKMkg941oVCgYmOjIWup4g6LQ47aol/LrXpGHNVPyDpTgjHixVYrR+kKbnl2DoBp1LtiEVQWFvHbIlo3pHUP0SpqLxkQ2P4tUy2OMrcFrFxIMJDIeGd7iYphePwTXhR0s7CNUI2o81qdgHzpiClpQIjCZxywYNnn1kcKNKWSpdvQeEZpms08B2GejRIEJSsdIOYgUJjMIoRXsrSBpeJOwD/y8H2oSP+vXVgEBzQEGBIB1WMNK5YoOC3PuRIJfhfFA6tsDOWjSfUU/6gHWLEILutYOkIybCMpEUGUmWEZKMIguSw1E6n+8mNRwHRUaSsyBboAgsLFBAszWyCYNt9+0mk5IY74oxZXk5wWoPe1cNkrVUXIVOUqE0dcuqiMYU+rfmvJvLpgaP+ho5+ZvHseWeVjLRLPHhBJpL44I7TqXx1Po3fG3lOcRbUkCi0ehbHtDvP8rqc548efL8i2PaJgkzSdxMkDCSCAQuxUnQEeS4skXMKZ5JS3Aqc4tnHvaFJ0+ePHny5Plb6OvrIxgM4vV6D9tvGAZr165l+fLl71JkefK8w3gaYNrXXr9dkqDlRhh6MufPXH50f9p/GEXHwvRv5zyhi459c4/mrrth4A+54oXN10HhMW/YfdF75/DSxR5syUI3vsdpm25i/+bjKQ++QDID7tKTABhnhD/xW5RalXNqv0+AAuYUrSITG+SS4AsUl4Y55azrqaiooLi4mLGxMYoi+zlvzvuRJIm5c09l+/aBg+d9f62LOv+zLM7exw/7TwPzDJwOlUvrnmRqaS+SJKjxD1FqPERtsUHRnI8xNLqRUwpuZ8GxSR6KnspMbYz3Fn2T9qcsspkMJ3Ac25TTsW2LxFAPqUgPetZm4doSAlorJer9nKS/il9KoGFw5y0ZrPd6SNZFUVM1VCSupLRugM0vJbH6dyO2r6az/0VOOSHLeQmbvfuztLcJrtkl6B6rwMwMs3V4Fa7KeiafdRvDho3zPQqpzR+gU5mBUVpHxtWL7AxzxTPvQY5KGAUZ6rfPZ0D7IVptCk+FRWbEQ+mT1zHY10AmVILXZTMxMsRVi59gS/BSwhMKkiWhSBKVPh8ZO4tkBBlK5GwElJ0LmFj6KpmkRdrMUKrb+HdkcXhHOHFiNsMjCQwP2P4soWUD2AnoXCMosSOU+zvRKr6M5JjE5tIgDTUBSotddJf9ghNuiBAfCVBTY+F0HA/AjVcX8uFTo3jab6JvMI5hu7hj37d5YaPO7Q9FiSUFx852cN2VwTcVm49GJG6RzR4SjmNJwfzph7Kl66s0Yu1ZqstUsoagvEjh4lNyXrgM98MPrsmJzdUNBD//Pb70MZ0vtl1Pyt3DePVsTt93OQ7VweSTDl8gKtFLuGnKTayNrGUsO8bz4echFeNPxf0sHfbTEvPBYDfMOga/6keWZCQkvKqXiBnBqx76rJzojbPnuf7c62Y8zPon9nDSFYeL6pqs8dW6r/LAyAOUaCV8qOJDdLwyzOqftGNbflzDGgRgzB5DGXEQOrWToY/fx7Sfn4IvZeDCwgaqaMdXXsDE+Tey6/e7EYpO3dh24qqbYbMEHCZ2UCYVVnjoyy9iXSLTv3AX1VtsFrx0JumgTHFfNRl3Ei2rU9ZWh1URJ1Xdj6VCQdlOblonsznUQEvXAGlnlurgGjLp5YwWSHgnvCiGRlFXJYYzgyOloYgsEzUpNp2h4x8BT1Rwwm9sCocFCdOLR40jJIWu5GRe81DWEgEipRMEog4cIkkaN7ef6WdWv4XDqmRowkNwOImFik3uGlfKJfmiKBKRoQwyOTuJnO+ygoRAxjogyh9AQGh/hEw0i6zK1BxTibvYRTxiI1k5X2fJyhUWFIBt2qQjGcbbJ9CcKopLRdcURp1hhLBBExRGKnA6HHjLPIT7Mzz3P9sAaH2ilyknVLDz8R4ASpuLuOTWuTi8OkbaZM+z/ahOheaTq476WiioC3DiV5aw/JqFjO+fwF/lwxV4+x79/0m8JaE5GHzzNyshRN43Lk+ePP92WMJiJDVGzIwT0Hz4NC/HVxzLzILpTA02MqdoBm7V/W6HmSdPnjx5/sUZHBzkvPPOY9OmTUiSxAc/+EFuvfXWg4JzKBRixYoV+e/aef75MRMw9iLoRW8qtv7NOEpg0uVHb0t0Qc9vchnFdR8B/ciiY29G60QbP9jxcwTwmZaPMatoDgTnvPmBQsDgowe2TRh4FFw1uSzo17m7rZ0d2FLu9ZzRxti7eYLePVewwbWM4n4/31kxC4C7uJlucv62USb4L77B7R86hntvOZkmrQtfiUSJGSHsup3//d//5dVXX2XSpEm5YoLAsmUFPP74KKGQQWOjh4uOEejbfwcSfKDwFfYPT8ZbPpszCw0winAqw1iZGMUBk/dUvgx6H5H9m0jhotSd4QJpJX5XATpjhMZt0ukkjZGH8e13Mmo5KdRjfLXnVAJ/uphntm4klPKxtMXkkpPCIIFtC6TEJpTP1eCovoCyM69hurqOjzZu5afPb+H+3QlsDYodaVZ3+rHGilhSC54CN2m9F0sxsCIRUm0vIsJtxCImRYVerI7jcC2fiWuomIhjkKRsMVL5czKeT5Dpb6bg1J8TmfIMlTVjhHZqJAZcmNtKkHprSEQ9BB1juNUMHinGM+uKcflbyfo8eCvGcXTPxa35WDbdy9a2DNG4gVOaoMiIU/3I5byY2U9Jk4P64gnOMlfTsXc+j607G5UEzlkB+PAfKSosYiAzgDpLoqS/BEvYJOPdRDqfJrnvZboGA1SfcQNLCmeyw/scsitOg3TcYXOmqbADUWgSDsskUmlqve1kstXEkjmB+JVtGQZGLKrK/vY7KhuqNWZM0Vm3I4PLKfGJi32HtV9/VZA/vpBE1+Cc49049L/wZt76ck5kBujrgK69jBX24a/tx4/CrvROUkujzAwsIjKQoG9riLKpAYobckmKje5GGt2NPDf+XE5odnvA7UW3JfAFYN4yAOb45jDHNwchBH7VT1ALHhajw6eh6gp7C3fy7IIHCZa46f3lh5lmT2f6+Y34ynLC+CzfLGb5Zh08bvVP1pGKZhkfiBIajOFWneglHvSdAczH3IyespsGowzXDypREm6WaispdYxRVF7MrifGGcssZWrieeozmwCIEeAV8xzkYUFCwDrfRkYTY+iSxnDLPhJ1I9RSjRKxGXUIzIlCqnqL0bI28dIwEjZ1ST9Z/0ayzmH+PD3IsXvDTB0bo6MgiTNRRrhuHCnjwDlWgivmQlJMXNksDVttOmYJLE1CyBAuh8CwxuPDFzDV20rC9jGaLTuQaSzAlvCEAge9lC0U9N2LeW5mB7F5UWaunCDjlXEMF+COWyiqgiOoY2VNUlEDGRcSNhppJGx0EghUVDnnz/yXWjOSRCqUQXHI7HuuC29VAGFLh8oGSjLBpgJivVFsSyJtOkgloKxIY+oZk6heWMb6+7eSEhkKXEGOuXIOex7fj6IreOtKiK0ZASAdM+jfmvO/z8YNdj/RRXm9xoIrZ6K5NGae+9buhlEdKmXTS95S3zyH85begZ5//vl3Oo48b0BPbT5LPE+e/18Ytkk4GyFuJDCFiRCCoCPABxou5PKm91HrrUaWjix6kSdPnjx58rwdrrvuOhRFYd26dYTDYa6//npOOOEEnnvuOQoKcoKZEOJNRsmT55+AXTfkPI0hJ/hWnvf2xkuPQHwv+KaCo/j1+7XdCOnB3LZtwNQv/82num33rxhOjQLwi91384ul339rB0oSuKpz2c/ChPGXIboT3HUw42Y4SlLCVObyJL/DIEuAIqLJIAD9qSmko4e+a0YIHbG9t62NAmsMj2yTKUuwz1zH/XyaS4s/x9lnn33YecrKHPziF9MZGclSXe1AlYycPUl6CO/IS/zX+NM80LqQpqu/Ss+Lj6OkNdbsUImbvVz//iQkO/Ab40zGpl3UU+/LcNy0Gja8uoBM6kUkO01bL3i0FFUzJqNVzOT37eXEH3gAPNVYmsyje8r5xPHTaNK6GE3aRLNZvnvaHmxnhI1M4jTtSeqFylcuipNOK7y434E861g+cuvzFJFm9qQ6br7tYQonbmV8zc+xEzYYSTJ7VjP4bYnwx7+EyyxHDlUyHi2C0hDu4Gas8REUYz3CU4yzsQ3hNNGcFoFqnbTpI975McZGArnb9LOFTHZ049ETtMYrsYMxvL4UhR+8m8T9H6XWWM4XLwvywDNxbv3tfpKWQiLlRbf2oYxX4J4Y46pldzM96+X6VR9kPO7EFjIljgjJAQ1bcpFKadjdEgMjA8ybN49Tz23kf278FbMadbzuDCua1/ER76f4cW+We7f/kT3iVWYuWMdx5QcWbPwtSJqHqfWCiaSLj526mO09TnbsMwDwuCSC/r/9OmUkZPGD34TpGTKZMUXD71UYDdkYaRPVkbPj8LplPnCm94hj2xJt3BN8Fn/jfj7WWUtA8UFpJcXyoYKCEhJFWhHxsTSPfH4dmYSJosqc9/1FFE7y0v1yP5pT4aRFJ9GR6mB3cjfHH3sFjYvmQ2FpTngGRrOjhIwQDsnBtxq+hUfJ7Y+PJll/+zb2r+wGTWPXyS/jrdapWVfL1tWtyD4nA5uGueCO08imTFRdRlZyj9OGe/exZ2sX+2t2kQlmcHhcFPZUEugsotbTRKC1jIbfLMLd4SZWGaNo2I3XTDIk1dPWU4MntI9TzZ9iWhKmLPDbUYrpZ5e1hAjFCEBPOJCwEUJBsWXmuUf54Nlxxtd38GzrNIajoBU4MBNZMkmNjDtOtmQbj2gFPPL+NrJoPD5YwMW3z2brKUOMNrRiG6X01tZRuNfLpF0Wy1/sx8p4kTsKOfZehcFpFqbbpmQgg62oRM0AG8LHIks2siSwxWtSs4yaVRBApDiCZgqmvDqVho3NjFdEWfulxzAdEgt+vRjf2iZUoREs9zPUlj0gTpsH8pdVFLLYqCiYOYH5r3NVbYEtQKQtVKeKlTGwhAzkPK5lWXD852aTmsjwp69txxIykiKRtN2ExqD3rnZ0WUMaNfAf68UZdPKe/zudjhd7aH1sP+nRKI5iHxXTC2g8qZI1P2tlbG8IT1Ch/ekuZFXmmI/P+ZtfH68xtHMUM2VStaD877pr4D+JtyQ0H3/88e90HHleh4xT5VN3vMO3heXJ8x+MZVsHLTGSZgrDNih1lbCwZA4zC1uYGpzC9GAzdb63V/wlT548efLkeSP+/Oc/88gjj7BgwQIAli1bxiWXXMKJJ57IypW5Amj5C5s8//RY6UMiM+TE1rcjNKcGYcfnclnSqg9m/ziX1Xw0zNjRt/8GtL/IPtYV/W87eNo3YfAxSHRCeEtuX7ILwpuheOkR3Wto4Dp+Qh8dNDKT7vPc3Hx3GMMUfOzCQ4lG53IZ9/ITrKTO7KH3k622qa6u5lc9DRR7dyF8JusnNSAQbGINi1hxxLncboW6ute8ah0w/Vtk113BSMQmaeicULuLx57dwvoNc+jvBme6i0lFMUhmwFmKZKUIShkWBsYgUEm68RrqC6/g+k+cjBFpZyTmxF89hq9mCt0TQeysQqp0IZnIOpxyGrV2HheO38xpZV0sKP0RpzS/SJXHYNuUfrwFXycQqkCSGigp9HH7D67iR/3H8+t7f4dpKwxTTseoys8e7iTov4LC2V4G9tyNPTCMJJuYYR/p/kqyPg8OKcEi359JlK5hcLSN0E+6SO14GcsVw/pYIYECH7VWhPqeGp7ZcRp6T2muoLftRJIEhpFh99gUEoqE7O7BbdqYWybQtzzJmD7AhrWL+cYnF/O7B/oZStYiBOweb6G6JIMTL+HYAmrUF7BsCdtWsExBIBQh/ewcdnv2kBzz4p/vpXhDIbfccgsej4c/PRQgmcwVLKupqURB4fHta+ibGAFG+MK6r/Hqec8A8FK4k22Oxcz26BS4p1Fd4OOESsHvx3/LvvFBpvnOZCR0PPVVRxebBxKDtEX2MaNgGiWuQ4s2t94fYdPuDJG4TcaA4gKV7X/qJP2zdnwVHk69cRme4qPfwfntrm8TcUZgXiFyUyFfmPFtCBaxkCI+WfVJdsR3sCSwhMnuyXTtGCGTyBVts0ybodYwu37fSs8rOWuXmZc08/EPffyo5xnJjvD7kd9TqOU8njfHNjPPPw+A525Yw/6VPWTiWfwVHvxRF1K1B+1xJw45Z/8RG0rwyv+1seOxblxBnbO+PZ+CWi8bH2rnpaseYkDpIytnOPWJOmqzI4x5ZxC3ZQL9pWiKGzNp4DCcCGz2SXOYsMqQoxmy2VlMFtvYfuJWnjshQVksxUd+VcL8sRdYy+kkhZeGddNIBFJMVExQt34Gg73T+cn/GaTDZRiWjIqBiGVJajHCFWNk/BNsP3UP7oFJObFWyAxXZNgbrMHUttPypxlYBKkuVNk9V7B3sUX9bhVPXKArKeo3+Kjb5MLwpEiURHBnPGQUD6PVgsKQgT9koqU0TByIA7nNkbJxtl20iqX3HY+EhJZVKOwvYsGPzycTTOCbkMl40shhmZFdYwih4iADiANjCGRsZLIHnjEJGxndnXNsttJ2zhNDCGwrtzYny6CTwkbNWW1Ygmevf4mS6YU4C52kIgayIhMZSLLn6V6EaREs0xDJNMM7xnjplg30vNLP2p9tQVg2gVo/M05pYMl/zUHRZIrrvTzy8edwenKvh3Q4c9S59VbY8VAbW369C4CGFTUs/fzCv3us/wT+ripVa9as4fbbb6ejo4MHH3yQqqoqfvvb31JfX8/SpUd+iObJkyfPPxO2sBlJjxHORpCR8Woeip1F1HlrmFs8kwvrzjnsy1eePHny5MnzThOJRA5mLkOuYNhDDz3ExRdfzIoVK7jnnnvexejy5HmLKE4IzsuJq0g5b+O3Q3RnTmSGnHgc2/36QnPdR6Hj1lwMtZe++di2AV13QaoXKs6GwsV8ZsbH+cXuu7GFzSemffj1j82GoO/3IOtQfQmonly2dd1VEG2FyHZyqooErsrXHaaMKsrI+YTObIR7bjyy4OAiVjB5zyjtz95F3+j3+ezAlfzg1tP57y//jPXr17Np3hNky3LCej3Nrx9z7/3Q/3twlMO0byCXLCO8uxOEiWHJlJWVkWg+mbHWV/ELjZkLGojaQ/jSg0jCBMUB3iYenVjAXX8cwaVKXPaVh3nge5/GY+3gs8dNULrEzz07m3lmR5LBc65C9M8jpetkS2ag7I+xK+bA3XImxkmrGNBtOr02BWaKMjPM6OAWQmYx/btG2L72z6S9DWSq56JqLro7B9m8NUBPmcmypkV4Ft3L/q0xolIVg4VxYqNOoqF6FCEoa17JRyMd3PhAHVKPA5F2IWXbGX3qK1x50hcp3jGF+l4/wR6D34f9OBSJjKRQ4IuiuUsQSZlM0osyUsn8ZY/S+mMBkd1MSN0Mt3ZhThQQDMj0xxWK7BDl0hh9yQI0jxenruIIVPKJJU/zyxdOxOWJ4Y4/xLotPUi1KpbtIuY3aG5uZuPGjTz77LPMmDEDj8dDaVkN8445EyEEafNQNvDIxDgrb92GvCjND0I/wbQsvrdrF5M3VlCulLDgs0sZ1jbTHc/SEbmD3T+s58efraWh+vCaMb3xfj6/7qukzTQ+3ctPl/wPRc5ChBBMjGfRVagsUZmI2tQV2lRv2A8yxAYTtD3RwbzLZxwxpYQQJK2cSI6/gHhVM9RMPth+ZvGZnFl85qH5PjWIp9BBIpRBcypUzylkx2+2HGwf3DrCjAub2PNEB4om03xmA4qmAOAw4aSXB3Aks6xdWI63LJddbRkWscEEkpJbiDVSJmf3XEC8eIT4OWmctxQy0Ren+czJbLx3H7IqkdiX4pXbWznnpmOgOsOEZwzZlJnXM8aZ3SO4JB9dtU/xw7MrOOY376FopBaEjJmNoTT3E3KeTGogjssMI7JjJGWZZ1ckCVEK/mH+tFzi3Ic1pvEqO6VFGOi0PD+L8YDAHS0iYUgkLAlwHii0Z2IkDIanD7L17PWM1iUxA14awj7SjnGkrIRnJIAj7Kfhz7PIFsawZYPAkAd3HLQRB+pYNRkJtLSOJCRAxhHzIMbrUOQ0A4tsPNEssgSSlctFFpJEIiiwgWjpBK7xAHpKR7YPlPAzdfwjHiZ0E8+IGzWtYCsWtuVAwTjowSxjHSj/95dJzAJZ01C9TpJjCbLCDYKDFhvZhInLklAUgWzlMvKRcs/n4JYRJFlBpFVMSUHRZCRkTMMmkzDRZdBcGgjY+1QHtmljmzZje0LsemgP086qp2hKAaVNQY791Cy2/GYXrqCDmRe/wfvjm9D76iGf+561A2/QMw/8HULzww8/zKWXXsoHP/hBNm/eTCaTWxWIxWLceOONPPnkk//wIPPkyZPn7SKEYDwzwXgmhEBQoAdZWDKPkyqXsaR0IdOCTflMsTx58uTJ867R0NDA9u3baWxsPLhPVVUefPBBLr744iNuh8+T5y9pC7fzQMejFDoKuLL5A+9u/YipX4XIVtAKwDv5Tbu/Ib5pIDvAzuS8lz2Nr9+39EQoWZFLlXsrDDwKQ3/KbUd3wfy7qfVWc9PCr775sW03QWxPbjszkiv+9xr+6dD4RdqH/5dfV+xFaJ/jUr7JVOa8tbj+GjNOtvVO0olx/MoABYnf8JOfZLn22gtobGzkfHEufxp4kMqCKpa6Tj36GNkJ6L03t53qhYGHURuvpi4ao3PfbuzKc1l2+nn8Rgkx+1NFnJL5CdOCIQxhkxQOPIoGqh/hrObXAxcjVEiagldTRfzmgWewU8NEohK+omJmTZVYP9aJM+VFbmwhZTvRtmeI+XQ2DVVglG8gG9RJSSZ9XmDUwy2lDjTVh/VKFZt/9i1c4amkWlbgO/ZSfA5BvNmFNOGkcVzi+oL7mPLBUkZPtmjvS/Cd3lo2dBro/g4cGYOsy4/jhH7mTTqOZzZmEVIKXGVkxyqZ3VmGFjcQFogamc6mSpQBCykj4fF6qPW1c82K3/HbiRX0GpW4KzcwvcjBAH5G1ffzmw1F/OZKiXJfIQvUHXw29Wt0DJIBmRcmv58ZpXuJpV2cPm8CT083f963kXvXDqEsshgvL0OiEG2wic7oJD75uR+QCu9Clm3mvH8+lJ7H/TcPsmyWn08cdwX/u/2nGAmLqj2T2bdrmPVbdrN1ZoZUxsBKqWScWWKhGPs795GQBaYNkmRjmBa7O4wjhOYdE60HBexYNk5bZB/HOhex5vsbqHx5lG2pchpmlHLNDaXMqhb84SO5tRgAV+HRC6FJksQnqj7B7f23k7ASNLgaMG0T9XV8yV0Bnff8eDFDrWFKpvjxlbqoXlRB1+o+AKoXVrD6e+vp3zgMwERnhPlXzeKZb29lfPU2ZjpnUdXwEsePpJiy7D0AKJpC0xn1mBmLSF+M2iWVrPjCYgqrggyGJ3jMuQ6l0OTVe3rIpiyMpIHulJHSSbrPqWb+0ukEd5UyWtzPtA4J3BZZJUFp1KTIpZHyZUlEMsg67J2tkFysUpLo58ye6cT6A8jjYzjMJLFMFZbTJiTKiMar2c5CNDIUqx2Y7jRj5WEMYwnKhIqwLCRMFGwUbGwkVCwmtRezN+4kXphE6GV0TZtJTacPf4fOtCePw7AduPu8+IYTSJJN1iXTvNamZreNyLoPyL6vuS0f2DJUDM1HxQBYpoIuMoCFjMVEpSDjhFTAZrS2moWPB8GSEJKNJRxICJxRnYr9ARRDwlZsLKEiYx4oAPianVdOLlcxDz7XqkvFUV6EGYli4kSIXFaxgQMHSZBkwiNZJN0FmQySIpCQMDMWulvDSmZxaQaaR8NIQybjRFElCip1yqaWYiRM6k+oIdwTJRnKENo/gepUUXSFDb/czuk351wZZl7UzPTzG5EV6W1d65fPKmGsbeLgdp435m8Wmr/zne9w2223cdlll3H//fcf3H/sscfyrW996x8a3D8a0zT5xje+wb333svQ0BAVFRV8+MMf5itf+Qqy/M/puepIm/zg6tytMp//yWlknH9XEnqePP+x2MJmLD3OWGaCoO7nnNrTWFq+mOnBJpqDb3CxkidPnjx58vx/5IwzzuCOO+7gwgsvPGz/a2LzhRdeSF9f37sUXZ5/Zmxh880t/0ssGwdAkWQ+Of3Kdy8gWYWCBf+YsdzVMOuHOSE4MBNcFW/c/60ICWYyl3Gd6Di0T5hgpYDgW4vrNS/ov94ml9zQunkv9zduY0LKICU28ID6U74u3wmAZQlCIYOCAhVVfQvXoJKKy+3AyOZUv4yhsm/feuACbNvmf791C5s2bUIELLb9zwaWVB/PfJYdPoas537sA7e1q15wVVC09GcUHbgh2bQF5R6FIebwldHvMb/lWsp9+7myw2J+0olUdyXStK9RNLiP4fgoaEGKnE7M1u/zze+l2dhdi5gxm8+9r51L1f9ja/qrZGUdj4gjeT2kAwoS0D8xn9mWjoMswQQMaTYhYSKw0Yu7MY1cJrilOYnslkmkXCRUQXY0zexGJ1NKNfS0RFVlJVWTq1n5h2I6e9KMlzgwggZW0z4eL/cSbzyHwpNXk274M1KwEtv8Hbe98n4ua3iUkBLg3vB5KHEbyQOyBXYmxLnHPEtD0SYu8A/z5NQ5jG77EGlvCcn4btyKzWCsiDK6+djMz9Ek9ZFoKyMmypgU3M74sjKe2j+bnv0+lhw7i5mfXsGvb/0UdBrIyQLklz+A7igg01fDatJYo8+hU4qstbN56wbqrjRxOUK8tOYK7j7/YmacMJW1T+4itcVP0hYMdM5G1LUiOUcwIlPxT8SQJIkPTbsEJfIk/f3dFI+dhl8LMKf5SNuXGQXT0BWdrJXFq3loCkwmPpqka3UflRpcpXXTOE1i8awaAFbcsJj2Z7oITvLTfNbrLxidWnQq7cl2nhx+ktRt36Vj4Gaa5l4EH/0yaEfG4Q46sE2bV37ZRvn0IEu/sJC6ZdWoToXKOWX8/tInDvYd3x9m5+O9DO0OQyLNvuEpzK1NUJjOgHRISF/8X3OZdu4UdK+GK3hIFB/vjIEsEe0cIzsURXVpmLaGw63g8iv0rBsEp4f3b/8EO/TNGJ3bUbPPY6oGXeVuoipkl3aiP1NLymvReYJBlaQyPj3AJTctw62o3LZkjB07YcG9GTqO3YIzHKB81TwmUPETIl25h+SUViYGTqBy0I8lGSgHsnpfe7eSFRlFjhMNZCjoqkM6NoltG6RdCUZrDGqen4Ka8mIqNq9eZJLxaVTsE8xcI5i8LWdekcUCXntMLEA5+DgIkUR4UqjdbmQpi8g6kDDZdXIaW5aIFkq4ojJ6wokimXikMC4pxbhdjmE5UJIaWXcaJauj2AL5gBezgQ4IbFnBlmwUy0JCoCoCf7kHR5HMyEAGFZA0V86P2TQBCUmRSRs6qlNF9nrwOFNgWmTiJhaAoqIqoOkKRQ1eJEnCVeBEc6q855eno7lVRveG2PrbVppOr6NvowvdrSIrMvJfva8qb+V99k2Ye2kLRZODGCmT+uNr3vZ4/+78zaplW1sby5cvP2K/3+8nHA7/I2J6x7j55pu57bbb+PWvf01LSwsbN27kiiuuIBAI8JnPfObdDu91qe2Jvtsh5MnzL4UtbKJGjIlMmJSVpthZxHvqzuLC+nM4pmR+PnM5T548efL80/Hd7373oE/nX6OqKn/4wx/yQnOeo2LaJnEjcfDvcPZf9NrBzsLInwEZSk/OCdYA7prczz/kHCbs/FLOO9k2QPWDyELFuW8uYv8l1ZdA5y9BUqDqosOa7r57gJ3PPs/Oi8KoTYL6ajcOWwEZtm1r5frrnyaVmkRLy3RuvrkRj+dNLskVJ8FFX8Ha8SW2tKnsjZt87rxx6P413dk5bNq0iTRJ9kV2kV45wJ7L1+ElQDOzDo2heqDpOhj4Q87Ko+riI06jSoIfV91BZPAV9pRofKsgia64+L9ZWTzjJzNt8rWM73+WDw1/gydSi6kqdHNl1YVsfm4PW/YtZM+MWpJO+PIrJRT3VVI3/ivinhoSgZmY7jm4lAzCSjM2GuC5G2/GVb2XCxsfY0O1wBSTMG0Ty+ultiDIRGIUxxDEfU5SQiDiIRL9d7Cnb4TWSy+jxjawTIPCaVfT1LQRz4t7GOpZQtF5f6JwVoTOdDOO5tVUFRYy1uDAljZgJQpZ8+wiVm7+LNKkQmYv7SRd5iAZcuKXJjhryiqa/Rsh5kIr3sfIS+cgdy6ltEJmLBrEtmKkMhKSFWfrYDM1vl5Knb04fGlCFYLhKcNsMQqJ3PEpql9S+Om1Dq763uVEz+6lb3UaY+VcEn1RbFtF12SEuxEzHsLtVyg/MWfZZwUHCHhlfB6Z+foc9uhVbOrZhJLOojSVM2v4BgwtgtN0cOmHtjJ9+nRmzJjBEo7hG7Ms9nQaTKnVKC1Ujnh+a73V/HjJjbSF9zGzcBrFziIMTBx+nUw0twDhrzpU7K9qfjlV88sP/r3u1+3sfLyHgloPZ3x9Hq7AIRF508R25DXj1G0fpw+d+h0b0TathsUnHxHHeFeMVd/fiRCCrldH8JY4mbz0kL1M42l17HigLbd9ah2GpWCbNoZeiIMoqmrDaZccsagUqPYdca5Jx5Sw4ddtmLE0siKj6hIO2cbICvrb0qgvhjj5y7X0/HErp24cZFgr4YWTT6HsiSramhVa1qUp6JjCtsskQg4TXdVwTWqmMpzkuUXXszVjMWRJuOQS/J2VzOucBAgU0ghsOqot1nykB4EHydrOybc24hrVkCSLtDeBaqiYioTHcNO6fBthVzHbTu3JtWUUvJHtzH20mfK9VUjYjEyxGauzQZKJVcmUlzioeTJBJgE2GrmyizYCGbDJugR7TsiS8WZp2AgexwQiJaGTE15rW222n5hzVq7bomKhUCH2sJA/IwkYpYp9TGdMakBP5o4x0RE5I4sD3sxyrqCglkGycgYaspUm29VPdCBAYX2AUE8SDAsTFW+BjirLaD4dY9DCzAokSZC1bYQpsIVMNqkiuVxYZgZ/gcYJ1y1i+/1tWFmbuuXVOHw64b4o95z7COloFkmWWHbNQmL9cRRd4Zj/mnPEXHi7SJLEpOOq/+Hj/rvyNwvNFRUV7Nu3j7q6usP2v/TSSzQ0NPyj4npHWLt2Leeddx5nnZUrrldXV8d9993Hxo0b3+XI8uTJ83axbIuIEWMiM4GNwKt5qPSUc27tGZxUuZxpBU3vdoh58uTJkyfP66KqKn6//3XbFUVh0qRJ/x8jyvOvgq7oXNH0AX619z6CjgCXNJz/bof099H+Qxh/Kbcdb4Mp70AiUGY4JzIDyBqUroD6T7x1u43XqDgHipfnhGbVCxOboOe3oBfw6suLeWrNfiqHHNjvizNtaT2XFd5AV1cX//3pL5AY3oXPmaSB01m39hZOPLnsTU83Ys7mgdYfs3v3ICtm7uT4yS9A/0NUOLbhcrmIpiYAgac6V/BvmL7DhWZgU6fMo486cTp9fPKTgsJcTTVSho2mSKiRrWihteimYLo1zMWKRWvZbLANXIU3sC+ssO7xO2i0tnOxvYnIWCVXrZxBf/wUxqfoJD0uQGI8FaA98GF0aR9RrRzvSBsNC+eyZ8DEGO9C6XMQ9iqk0y08UtZLen+E40oHSaHSuWUZ77vqkzRXjfHU+hLufDyNbWax4/0kxTipruc4/vz9SA234/ZVce4Jbr7/2Qv42i9+hZpNorjG6NpYgz0wA9J1HB+oJOl5lnBbM+OPvAcjEsCRfBopfQKnyi/SP9OHZyhKdNTkhU37afCWkrSKefDRaoY4BafDYsIaI2u7KXJGCEUnEHaWVX1nYVS5aKl8mGOOHeSXF3iZiKexlAxJ4rSHk9y4+WUemXIy93W9h0iBxTm+NFvGFfT0BmxRxqTpF3HMtPOw5z1PaMUmnJrO3LFzuPLqQhx6bj6uboexE2eipA2CpU5mNTlp39tDXflupkyZz4wZM+joM1BkqCpVKfDLaL1tsG8YZiwCt+ewOVDtqaTac0jU1Zwqp353GW1PdeCv9DLt3ClHnX/h/gRbH+oEYLQ9yo4/drPo0kN3hpbFFrFP2gGAkgkQidsUuw6d2xIWr4RfQZd1qsJTEEIcbEuMH16gbe6HWph0XBWyKhOs8ZOcSPPCzRuJhQWO6nrEFy+F6W+tSLuvxMWC99fRs7UV059GNlw41EKScQhUurEsGNrQh9i9jURWpSm0FetXc2i3m/E+Z+JqTFBvFrPwSYve7QbDFTpKxMA7nuUFvRI7q6EiYUoWMmCh4ySKjI1AYqwqTEZyIMsCZ1In5knjHvWSKIiSLIjhmfCS9iVxDmiUvnoCnoDAMVbGxKkPsHxnDDvsx17XhEip2Jg44rl5IQBh2IxoUHh1Fe47k1gRC8uwwc49tg5SbDnDZrBRwpZkMj6JE+7LomQOLRA0bxCU7FOwhANPWEZgUUE3r+X/ltDPZk7AFDJCdiLbGVSyCCQsZHRSgIxpK6hp48D/W8ZGxRQyVtYmm7DQ3CoiK6OZYKZNbNsgEzOQTYHuVvBWBnDoLiKdEwgkTNuBnDXRXCp6wEM6YnDBL0+j84VexvZN8MyXVyMsm3QkA5KEsAWje0K8547T3tK8yPPO8zcLzR//+Mf5zGc+w1133YUkSQwMDLB27Vq++MUv8rWvfe2diPEfxtKlS7ntttvYu3cvTU1NbNu2jZdeeokf/ehH73ZoefLk+TsQQhDORpjIhjGFRUDzMyXQwLm1p3N8xbFM8Tfks5fz5MmTJ0+ePP/2XFB3FufWno4iH5nJ+M9MLGYyOpqlttaJGtv9Fw173pkTOkrAVQWpfkCCwOy/XWR+DS2Q+y1s2Ps/YKUhAdPLBY+ZOl27p1H6M5WlZf9N5YxJrOpYhS6NI/QElgVOsZ26YCtwuND83HPPsW3bNhYvXszSpTlfi6efHmdk1KSwqISde0vpGfJRVxHDaQ/zne98h2dXPcPmulW4TzIppoK5HHfYmLFYjFv+59sM9zTS1pvgj398mnvvPYGtlsZvdsVxaxJfma5jdRhkDQtN1qmqXEK2XGKeMY8XH2nnoegA2fSJXOtajy87zJPJ4xnwW4QLnSgLoXR0hL6ICzuR5UNVa+kTaZ4Ou7EG97Lr+YcRRZORVt2Jq+hCzAKY6evkGGcri6QOmvrdZGJJvrsqy8NyiB/f9j02PRjGoUnYQsZq8EPZmUiR2cT+fD+u5AAfXvw0c7R9DG+aS7FrgqRdS+jWK8i4i1DdQZRsETMvkYi8fAzdLx2HGvfh93RRW1jOTO9/sWPzIi6b+geGMiFu3dZC95iHH+++hnTSi2xFSeHHbQ0ynvChS1EGQmBJXvaP6ZT7ZNZbdSy40EOsKUt3ZDLD93+Q5OZFZA2BrkskAh288PVvEtjcxiPG8ShWHL9bJ61NQ0m+zHELllFb7WPD+hZE2zABv5evX3e4rV9jrcbAqIXlUWiZ4uC9K8J89rHvM2RZrHvpcZad9Q1W76pECIFTl6gf28B7e3/G1DoVX2MDXPNDUN9Y8imoC7D4k3PfsI/qUJDknKAHoLkOH/Oqmst49ekGXixcw7zhUaxTF8LsJQfbf9TzI14IvwDAe0reQ+3COfRsGKWozkfTiUfeSVBYHzy4PdERJlgsEyzO+c73780QmP6G4QIwsjfCyu9tY/sLexiQQzgSComicbxWBk3zEEqM0GBVs++pCRJRm0xCJWs0UCAGkZkOMRV5j4viT2hYD3fgEk587V4sIbCFxCLjZVT3MPvsefRLk1EkgSrSzOYFWjkOG5n67ZPoP/FlMqaH6Y+dTLC3hgwS41UdSJJFpGIETY1Q2e8nZfhwRVUKwk4+8FACWRKU7RfsUHfQzxIUbCr7JRY8quIyDBwJCVMk+NMXXuEscxG6w4VtCoQsIdk5D+aMN/feJguJjAccKWdOpEZCAmxknBMOcm7OAhuJEOXUiP0IIIkPAycqBqZtoeZMLZCxDuQxg8BCRsLEjUwKAZg4MLGwhUQ0bIMNpgW6T8HpcpEcMrAMGyFAZAwcPo36hcXsHo0RmZAQhoEs0hhZSAxaoCqEumNs/vUuxvaGSIbSFNT7Xyu3iqLJNJ1e/4bzITGWZGjHGMVNBQSqjsx+z/OP5W8Wmq+99loikQgrVqwgnU6zfPlyHA4HX/ziF/n0pz/9TsT4D+NLX/oSkUiEqVOnoigKlmXx3e9+l/e///3vdmh58uR5i9jCJpqNETFipK0MQd3HzMLpnFF9MotL59MUmJIXl/PkyZMnT548/3H8q4nMXV0prruunUTCZOZMH9/+yPEoQ3/INZac8M6cVNZhxvcgtC4nOPvfgmL1poicJccBPnOpk77MKWzY8AqzZzdy8sk5+4A5c+ZQXVXKULoLr1Pl1OOKaWg6XGTeunUrP/nJTwBYvXo15eXlTJkyhaQusXUki2kLmnwl+L0HzldxPk3VTTQ1NWHySSYYJUgRGod742Ym2rlq3jaslg7aBwv42u/P4aNXPI/80U/j9vpJGILb9pRR2f1eLpr0AwTQ2BrjvMm3EPr+F/ihPYMuXz2DyiI+Gv8Z30x/imV1QzxilDIUL0VzRFhgfoaJV6fz9eUvU+f0YdS5qB6N8+dtffRkNCT/XGzZoMR8jPLyOq6f9yiOYDdzEoLBAS/RoRrePzfMFZtsvvDcALWu9cw/Zown25fRmyjFHrWxS2XUshqOq2/luIoncKgqtVKYCxcFeWrzOIPxcrq4CMPyYAnB/b99AYeRJpsswpIDuCucTC7fzoVN87l1VRNffm4xA/tfxMrsZd5UD0VVI2wxGwjGahjuMMmki9C1NONGMYrLjZ3RyFrQk6qlqdJAjTWzSuxm3y8+REVmNkOigKRhoHvTdL80jYEdHTiyAtOykSWNhFVDwnShOCq47zkbxTmACPTgcUs0FlYjhDjsOubqDwSoSIRID8U4/5TJ7O7pwzRtsrYXTU7y7Iv7cRZXkskKdu4zOMW1PVcAPWLj6++CyDgUvXnG/F9j7N5N8s47kVwuPJ/+NN6yMlZ8fgYv3tNFd0rHrRYw0xSoai7WKbUaP/rQsWxtW0DjVJ2yJsdh422KbTq4vSW+hZ987QqMtIn2OvWnQhGLNZvTVJWqTK8L5ArCJQwkRaJkWhF/GPkDr0ReYYZnBpdXXH7Ua7/nf7iT0X1RUhMWPhyMlSZA6PRO38volB6C46WMnr6Zsx49l4ThRDYyIKCXJjQyZGQdpSxCT6yLjrPuobDfSdnjFzFoT2UGG6mS2hEZm1JrNU9JNZhCASQ6mI2EjY2GM6Vz8g/ez4Q/iz5ehmTnRN6KnVMQrjiyVI7DMhCWjNMG1bbQzAjFYR+esI0tZDwZDQ5IuhKCujYDsAEZS5I49etzMIWBnJWwhQKKdeD8Ms1rJNZfIBCKYMYLFpZiItkyQshkcWH9haezjImGSQ/NpHDjIskwNQfkZFCxSRVMkHZnCQ4VoFi5z5tc6UGBhXrAViMXp8DOZTjHYthIKICma+iFQSLZ18oVCoRhYCVTbHkwTEmVGyGSJEImksitAZpZ+PP3W0mMJHE7sweKEObW9yrnlmJlLIKTAtQvf31bi2QoxZ8+s4pMNIviUDjzlhMomBR4o5dAnrfJ31VZ7rvf/S433HADra2t2LbN9OnT8Xq9b37gu8wDDzzAPffcw+9+9ztaWlrYunUrn/3sZ6msrOTyyy9/t8PLkyfPURBCkLGzjKXHSVlpbCHwaR7qfbWcVLmcM2pOojHwNiua58mTJ0+ePHny5Pn/ygsvhEgkcoLpjh0xurmEhplLABl876DlmeaHslP+IUONpceJZmPUT74aqedXoAWRJl3O979fgWEYaNqhgmWFhYX89I776Fp3B3X+YXw1y44QuoeHhw9uCyEYHR1lypQpjNU6KF8WJDmSRZpdxoNFP+L5PpNm28t1ZTYuTUZFpYRcdmjKsPnW2jC7x7Msr3byubLd1NcG2LfPoq5khBvf9ygzancxlNnBg56fkZCKcNavY1T6Pb3hFErGgS94N9eu6mbrI0vpMAIMT/HgPk7whZonWeovxaUMcenoM9yaupgCM0WE0/Al7qVCD5MxgkjY1Dv6CU6aTE3JTLZQQfKUG6n2vsw1c++nyBlldLSAkVGV1fedhWFKjNsS9mwP0913cdG8l8mGNI4JruULG79COF1MQAvxtYu6OL52H0IkiWegZ8DFijNv4LgzbTbuivOzJ51MJGXcimB07++YkM/A8KXBW8RYX5Cno8ewcc80hqMB0oaMnX2KDxwHlyzYiuYfpLPwDD7z0w+DJWEIJ3YwjJSUkdxxJNmFnJCw8PD8/kXE9rs56dVnqAoVMioHCEVlsHWSg8VI0WJuizm4zrqVxWIDW0tPQI0FkS2BZetYBkhqFinpQdHDKFOfQZIOtzvpX9uH9dRWNGDVV/pYdtNi+u33MRDyEvQanLhwDq/sMpElQXFQZp8+izkTq/G4JKiqg0DR3zWv49/7HvbYGACJ227D//WvU7mojGcel0m7BFtXpXF5VC465ZAGNLvZwexmx1HHW+RfxMqJlQAs9C8EeF2ROWsIrv1RiOHxnKD4+UsDnHnLCQxsHqZkahGjlUPcve9uANqSbUx2TWZZwbIjxrEtm3RRhpPFY3jiffTLfp6rPBGfw8vAtCiNkXFO/ck4WneCbmsZyG7G7EpM2YGiwY5LnyQyfQwl24FupNlXnuSU8T8grfkSCgaSZCIUC9USaMJAQsFEJSs5QICEjSYbGIYT76gHExkB2BLoAqSkF5UsOhZxv0xGNUi7VLpnB7jksTRuKcEAU9hnzwbA0A22nbme7nl7yLrTFPWUcexvT8U5EcRExzqQlaxaBgoGJk6KOiVO/5ENjhgOQ2CrNvGCGM6RcmxbA2yknNEFGmnEgQKCo9SQxYmCgXJA2LXrtrDrmCGK99XhHQsgW8qBM4KNcnAr4ZNxZS2U7IFdgEzOu9lV5CTcHcPAgQBUTBQMwnuHMYSD8axAkW1QVGRhIasylpBJjmQAhXRc4CtSkSUJV4GDTDSLp9hNKpRm0907WX7NoqPOqfH2CTLRLEII4kMJWh9p57jP/oMK1uY5Kn+X0AzgdrspKytDkqR/CZEZ4JprruG6667jfe97HwAzZ86ku7ubm266KS8058nzT0DWMoibcVJmmqSVQjqwHqrJGoWOIGeXn0a9r5Y5RTOYWzQrn7mcJ0+ePHny5MnzL0pdnevgtsejUlKig2/quxjR38amsa18Z8sPMG2T4yuO5YsLfn1Y+1+KzK/h8/mYefIXXnfMpUuX8qc//Ymuri6mTZvG/PnzASj1qFQeFwRAleBP3QIknc0jWZ7uTHFB0+FevH/uTrFzLFfg7fneNOcU1tJYX0NJscHO7Xso9u9CkpLM1Xaiex9nuGwhDtcNDFcN4XBG0RQTU7V5eWUFY0GZKeO9hPYGqFkWpknbj27HyNgyC/Ud/Lp4O5qUZmeRlxt/G2DlwFJOrMkVLt1rz2DZcUEuSN7PT3aX4aycytDUC/mZMZuP8x1a/Pvo2V6LKQUIZxT2jlVQVF1KVfpZ0ukUWBIF6iByMommqZyrt7OiTlDqHkMiwdrwPF7dfQZ/+FM17ft7sU0dl/0Mxyrd+M12Op2DhFPjCNmGDKiawMgo9ETdWKP3IiQHigRzq6OkDJ2+UCHTfBtQxQVk5AJQTWR3EkmxUQpGYaIEM5nzOLaR2Mskejs+TIkaY0DLWTtISBgpB5Ys0eaYzmecP+X/sXfe4XJV5du+d5vey+k956QnJ70BgdCLVBFUQBALiorlQ7FiQbCj2CgqiqBYQHonJJDe20k9Jaf3Nn1m1++PCYkxIOBPjGXuXCfXml3Wfmdm7ZnZz37X84Z9Aqef6GN8Y4a25jhSLk5GdJJyDmIu+iVUtuCpOfbmyvD+0cPtzFiO/QegrO4UQmVZ7HY7bf0CkqSRzQrUlMmYtUuQLqsiGh3NezS/gW3G62Gp6jHtZNokqx7xVh4eN990fzdU3sBC/0Jsgo25vrl/d9uRceOwyAywp1Vl2Xz/YbuDjnjbUdtnzMyx8VsWO95rMviX9UwqHyCihChSDSrnluG6+ER+MSHJOTc8ia85iMfqpVFex1rOxqFohPwmAx97lI6JW3EnKzH7TZRDTzvttFC9CfZkpxHRenHq4+yVZyCaBj5rBMuhkpySJtDmYHS8kpTpwbAZjFd20XTibia/eCK+vig5wY7dzKFjIx3WSYYtNMuPYMK4y8Na41JCdNBmLSJDAIDdp22mdVETwxN6wAIlp9C2qInGZxYjkaaUTtzE6GASBgrWoVxjwZTI2g3SkXFsGRuoDlIeDWfclV+PgUL20NbGof1AJouJjImAl1HGAwPsPaGbyfFqAjY75ERs5G8UChjYSGHYIBs2MRMCyhgIR4YLApAdz6HnACwsJAxkRAwswwQM0HS8lR4mLamib9sg1YtKSCZE9i/vA8BZGeH0L82kdlERCPDUp17CUPPj8FVbl9ciXB/E5rXRv2OQ9GiWvU+04oo4mX3ltL87Fgv847zlTx5d1/n617/Oj3/8Y5LJJAAej4dPfOITfPWrX33NL9R/F9LpNKIoHrVMkiRM881/SB4PBorcb7xRgQL/gViWxWhujDE1homJLEj4FC9RZ4TFRfMod5cScYQpdkaZHZ6BU3a+cacFChQoUKDAfzirVq3i7rvvprW1lYceeojy8nLuv/9+amtrD3u2Fijwn84pp+Sr0bW3Zzj55CBe7z+cA3VceL57Jfohy4yX+9Zy/dRrccmu/1OfbrebO+64g0Qigc/nO5xUcfU0L7IIY1mThaV2vrMxdngfu3xs4oXH9jfXvOFFEPwy3mQLteEx0tu+yJBUy0OcS1SezLtyt9PZ109Gz7I5kncYafE7sWrGELZFUdwSZ/i7WThrDs5EEaXiLnKWjEMCAR1LzrIssoufTDmNX2x+B8ulHOlQMaFQjs8pT2MTcyxw7WDN9gjfP+n3jAzvoUUrYYP9PLorFuLs30csZpKUbfT0VPL080uZPqsDxWOxJjWX4Uo/QleORMxNXyKKLGcxFZGfbf4g6zrnIEsjuBwCA0oFylAPQwNPkBGGcOZynLBkF9tHfcS85YiyQsBho79rJUZ8AwgWclhnfafK0z2fI65XkN1gQzPtIAhI0T4k3yjek18CBMYefyccLpUmEsdLlgwjuhPDMJFkCUkEmwKzJtk40KFTXGRn2gSFmRNtPLsmxYf676FNqmS/rZ6OqhXEJA03ISwgZ+SwS0eygqtPrODAswcxVJPIpCC1k7wosobocmFZFnuHukhaY6SGyyjOjDKj5wWsVAnd115DxaFCgNmcid0mvKUEHc8NN5C68868dcYHPgBAcVjmnBOcPLMmQ9gvcv7SNz/WRUFksX/xG28IFIUkJtco7GvXkCVYMstx1Po53jmcFjyNVV3PMF2q55TgKcf0MZhLs1uOUT6nAtsWhZxNwHHQZOigQfqeFj46cR5FB18kkc2QENzYvC78bh9Fk/wEMrfyUNlOElKamK+ZhvUzMKMHKR6Qmb6mhpHJd9DddiWvxM5HNE1sVha/3I+DDFOstZBMkqmdyJptJWRtFomyATL+BK6Eh6wvjaTFcI8EGYrE2X/mOrqX7KO4o5qKtUtJeRxMWy4ybFYToY9S13Y60osQMTGdKUQTsAQQLExBQEp7MRFxkaCBrWRlgSfe0c24V2T6o2dgT+TFeVFS6ZrcRce0DqY+cyqB7gCQF4jtZPjrkSFgIaPhJEcWLwIWKm7E3adRtGcFznEXut3CSktYRr4s4KvezYIuYM+atE9zkGu2UdyXReCIAGzkDGSHjJrJn0MWAhp2ZLIoZMCScPhtlE3xo40kSfXGmXXlVLzFLoZa4kw+s5zGd9YhiAKx3jQLPjqbXX/chzNgZ8410w8f58BzB+nfMUjFglLqTqnCFXbyjh8t48F3P4m31IPilOne1F8Qmt9G3vK3+cc//nEeeeQRvvvd77J4cf7DYt26dXzta19jeHiYu+66658e5D+L888/n1tvvZWqqiqmTZvGtm3buP3227n22muPd2ivS84h88HfXnC8wyhQ4J9CQkuSNXKohkrKSAPgU7wsiM6hzlfD0pJFNIamE3IEj3OkBQoUKFCgwPHh4Ycf5qqrruKKK65g27Zt5HI5IF/M67bbbuPpp58+zhEW+J9DHQU9Ba7KI8v0FLTcAZkuKLsYis/8h7p+VWz+j8MyqPVWsXZgIwClrmKc0j8nIUIURfz+o/1D9VyaiuAW1h98nPH+Iq6Yeg0behUmBm2cWXPscU+pdNCd0Nk7orG00kFdQAEWQmghJdE+LMcAX988lVGhnOi4k2WqQdAfwZKGGBuK8uLOGXjO7sI5WeCkBdNZUlmGv9FD2i5SX3MNL7wQZsWBiZwwNcn8CY8zpHSQsnmY8N4c2Xvs9G73UjElwK9PuZ9gqpPmoUFe2baG4ooexkYOoFsw0d7P6ng5Zy+exk+mCgy2pOh1RsmJDta3lvJhdRqBiSlaMkUIFSKGx85THWey9rFFzCzt5LwpL7GtVSfkS1DpH2IwG6HG1kd3spjO0PuYFruDlKlT4qjiZzc1MGtRLT+5fw+rX3qW/v6fIUgBBLsPJsVZGT6P3P55SIKDWM6NIpl4hThGpJ/QBU+R27GA4RdPxcodea0ddpBQUTUT05LByuF22PG4bJy52En/iMFpCx1cca6XhiqFT31vBDWjMz3dxGSjCZfnJMZTFilRJGKPEnYEUMSjk/aKpoS58K4zSQ6kiEwMIdskvvLhIGu2Z/EUDdK1/hXiW2dhmjqfSX6XQEIl8xw8sitL49J6NrfbWBFroKwmwG2fCBEOvDkfd9vChdgWLjxm+fWX+7n6Ai9Ou4Aovj0zSyVJ4NZPhNjVrFISligvPlqyyoyrzPnwGCfvjOMr3Yv2id+jXH01W+7dxeDeEWqXVlJ7Xg2hcYHcBh8bfScyYWiQ9FgRKY8Ptxaj+8nNlFdUIg+1kjCcbBIWUzrHx8Kr6+l4IUswo9DhgKQrh6uvlLk/v4x5vEQNe4nt9mHmMgxYAogWFdZ+6vVdCBb4tAzCQRtNpRPZv+gApqRR3FqKbSBI56Q+LMlEC8bQ0k42vP9xRmp6Ga/pZ3BCJznPGEt+di6O4SJUJLZ45qCf+ACeVRMh5WfSyzMZrulDc6p4+yOUNk2kbvVcdERUcqzhIkZCSQZKn6NzRjtZZ47ZD52BZzTAjJFeQp0jGAE3NlPDnnIeMrPIi8Cv/i8gYCfDyeJjjJph2pjBCCUYyJianUX3XULab4Auojk0HGmNv9KREU0LZ0zCcEoEbE5Mhx1ByyAZKqIiItlE9GQWGdCwYSFhASpuLHL4QiI2r43dfzmA3WdHccj07xjkkh8uZeRgghe+tYPfXvUydo9CvC+N3S1z7i2LKGo48nnZu32A9T/dBkD76h58ZR4iE0N4itxMOqeW9lfysy3KZr917/ICb563LDQ/+OCD/OEPf+Ccc845vGzmzJlUVVXx7ne/+99aaP7JT37CV77yFa6//noGBwcpKyvjuuuu4+abbz7eoRUo8F+HZmqMq3FUUyWtZzAsE7fsxKO4CTtKaAxNo9pTwbzoLOZGZh3vcAsUKFCgQIF/C775zW9y11138b73vY8//OEPh5cvWbKEb3zjG8cxsgL/VuRGIDcAngYQ38YZpaObYP9tYOlQfDZM+Fh+ee9fYHRdvt36UwjOA9t/qGj8VjD1/OsxtonLfdMJTr6SQTXJOZWnvS2WbqZpctttt7Fmy1r2ndDNpCmT6UsPUOl5nh+e+hrWj5YJ5LNXr5rmPXb96AbY/y0M02JMPBPcdQxro3Ra9SxFoWeHymN/KWbn3gTyI9dSOfFcZk/14j/Bzvc2xrBJAo8xg/TOqYhGgr2vdBBWWkgvgJeq3JzYUE9k+US6ey2me+xMWPQl9m+8n7tWP8/OkSKiQgvvyaawFBeWafFu71Ocqv0J9axGbowvQ02LSJIFCIzmwgwTRfZn0Ugjmj2oajkjWohd6gjrnp2JPHI/iv9mdEsinvPgIY3D70dLexhLmnicM3kp9v+I7vVw2btsKMO/JSIewOkJkE71Inm8iDWL8IYmMrrPjZnOYZlDqEaCQNCOZ7QKZ/Pp+B1FJAUnr5o0+FwmK76+mpU77Xzzj1EMS0YzZLzOIGXFLr5+fYhv3zvOwR6dXz2S4EOXeNENC12QeShwMRcNP8KC1GbWNX+UuoZmLp9p8p6GCxAF8Zi3zBN14YkeyR6eO9XO3Kl2BjMqT1g7iU5spm/tbIJbU2iqjNMu0BDfTvyxbawwLwdxP722mTyzJs2V573GmHiLuJ3Hxvh6GAMDqGvXItXWYps1603vZ1ME5k59bb/nHY90IO/dhJ41GN4/jvj7pzEql7Hn0RYAhvePUTQ1zFlPyzTvgURbHU0j+Xo+2d4s6UGNhQywzWMSdlXQbjsZLedluDlO6g+/Y95wjsqQRpNHxD8WomTHNFRZBh1Mh0pAGcCrjjJslSObBiEGyOHFTYJRSmjXJvPwGduxd0wl2lpD0q1hs1QqD5SQ9o8R2VfH8JQ9xKp6Ga3tQTBERFXE3+lgNBrDgwPvYJhYSGVnfYCTNgrYDBXPSICTfn45mjOJrPqRUk4ELExMUvhAMtGlFOF9U1DSLmq21yE64kiSjXHFQXTIxcnPRBnWA2hKGsU0kAz+JpvZpEo5iFvKIag9jJilxMUAmuXAbuWQBBuOcif7p67HrWWxPVuLY9yJCYeLBgoZO1NfsGNhoksSitOLrI1jGSZaWscyQRFUTCvv/pzfT0CQFexuCTWuko3liHUnKJ4epXhaBIAN9zUT60uj5wxaVvZROTdCLqWz7/meo4Tm1NBfWalYkBrOEDnkSnPiZ+ZRubAUySZRubD0TY/HAm+dtyw0OxwOampqjlleU1ODzWY7dod/I7xeLz/60Y/40Y9+dLxDKVDgvwrTMompcTJGlrSeOXSHFPw2HwGbn6Uli5kbmUW9r5b50dnI4n/W1MgCBQoUKFDgX8X+/ftZunTpMct9Ph/j4+P/+oAK/PuROAB7vgRGFrxTYNpt8Hb9thp4Ji8yAww8C7UfzgvblnH0dtbxsSLcuDFGc3OaxYv91NX932wr3hTjW2BsEwBCvImzik6D6sveej+5YVBHwFMPwutnme7Zs4cNGzaADJlMhuHhYUpLSl574+FX8lnmggxVV8H4VpDdUPNBUA4JMUMvgWUgC3Cl/zkeGF2Kmxheb4ofr76QH/06xbggYZaESU300epoYoXcwK+fs5PVTRQRygSZClPCntiHaRn0xkq42CxnlvOjrFsBq1P9jEyUGZj/Ep/bPsrmVVHWH/wSiAE6Bvv5/surOf1UEDMy7wluQ7ZEZgdf4fSZC1jXXoZg9DGY8TGzZB8nVGxm23CYV+IzEbU0hpDE70jjlHqxnEPYpo5hySDZLUr8I1iCjBWq5vwLFrP8t99ht+NELN1i+aYMLwytJx2KkdVMXK4SZP9Miha+m/FOmfQATKjK0rfrCTLJOKbnRBIpnSk1DrY9u5TdKQssEAWQRJMS9yD++ON8dK5ObfHJPPlKN6tbF+L012BXBF7elOVgT/68aelSufZrQ2SyFm6nwAvRc3gpeCo2p43GKU5evPWc17xJ8dhjj7F27VrKy8vZs2cPXV1dvOc97+HKK68EoMgZ5cuzP8NLvauoX1DJnK0foue+++lNueh2TWC61oScMdFNQFMJ+48dZ7pp0RHTKXJLvLI+y7b9ORZMs3Pmkv/7uWSmUsRuvBHr0PeW98tffs0s6beCZVnIdpEhuQx/rBMs2LXJJLRzEIDEYIZsXKVlZS9KyqJMdNGRiKPmDExBZEVdLWO1ARgawkxsQZtRTk/bVKysgaiI+JuX05Pw8dHBUuYeHOI3/nlYdhDtGQ4o9Uhla1HkLEP6IHqbgmgZHGQWfgboZCpjEZW1V6zEPhph8oZGBFPAVHQ8MYVom04WN6JvEIchMnHtFMbKhxBEnRs+fQHR7hBYOcrEFYCLFUINyXCcwYpxIm3lJGrGWH/V0xg2jYotU2h8/BQEU0TAQnNmEVUntrgfQzYJdUcIdxUh5xQk02LY5iekF2EKIjmHhmPcQhRAxDwkNBs4SSAJOgnLg25IWHaNOrbSLtaiG2A3BSqmutB+OcZLazeQGcnSXL6bs39wOfBqhrKMiYRlgiAJWBboqkWkxEliII0gHBK2LROFDDIiGi4MQSZQLGL3K6RHsgRr/eSSKt6qEAPtOTo2DpEeTjPWESeXMtCzBqZuIsoigYqjbWarl5Sx/6k2RlvHKZoapnzekc9LURKpXVpJgbeft/yL5GMf+xi33HILv/71r7Hb83eZcrkct956Kx//+Mf/6QH+r2PL6Xz7xnyF1s9//zRUe0GgK3D8sCwLzdJJaWniWoKckTv8w8ireIg4QswMTWOSv55iZ5SFRXMpckaPc9QFChQoUKDAfw6lpaW0tLQck9ixevVq6urqjk9QBf69GH4lLzIDJPZCphvcNW/PsVw1h4VVnOVHsqfL3gnJ1vyxyy4Ge+TtOf7fYfPmGLfc0grAY48NctddUwmF3uZ6QbLvbx4fbXFx76Nxlm/IMrFa4ab3+3HYXyP7M9YEe78KpgqBuTDlq/A62dDBYBBRFJF1qDlYQnRyMXMiM7m87uJjN27/Vb5PVGj6PLhr88tNHSbdlG97JsLIWgAuK+/kgvCdyILJwa4cNmsQe2gJtp4VSJPmozhERK+dbWlA0LBEEUkQGHaYXD5pC23be5kQ6uYd9csRzLNxa1Geyw2xY5KT2TNWcMb0h9CNHLsrl2EtnQvDBuwrYuX+Iszqy5itr6PT2oQWlsipFj6/G18owcLgSq6b8QD4RExL5HwSfL7zXJqZhEtYy+dOb2dy1S7UsV72GnO4tz+NNigyITTO1VfN5oRJVeweLuHxPUVYewxEAZJGgmtvHqJ4ei39eIlUBPCXLSPZ8QKoC9BNjWDpKJp9I/HkCEZqC0HXfEbUTxNPHjIZOCQ0Ty1P4BUH2dOuMDISp6Iuwoc//mHaf5ogkTJo61Z5ek0Kr0sgnjLp7DMwLVBkUGSBOVPsCCgMDI3RWDWAZZXkr6dMNW9TYy9i7cb9/L/v96OZ02HwThRrkEQiwZYtW/B6vVx44YUAzI381czQGqg8/WK2r9UoSgwxf+s3+GLvC7ygnELdxVHOPuFoixXdtPjSqlH2jGioGQt9s4XLENnT0U7x5Lvw+mKExffjF886ZqiphsoTnc+hmzrvqDoTt3JsTSmzr++wyAyg7dv3fxKae7b088r3NmGoBvGS05F6bMgKDCiTOdGwcJd46NwyjD3kYdsjncy/tIIX/vwyOdsIsmJDEmRs9nGyriiP1V/Mmgln89SnpuK6t5OXfrCLZH+KleocBM3AIyeocW3gvPJhBtJuskqAlkCWR95ZiepNUrK6GmlCFkfOon5NGYN6JZokcrBxK1l3htmro1Rme8EUiWdDGJYNHTuJolF6Fm7DdOpU76knviVGXewA4b4AAAuMlYiGhYXISYNJujZOYmBCH5F9E2lbvA7DpuVfi3lNzHl6NopqQ8QkFRxBSHsxJbCpOjmfiqzKSJoMlkjCIdMTDJOMDuOOjVAxHjhUqC+fHOaQ4ogGZC0POd3LKs6k1DxIp1JD1nSjqGCZBvHuOAe27UBLa1hAyp9kYEIXUtaDp6cCCzH/UWaZWIaAJQh4wjaKZ/qIP9eOoR3x2ZDEvM+0YFk4FRUzpaEmBdSMRqwnjuJ107snwWi/QdOjbah9Q8QGVCzFQdHMEpwBO3PfO4Hp7zhaOLa5bZz3w2WoSQ2bR3lbZpoUeGPelGp5ySWXHPX4xRdfpKKigsbGRgB27NiBqqqcdtpp//wI/8cRLGhoHj3cLlDgX4FhGaS0NGkjg27q5AwVAwMBAVmQccoOKt1lBO0BZoWnU++rY1pwEg3+Ccc79AIFChQoUOA/muuuu45PfvKT3HvvvQiCQG9vL+vWrePGG28s2L0VyOOdCH2H2oof7G/jTf2qK/LH0Mah5LwjyxUvTLvl7Tvum6C19cgU6UzGoLc3+/YLzfYoBOZAtj/vSx2an19umfTsfJTEng4aXU7KUm1sXzmfRWe969g+hl46JAiTz5BWh499D5MtoKcoL5vJTTfdxMsvv8zkyZO5+MLzQY/nX/+/RfHnhUogpxvkciY+u5jf/lXKLslbnOSGIbIMx96bIdOFLEFntp5zr0oxW3yR760cpN+uM25Z2KwcdlElbgWwSQL1QYUiZytfnfUYpDsZsir4yoEL0fesoTfnoraqiNLgIIpdYH9LCf1mA6KiYxbbYFQlHOog1ZemyXYSpYOdzLW1sWpwPp3JWoa1GBdMXk5jZD8mIoNGBCUi8A55D2sO7Gb+zAjz5r2C6k5hD/goO+gh7Q0SqOrF8FUyt3YCy1/JEE+afOPDIR5+LknzDo397QoMTqJ/2wS8xXGmlVaxd89WUp17ITQNNZdDy47wwSsS/OYvU0nYfMw/4zJa9ikgaGDmi6TZ0ejvNZk7tYOQY4hdnW7uf2QThrmNpvQNjCdAFMnbVJzjwWkXCAdExuL5jH+nQ+Dqd3j51f1PY0+1sX/9Ru6//2Kufvd50HQT5AbBN50/v/huElp+an9Gmwxj+zFMCUWRWL78pcNC89/i8Ll419kAfrjgHubHx5gfLs4H9Te0x3T2jOSFy3jWJGu3cKVFZs59mJzVjdsSGTLuxCeciiAcfV79bM+veKl3FQC7x/fxjblfOKZ/qaoKqaYGo70dbDZsixa9Zsxvls337kJL5eN1h20MlDSiZXQUh8Sk8yZQ1JhluB+88TYatt2NY8xg9AqdjvNSnH9PHz67wmKlnBULf8OoW+JjF5ZTE/STmxWmYk6E5q4mug8U4zXS5EwbDQNhrjSybK1dyTeWFOMY0ekrNrGope8cD4EBmVC3RPCAnWCfgGBC2bZpuAeKWJx4Bp/Sy1BmGsVWP83MRFcM1l37CKo7jSSqhMQ0Xs8wumXDZhtHz4RR0NHJZ557MgKTV05ntCSHpEu4hwOHXwtXzI1kKiDCcMUAqz7wFHJOZv4jJ+JPOljx8RUoNoGyzbWEOkqxxYLYxQxS1ka4oxwNEMkiSSKWoSEJKgomKi5MRGJEiZnFmDkLScg/NxOB5FCa4PfLkN6poCsGrlEvr1zzIhYi0586mbr10xAt69DsZhHRsnBaOVpeGMI0jxazRBnsbhm7oSPbQI1rxLqTiJJAWjWwawK5VAKzKkSiM4ao64iiBUYGh0+mvDHEjPOraFneQdf6XkpnFTH5vLwWIQgCdu+/t9vCfztvSmj+22IE73znO496XFlZSD8vUOA/EcMySWpJNFMnrafJHMqOERDwKO68n7I9RJmrhCJnhMmBBircZZS5Sqj2VBbuEBYoUKBAgQL/ZD73uc8Ri8VYtmwZ2WyWpUuXYrfbufHGGwuzBwvkiSwFQYF0R74tH5tN+E9DkKDstUWt482SJQEefXSQZFKnrs5FQ8Pb+DoA6GnYdWPe8gLAeegaODsAu79AZGgrpxY7KXF2cjA5lWqtCcbqIDj36H489TD4Qr5tCx+xtXiV/qeh7c58O7qMxsbrmDx5MiG3Cduuy4uRwXkw+Svw156+E2+Czt+yfcjkqczFLMs8TNTjwl37HtbtTzIpZGN61AbRZUB+pmJy0rfwJDZQNKGUxrqfY3O1Ueft5WvVfn737Mskxu1UlIQ5YE2mRaumJlpFxCkxrzxAKhXlqy+9hz/3nMS1J/6RE4PrUQWBldGPsTdzGm7bNpxWmv6xCKZLB8uGv7GT+WfoWC+6WLNqDSsGD7Jk/gS+d8tlhPcaWP0GnohODC8hMUal2Efa8LIzcTkd4YW80mynck4XU+V2Mv2VdPeVowwa2E2R2mWP8//6fs9w10Lcu86m3Labxy69i3vlWj568FrUVA/mwF3EWrJsrLoGd3AyDrtMevAXeGWVj8/upjraT+TaVr56z2yefuBZ8J/PwopBFCFLMunEjNuJ63a0/TIfHf4iY+MjBPSHaetzIlWogA0s0HR4bn2W+kqFqhIFp10nEpS4aJmbxY02vnNHAgkvummnubkZhl+G3CCxjIP4aDcVEYVwOMzY2BiR2osZU1vJ5NyogTPZ1l9LJmty76MJRuMml53pZlLNa4hqdgdEX9+HNuqScCsCKc0i5BPxRkVSHRZFATcBb35ciYINOFakbkt0HGnHO45ZDyDYbPi/9z20PXuQysuRiv9vxdccPjsxEvnYG4Is++IiOtb0MPGsWoqnhAnW6Ox5povw4y/hcpnIHoMlT3Sx59uz6dqT4px1UDFjBu/4UDWi14uhGex+5ABjnUl0UyVty+LTFBKWB7uYxefVOTBX48vvfoUeZwBvbwS5ZzpZbQYZnx2rSMQzBLqSvx62LBFHSsbe66LXWIw78hxTx7rQEyW0Mh3DlUR3JwERzQ9rTmsimkpwsFwhfOIQU9br7B6bTy37MJHYKc+na0ofbXPaWHB/GZOWL0TUZNpO2Mb0p09Ec6kIho1N79yEIZtUNJWDAPvObUIUBZZ/9ikirSVc8OGPo2Sc+AYdSJYNEf1QAT4nGCYyIoNuHw7NQNQtBF0AE/L/CUhm3jMdTCwDHHu9nHbHZYwW5zhw0lpi0RSiZdE38wB162cABnayyKIJgkV2/ND4edVd6ZB84I66KJ9TwnhHnHhvEgQBUzfz400Q0LMahm6RHkhQPDnA6L4BbE4RwxDwhO0EimXuv/QJerYMUjTJR9f6PrylHsrnvP1F/gzdJDOawRV2Ikpv3rP8f4k3JTT/+te/frvjKFCgwNuEYRmk9XxmsmEZpPQMaT2NJB66Wyq7sUt2AnY/ZxedRp23mhJXETOCU6nyVBT8lAsUKFCgQIF/Mbfeeitf+tKX2LNnD6ZpMnXqVDwez/EOq8C/E+HF+b//YSorHdx11xT6+lTq6pzYbP+8C/4nnhhk+fJRGhpcXHddBbIsQq7/iMgMEN8NoQWw5f0wthm7pVMX8mNoKkUhiAalfCb431JyLkhOyPRC0ekg/o1IOLzqcHPrmie49Yk1qKrK595bxUnVeS9axjZD8gB4Jx/Zz1kOk77A19fvYG9fnEc8t1BXWY6wCdJ6EgH41tIQ0yI2srrJV1aPsW9UY1JwLieKCt0l29jkH2LX5k8SipXgmqhwbvcjNCSfQZQFREcNjlOeoswjU5/ycu+DtaxvLyfmEplrX4dmgCVYTMi9TG34ZBZ1zuQnzxik3DbwBrArIlGllMD4VYRLVF7s+Alquo+Xn0/xrTqL73/uOjp+cheD/S30lugE63xsaA5x68pPsr6nkUT8ILrdzbdXL+ajl2oc2HsWD6y5HNEPg5UqbZ12vOGdOBe2YuuooLcjTSptsXz/VBRBRx19CIxRRASyvQ8wf+HPyBZ9iPYdvyRsb+Y7DxtEPBH2597LmDYBwVbJZOdqvnnyQ5S4B3ipeTFfW/VpMpaTVcICFMGDV/0t/SNZDKGYbFZBEPJmBIoEpdH8tZbDLrBopoPbP+6jfd0g3/lODrt/OkNDQ4hpk8+fNpO45OITu67gxe6JROIp3jXJy0VnlTASMzh1vpPbfjWNjq5hQCQlFvPDB2Ks25nDsiz2tqk8cFsRovjWEoD8dpHbA/tJPvRrnKEQlR+/iawnimL7GEOmiG6NEBKvRHgND/FzKk/jrr2/wbIszq08/XWPITgc2ObMed318YEMfU1jFE/2Eyj/+zeKTvj0XDb/aheWaTH32hn4Sj1ULSo7vN7mlKlp9JB81o6Q1fGLATxhnciGIOHHT2W/JqEN7GfjuT+k9EPvJNGXZPuKXWTMLGOxGLoeQwt4kXI2BKeCVWHx05O7GQhYZJUkckhBNFIoB11YooHlUHEFB6kRU/hw0yvUIktpcjaVAfyImZMw6KaDExCwcMVcVDTV0DW9g6Q9iWvcSyobwJnSmL88TESN00cVz3IlKg5y9hzhlgD+rnJceg7R1KnbWcbw1P08f8MT1GyZSOmORqY+t4DZY3sRbClaFRUlK2OKFqbNYLxyFFG1gawiGCrZokGUrANnzI1uOdCxkQqnSVUM4+/14x6VsRBAssBmYggmhurA0h0oqMjo5JwgahK64qanQUbRQbBMIu1FyGSxoSIIFpYAGGBiIioSslNCz1kg5BPsgzUBTN2gdmkF4z1xkr1pUsMZcgkVQzNJDaVBELAMk4q5tSiKgeKQmfnuyez+SzNP/r8DZHIKpm6STiWYsMBPeiTz+gPodUgMpJAUEVfI+YbbqpbKs4PP0fHlQbz9fqINIc68bSmKo6CX/C2FV6RAgf8iTMtkJDdGXI3nvcSwEBBwyU4UUUYUJCb6JzAjNJWII8RE3wRqvJVUusuxS/ZChnKBAgUKFCjwb4LL5WLevHnHO4wCBf6t8fsV/P5/rl1GR0eGe+7pBqC1NU1trZNzz42yPjFAX07iZDlLSHFBaCGMrM8X3bMMMNK4HV6IzsYn2vOFGsMnvPZBDmUVvya+qRBvAuDR9RqqmrfZeHbFdk68JpRPCBSVfDb039De3k7r2mcZC05hbHyMareJ6q8A8gLo/hGV3qTO2t4sTcMqsiiwf0yjo1Une1maRKKc0VQE3R4gZk4l6E4xRerCLgtUTFpKZYmDTTvjZNqXk6YIAYuAnKRdLafO3gMWdMQdrG4ZZLDjASzH5QjxAXAEyIluOlUvT+7o4qz4dvR0Mw5hHAmd/c/fwXWijVtK76Y2HAfLJJ4u4srffYBYNkAsvQ9dM7H1fY/4qJt7EtfQMToHFTdMAkkOo/fOQxAMbKVbQDa5eNYunt83iZfbGjGxgegE8gXKJNmBZUHvnrspD6cYGvHTOzhCt3UVhm0ahmBHEIso961FEXUUIc0jzadik7KMW246c2GcI2CIX8IKqURCMiNxAadNwOsW+d5nwihimu/9egC3y8Vlpxbz+Oc2EetLY9+TY/KcCRRNjTJrciPLllXz+z1JNiX96KJFf9DHimaJx24NMD7ayy9/+TPsqRJsjlNxu+34vRJjcYN9B1XiKRO/R8wXGnS9xes4w6DsL3eAocLQMDx+H473fxbwUSLd9Hd3PbfyDGaHZ6CbBpWe8rd23EMkhjL85ZPryKV0ZLvEJT9cSLDSg6EZSMqx4ranyM0pX3ht+439L/aw/8Ue2l9qI1hyKp37Izh73Zzw+fdw+u17SWc2MZTQGLDmMj7qxBffSkIbYTDajzls4erw47OFkOMSkiyScRQz5oiSG96Jr08kU2KS8cSQBmSyUQ3RkLnguX2897nNeDNZLOCF4pPYVyWhpGwIJgz0T2A0cSIWJjZSCAgs+OMyGl8comPRdpoWdSOg4xzzUas10ySdgG7TsOmjGFoxoi6BLuAxdaL04CZJuxrFM+ZE0VV2nv8yZCZw/cNd1OrNWKKJt6aDFW4H1hh4rTBLf/BuJM2OKGocOG0TRV1hslYK1ZPG311CxgW6KOLqqkAUkmgODUmXkXIyhmhiiiaWaQPRAtGO1xjGbyRJOyXavMU0vHwKwYFWSrpC+IeCCOQQZAFviZvMuIqWNrAMEwMTh9+J6feRHUkjiTDSMobDa0OUJERFoGJBCcMHxlCTGpJDoXNzP2ZGR0/l2PLLnRRPj+AKOhhti5HsT5GOGegmiLKImrEI1gWoOamC8a44B1d2Eaj2vWHhvx1/2MuO3+1FEAVO+PRc6k6p+rvb/zDxQ7av3E24s4yoGEVsFunbNkDV4n/sHPhv5h8Smh966CH+9Kc/0dnZefiL71W2bt36TwmsQIECfx/d1EloSTJGlqyRJaNnkUSZgM3HwqJ5zInMJGwPUuoqptxdStQRwSk5cMiO4x16gQIFChQoUOB1SKVSfPvb32b58uUMDg5imuZR69va2o5TZAUKvD1s3hzjzju7cTpFbryxhpqaN84seztR1aPPuVzO5PnuFfxk9y8AB08bHu6ccyuyuxr6ngBHGWR7QPRD/Weg4ZN5D+a/zVR+s1ReCc4q0JOUzmhlW0/eZmNYmI5Qez6kWiByymt6c8diMap61+BOD2IKIpfMXcLL7mr6UgZuRaA7afDC7iQJ1aQjpjM9asM0LeqKZV7pm4rpjmOaTmyKhzKPwmjkLLYKYa6Yaqdy6ml89JsH2dhs0pv8GFXTh6is6IKkmx+NXc8Caz2jqp/tqVro3IqrKUGCF5Eb67GZOpqhY5k6WXuQlkqZyLTZJHY/j25YDPUNE3v6lxTdkLdGQBBRLBFNExlPmYiCgcOWQDc6sSYpSNd9lxJqiW84l8zQBVTZxknoBrIa5CPVl3LRDaeTODDK7x/vIaY6MWUFIXoFwrCAIGSRyy6nd1BD0AZIxeL0D7uxpBC6pSDqIh5BJGtkGcvWkDMU7FKanG4xlA1hCHawIJUFUJAlhdE4WKmd6KkRctJCSkJ+vvnFK4n3j2GPRrEnvsaBpgRd/Tq6aaEMx2mYOYEbrggA4FYEnG4PpHQEBKI+Eadd4Obbb6e5uZkiUSBYameEM9A0i41NOVJZC0EQ8LlFtu7LcdKcI+dN895miga/hd8eh5oPQMk5rz3W/jrJ6C0mHJW6St7S9n/L0IE4uZQOgJ4z6N4+wsafb2WgaZjS2UWc+pXFryk4/y39e8dZecdujFSWwaZhcgxhWn7criArf7oPSxShvIrcvl6GjGIMHGT3x3HbhwjqGcZ1LyYgZmUwQDdETG2Alqf81JkTyaV2I47KaONFJPwHEHUPodY5RFeX48psIEI/MhqTPE+y6mQX/o2LQbMR90pU7PMzXNrP9suexZaRWPj7s6jscxN6eh7RVBqHr4PImsWYwm4sLDTLRs6XRM/YkdIRxuv7mdvZwwJjDQNUkU07qdlaT8mBSp79+Mu4MjJRdRjZFFGdGk7bMKZUjrvXy7Ifnk5097RDhSxlAgcnkPUO4Ujb0J1pbOQQLQklK5MKJhiLDOLMKBQ1lyIgIGYlJFPBJIcgioRsSWaqa0nmbPTl6pi7IUkaH1gTjpiriOD026k+sYLdj7Vjmfn3FxOySQNdM7EEBSQL2Q7OUF6XMDWL8nklLPvKEhx+O/uebGPghhVkMofGR1ZnoGkYQYDqE8oZ74wjvepnbUHl/CLOv+NUtLTGsze9gprIa5SmYTFh2euLx3sebQHAMi32PdH6hkLzXm0venG+74SVAAE8JW+zZdN/KG9ZaP7xj3/Ml770Ja6++moee+wx3v/+99Pa2sqmTZv42Mc+9nbEWKDA/yy6qZM1cnkxWc+imhomBq+aG7llFx7FzeLi+ZS5Sih3lTI7PIOZ4WnHN/ACBQoUKFCgwD/EBz/4QV5++WWuuuoqSktLC7ONCvzX86MfdRKL5Yt8/eIX3dx6a8Nxjaehwc1FFxXx4ot564yzz45wT+uBQ2tF+g2TcclDBPKCb3gxJFsY1Cbz27+cTm35Ji68bAbyP1qLShAgejIAH3j3LnxKnLge5OJL3gklf0fcM1WmW79jUWQTG5o3UjfrQi44+3QusrtpHtOo8sn8cf0qTmIf+5U55NxlVHoldg6q7HHrLE5/kkTp/Zxy4kqq+97Jkuows4qdwAUA/O4Pj/KXp0Xi7jIkp4fRkQgTl9r4zmQf33nqWfYnazmolaMZMg17HsQ0JYrtAkUtDzKmLaXZNRGbO0DWW8yYI0Lpe7+CePt60uOjpDMGmcwYz4/P4LzyAyiCwfqOYuI9DxP2zUOS7IStJ4jMD2O93yTlHETLZihb/Ayn9/fRNDaT0VXPUdq7i5Hd7yN4o8mnHzuNg6qKFlbRhkByhSif/UkGRwwkm8jgiMa4dhHywC/RVAtf7YcwTJFSIqiCn7im0zZYx3sevh2/LUbfuIUliAgIHFXWzMxhjz9Lou9RNEFESq3k0cffweY9Gpoyl77xFl7e/DIHErNRM2k0cgzUDnHvJ8LUBPI3C86b4KIvpfNiU4ZaQeYzZwaQJIFUKnVoSFh4lD5sgbx8E0uahF1DOK0DBD2N+D1Hbjr88i9xlLZfM8XXTUWxRJl1NxSdAaJMOmPidAj57xVJgqtvhMd/A74gXHjNPzhg3zpPDT/FY+4niC+GybvPQvXKNKZSDDQNA9C3bZDuTf1ULzmSKWpls+gHDiBVVCCGQoeXp0dzAJijIzjFFN5sH6YpoHT1kU13csJPrqTpWTcZRxQOZCCewtJVovoAjSNP8vw50xhefTr2AQkdCU1UkE0vo0SZ9dQcTn8mwprLt/PUPAlbn0mwLcmC3znQM+WYyMQIE2SIhi4NHGPgTOIcqSPYGyXj1tj3jpcRbQnqnjuHrEMkafmxk+HclXbKUcixkRE/JOwJsoka0pJKb+NByrf7cecMSqxuwCKDG8U0cKbsgETd+hqmrixjr2s6C9OvgGiwaooXgbxftKpYWEoGS7NjAK4RP00nbMKVESjuddBW3kFbjUq4tRol7aLp/C1U7q5GzigUtZciGnmRXxQAwyKVFmlnAuW0YiID0mGB2Tp0RgiiQKDGT2ZMQxUtNIeITTVBFJHtdiS7hKEaBCscTDw5gppQySU0ECDSEARAUkSmX9KAqAis/OZ6xg7GyCVyiLKAkTNY+LHZ7HuylWy8D7tkojgl5r+3Gt3S6erpIZfIIRzSSsbaxuHvCM2BSi9D+/IFVP2Vr1Fg9W84xXEKD097mOHruzmx5WSWnbiIUG3gDff7X+QtC80///nPueeee3jPe97Dfffdx+c+9znq6uq4+eabGR0dfTti/J8n5rcf7xAKvM1YloVu6aT1DDlDJWfmSOsZJEHCKTtwyU7q/XVUecoJ2AL4bV4a/HVM8NYwwVdb8FEuUKBAgQIF/kt45plneOqppzjhhNeZcl+gwH8ZiiK8ZvutMDyssnbtOFVVDmbN8r21nS0j77dsC+d9joEPfKCCD3yg4vAmJ5YsZEXfagzTYHpoCmH7IaFL8ULjT0jFxvjs9Xt4z4yvEBoepv3xOuov+inIb95b/d57e3jiiSGqqhx8/esTCGRfwNZ2J1dMJ2/B8bcis54CPQmOQ8WvhlcjDTzKly81yWkW9goVvHnxZJZvFDrv573aY+y3HCzRfsdO+5m0ppfht02gfyBHcqScF0trWdfRzbj+Ag2BVij+8OHDvfTCk9ilJejyBFRDZMQfwO4vIxj/M3Oduxkxi5mi7CdID2OGHzkSZcHcRfT1T+O5jfsJz63A8BYhmhJjCZEioRO334dDSDA0ZjIuT+C61o9yenI/hqWx9clqvP6VlIh/BlNDwGTGpFMZd/vYwwOY5iAT9CifD97D9kGFH+xLMZZW+O2DzzN79mwEYQ4joyaWDo4Q2BWBylKF0pBMMmPSMqxiTjkHreoEHJvvplLeS5JGHM4IFfEhLlt6L3fufBcHRqOM5YpwuESK3TAwamH8VdK7WxlFTuxFFAzARMv0oWaHyfquRTdM0vo8HnhkBQOuM3FHXaRsMkHfbh5pf4ovzPoUALIo4OoSCbZKlE9QKArlRb4PfehD3H777YiiyJVXn8fdT4JugGglYeBnjKf68Khh6sruBvKawctbspzkcwEwEjMpK3WiGyLfvHuULXtVaspkbvtECK9bhMZF+b9XTwXLYnjMxO8Vsf2D5+Ib0Zfr4+6eu7EEi5GT3Oye1kO5u5who4MlgoVk5Y/rCNghPg5bV2EFIsR++TuMjg4EpxPfd76DXFsLQNX8CGUzQmzZ3ItoCKQIIJPBZqaZImygYWMfDXf/jhdvWc9g6wEEQSdk9hM1OsiNF3Pu2l70Wy5m2x872Pd0F6BioBAnhIadsNXH5FYbzXW96LFyZv1xAnpGA0yGKSEsmOiBQfbU6lzwWJi28VqG/B6Ga/rpndxHMpjEYQj4xjyEEjo2soBFQnJiGYBgkDVKaIlEcbiyGLKKK+HCbqZx9/gYsYeoNA4Strrpt6rxdpdhc1gs+tVkTLdJl1jPoL8YZ8KgVd+FpB4k0lZO7Y5KLEtFNxVyDgNH3Ev9ivkIJc1EpHZWnXuAhFHEcH0nilFP5xkZ2k9rJ3N3MXJuDMOmomRteAdCSJho2BminBwOTETSuBHJezC/KuyaGBiWQWwkhSaYpPw2xkWBbKXJ5DYLX52LSH0xDSdGmP2+aahJje4NfcgumdU/3Ex6JIsj5GagPYev1M1lv38HL35lNW3rRjAsgfDUYmRF4tLfnMuTn1rO8IExak+upOziMNftu46hzBCNFYto6J6M4lSoPfnvW2cs+/Jidj/SjOyQmHbxG9/gvMZ9DQttCxHPFZmkTPqHz4H/Bd6yOtXZ2cmSJUsAcDqdJBL56S1XXXUVixYt4qc//ek/N8L/cXIOmSv/eMnxDqPAPwHLstBMjZSeIWtk0UyNnKkeXieLMk7ZgUNyUOoqZkpgIguK5jDZ30C9vxZF/Of6zxUoUKBAgQIF/v0IBoOE/ipbq0CB/1qGV8PQCm65rpof/HE+TqfMddf9fWHgtchkDD772QMMD+d/V3/xi3UsXhx4cztbFuy9Bca3gCDBpC/kvZf/hrmRWfxsyXcZyg4zLTj56JkGgkha81LpaSLkzGdkylo3tN0F7hooPvsNBefu7iyPPDIAwKY9Ob7w3X6+9o4tFL+6wcjafKyHjvvgvZvZ9tJKFkzp5tLL66D+BpDdYOazO+2KAPohGwo9BU2fhcRe/Fo3jQ43qqJzgu9FvjPo44mWYmJxE1fW5PqeKL2VeQHlpVSW2ydCIpHgxhtv5LHHHiUX2Y+toQJ7STGlDU6WlDto0UdZFnmayPgBLNPN9LlpHO88nemVX+CBB0ZZt3kY1TkdYS9MEpzsc+tcWPsYF7gfY8M8Fw9vLEHMJhFLp2KoUZ5dWwemiFtvB/syKkI7yGZGWTAlwsruM9nxvfmonrPQg1sRSwfJnb4Pu5EikzJJZiwODu1jb1uGG9/n54ov5VA0AZsb/GKSUmMP/pIQkq+ezlYN058FyYa7cQlFvVsZSc0nafjIBjLkFDtZ04Nd0tEtE90QmDrBzsBI7qj3zrScyJ5GpLHdCJhEiidSM+ls/Kv3EovFAOgadqG5W8iVVIJkIDsyiMnSw300taj8+YV89nL/SIbp9QqnL8r79P/+978/vF1ltcqWvTm6mtexfngYogoQp7u7m8mT84Uhp9YpvNj0bmRRY2YwBZOvZWeLxpa9+fOjvVdn5eYM55989JR/w7D4xt1jbN2nEgmIfOdT4cOC92E0FcaGIVycz4h+k1iWxYMDD9KWaaPR00jKSDGijRDXGgl6JBS7RD8aE66dhLYjhuJ3s/WP7YR3/YV5JbsgnUDoyYEjgpXJoG7YcFhoFuJjnHaOSvemCNawid4yTpneyxLXs9hKDXZ3d+Ds3Ebvpj6qZ7jYvTqHikyTuJisaGNCaje9X92K7FRQvDIJWwx53MKla5iIBLz91HaJLH5MZrRFYE3pGKYq0+sI8lh4No5pvcRLPeypNyBrsvgBG4Y9iSUIDFclSQUtGld5WDC2nfToFCxGcJBgp7GMPibRVW6RcoBuM3F2l5Aq6idWEqe4Vce0G+z3VNIVkZGco3STIdjsxMrKyIhouRyG00BXFdI4mPb0UmY8sQzFyiGZ+SJ9Ekl0S0IwXAS6K1B1g9jJq0i4LfScimaT6Z13AFHSMRwptl+xk6EJcfwDQTL+FDOeXUzdjioELDJ4yOAhHTHRwjFsgojS5kJSBSzRwvTqGKqBYBPQXJAsUhio0pkY9VIT9aKmVMZbRtnUMoplweLrZzPlgnpe+Moq2l/pxjQsUuN9SH4/450pXrxtO/awDy3Tj2hXiI2CltXxV3i54qGLDo+vP/T/gSFtCGTY8cH1nC+dycyaGTgDf98y1OG3M/ea6W96HANMUaa8pe3/V3nLQnNJSQkjIyNUV1dTXV3N+vXraWxs5ODBg1iW9cYdFCjwX07OUImpcUxMLMvCtEzSRgbN1HHJTpySg4DdT7EzymR/A5WeciKOEAGbn1JXMRXuMuxSIYu9QIECBQoU+F/klltu4eabb+a+++7D5XId73AKFHh7yPRA8/fAMqlgIz/8QgUUnfoPdTUwoB4WmQF2706+eaFZj+dFZshnNg+/8ppCM0C5u5Ryd+lrrotGbUybPwUrJWC3CZQFh6H/6bz4O7oeZnz/9WOwDBwOEUkS6EtKtCftqM0mn3voLO65cAt2xQDfdDQT/rQ/weaNcfbedxDF8LK3fQoTK9cxszqWj7vqfdD9R7AFoe6j+f5zAyTHRhnsd1DkFLBc46hKlhYFPlSxnj+vPB3FsCgf0tjVUE+Y/Czl5mwx2upL+N2je1ixPUj6rJswLAFXcJzFc6ejCFnk5L3cM7qexaEp+K0eou5KxIiPVf1RfFEFTTPBATbJRDNFnDaReZLJvNzLIOicMLMYU3Lxs9bFKGNhTCEAqogQ7ydrlsIkH89772e22sKdB6oYTkewtH6soST0l3BQGOCHaYErnSHmTEzwwCsihinhD1ZTFjFwOwTcloCQUJHlNBmPQaZviMaSMCcv9bFvTMLrNFD2n03MdzZ6WkcA0v5OfhXdie38ncirP4p48GQkSWDbPpXiqED/sIVl5W0FbE4/pUUNuDyfQLEJ1E5axMZ9Ds47cw6rN7TS2bIee3YVlmMqVb5SYroLqXsxq/5UzAJ7hmXzj/UktyzAyOXHo+I7PCYbqhVeWJ9hb3cJw+MQCUBpaSnV1dWH9/1/7wvw4no7inwTsxc4QRIIJTQE4VC/QNh/rEjc0qWxdV/+PBoeUVn+bCfveXc1iIcMEsaG4Yefg9EhqJsCn/gmKG/OH+a50ed4cOBBANbH1hPTYoxoIyC0YyNvE1PudLPkgqnkTlJ58IOrMdIZOg+4cU4tYXqlhiwkOeT4i9yQzz41+vqIffrTWKkUJYMzGSxdghSNMKlEJtmznA3yfF72TSDX/DSXlM1H6xnHDKbpSZRhSgaWaDEiT8fbm0JxSWQ9CRIVg8jNHjLjbgRLoC/ZgEvNsn94HgN6DWPD5aizRumacx8Dlb00TzLQDJnitiiCDGZaQg/qWJJKxpfAng1y6h/qmOl+mRw9yAh0STVsa3CT6wkixMETB4sxNl7UScWQgVGiogZHCA86SMomfR4vusNB1ptETh3EMVLJ6MQ+PGNOrNJdjBohpJSH7sk9BFM6Fa2l2A9WYEkWWCKOnEROBESDrOjkxflush4TNxLRgxXEpg+QsYOcs/AN5YsZjpfnPwc0m4WG/VAmNuR8WXLFCeKXDFN+x0RkVcbCQjAFFNOOJ+xGQMBV5WLfbAtPr8WsTgeCS2CwPUc2LaDndJZ/dwe+UjeRqUVs/kM7yTEdAQtTtxDJG4UmB1L0tg9jqSqmrqHGs+g5AzWp4go7D9/wK7Uf+VxWFIW6yTU4bW+9LpVlWQW7sn8Sb1loPvXUU3niiSeYM2cOH/jAB/j0pz/NQw89xObNm7nkkkLmbYH/DSzLIqWn0UyNrJEjZ+TQrPxXnyRI+G0+vLIHh2RHFEQm+iYwLzqLsD3ElOBEKtxlx/kZFChQoECBAgX+XchP8z5ycdPS0kJxcTE1NTUoytEzmgqFtwv8V6DFwPor/wHtH7dgLC+3U1fnoq0tjSyLLFrkf/M7y968XUamJ//YO/kfjuM9HzqFbN93sGd2IIyuBzWf3Uyy5ahs5MPoadj7VUjsIxJewo3/78PccucYxW6JkhIbo3oVY2U3UeKNQfQUHtyb5M8HUgx3ZEimFWolkLIWXcMupovOvF/qtFvyWdlYeZEbMO2VvLw1QtSRpJ96nvSU0LhsHy5Nx1PWyIdm+njqqSEAls6uY6NQhIXAQnEFBwYHeVY+nZETF2KlLbCgzCNzwyyJhp7vsjuxC5KDPDV6NntfuZGQ4GX69AzWlFmca1kMTLPREs8hjNm5POLlfeeH+X37FxlYYVFekaFv1OJPL49jOdqR1TYYLMdhj5I1VEyfBWUmAt1s7pmImnVjmhqggCEiqE6kYRe97ffxgY597Gq7FUpM7OK7uP+hdl58cT8nV1q8IpyMkUvhtmKHX3rDtLiqysMrCY3mX7aRGLIYnAiqGQXDy2jJSlKDRRjN7yCX9SFIIjndIpUDtw3CfkikwOkQSOUgG57C2ec66Ow3AMjkLH5xczHtXQIfev/nSRRLJJb8Al/9Onwbv0HUFQDg5c15oXl6vY1LT3fzytYs0ycoefF535chtjMfcPXVUH4pT69Ks3xjBqjF3fB1rr04wemnzMHpPCJW2xSBc086+iZlTbnCje/zs2Z7lql1NqpI8ZcPr8JvDTD382cSmFBE2C9hU0CNpzHb9uIbfAF9xI/8sa/mxeatq/IiM0DbXmjdA5NnvfGJoeuwezPFuTQDRS5SRgqf4qPUkRcHF7tEJmuTOKW6ClkUiSc1DN3Mi9hON5mcgmB3YP/81xFH0kj19dhmzwZA27ED65CP9YmVO4lfvAz/sgVE6i7gs1/u4jmhnoRXRmlSOP8TlVSvdrNhuBWtXUbOKGTDSWymjmVCHduISl28fE6c8aFTkMe8qHaDDY5ZpNUcw9pUsniRVYO6lhG2X9LMeJFKyZhAV9CPaIiUHKjEO+xD0gUSkSTzH15I5wnreeCGzXz5z0ka0sNYgsCjF2d45dyDnPKNC/GMOLEEEFUHBz/wHOGJFfi/ZCJ6VcZlP6NlGbx9UTRnDiXjIKc42fLFR+if24buS7DoqSiNW8d5+tQaBAN2LdrPxIMeTv/WJRixMizBQsRCsgwEXcSZcOIfCCJrMjlpLp6xMqJ7WumZ0UG02c0pt5yKa8zF3rPWYTpTVGyfjIaMJZigZJBUCf/+IM6fuxHjeTlRACwEFMtGejjLvI/Oo+PmTczaaSA5HDjOCrLkw5N46mvbSe8dR8/o5GwKW+5tQgwGEZxOVNOOaBnILsC0sBWZmOeOkL0jhZ7VsUwLf0Tk6c+sIDWYpqQxytSLGmh5oZ1AVZSPnP4RWtVWTg6cTNR2bKHUNyK3ciXJn/4UweHA+8Uvokyd+pb7KHCEtyw033PPPYerX3/kIx8hFAqxevVqzj//fD7ykY/80wP8X8eW0/nal18G4GvfPBnVXvDiPR68KiwntCQJLYmJiUd2Y5fs+Gxear3TqHSXU+utpsZbSWNoOgH7W/iRW6BAgQIFChT4n+Wiiy463iEUKPCvxTsFwifCyGpwVUPRmcds0t6eYd26cSZOdDN37uv7LiuKyHe+00BTU5KyMjtlZW8hk00QYdq3YeglsBdB5MSj1+tJMDJgf3PChaN0EbAIPA3Q8iPAgqLTjxWZAYZWQGJfvj2ylhNnnM3t35jGzT8bQtUtZk2yUxxWIJMBPcFAOn/TKTTFTXx3Jf61cRzCKC88GSJ+ynksnTmPIunTKHLR0U/BlPjV+o9T6m1nKOOje+5G4hPy9g+XMo2PfKSSk08O4nCI1Na6aB1TiasWtQdW8aHd15ApV9DGaxHsaZw2J3Nm13Ci+yBdfftZEvWwxp7gkf31lDhKwCxnW5PJLRf6kKU0vzp4M+nIEN7SKiY0fpnp2l6W3fZnjLSNA5FJrKivZdC2F5Msil1l7ombkPT3MjAyRkdqB5JZQl7CcoNNJGvYQRsCrR8rE0dKGrgmBbm+eA2Jd9fw04EgibY5mJh0xzxo6iAdfRo22c0nz0jRO5hBVSr440oH9z49TG40y8LhNO8/6QGcdc18Y+BsBlpPRMrlGO07FyFRCroDK5MDUwXJRSolYdmgrkKma8BgSq1COmuxfmeO4dwIuhwnFDJ48EWRD7yjhB/98Ht8Yf0tOPwpIhUyLbu3E7VOAaChUiYxmMEdcXD1BV6uvuBQQTLLgtiuI2/i+A4ovxRNPzKDXHaUUlE7Fa/3yHhPpEwGRw2qSuRj/M6XznWydG5ekP7ju55l9t5vYzcTJK78CYFnnyUSDPLV64I8/bOtuLTlRIf3sPcpgYYLunBUV0PRocJ8mpof16Gjx9lRPPcneOUpKK+FbJpTW3dSkmjmlwvDeCaeg16tsj+zH6/lo+ZXVQzt7uCZyAAXfGc+oWovU86qYO9z3QROmMO0qxdCfQVySeUx4pVRXks6rqPYQAl4qDlvOlJJ/rNiqv9iHqEZGQGn6aRDTzK1tJxol5vseAYVE2+vA9lpUOfZywmhl9HdKumHJ7N+zI0hgU21CJtjINrQRRlLyoIpE7NlSDsM4i6QDYvZz86h8eGTEEQQLBFn3ETR7PTM3UmyvAXV8PK9D2f5wh0+ZEtAtiexcDIwcQR5Wxlg0bagBSkxTu42O9MfmcXBCpV1Vy5HExSc414mrp5Gz4RByowAo5N6SZaMIQgmu0/tYcrWBqa9NAslZ2fRn08hGU3QVSEQSjkQdQERFdnSAAFfTOK0O8+nr2aARFTn4LIe+kJ9lK4SmP7sJAI9QURLYsHz56LYLNKWiS4arHvPi5Q3RylrrsCecuAcc4NoYZp5h2YBC0szcIbsdG3sQ/S4UCQDQQADhfrTa1jcp/Hyj3YR64wTKs/P4LZMC2+Jm7HONIIkIDokJK/BwZoWtjQ04a4KMyk+DYfdgaVppAbzhWN7NvfTtaEPxSHTubaXeZ4ZnHfhea8/Jt+A1D33QC6HlcuRvu8+/N/5zj/cV4F/QGgWRRHx1ekTwGWXXcZll132Tw2qwBEEC2bsGjzcLvD2YVkWST1FWk+jmTq6qaNZ+qHKwhYOyYHf5mVp6WIafHWcVLKYCncZXsWDJL55j6oCBQoUKFCgQIG/5qtf/erxDqFAgX8tggCTbgLz0yAeO/1+dFTjppsOkE7nM0S/9rX6vys2OxwS8+b9g0ketgCUv8bM3PHtsO+bed/j0guh9oN/v59MT97qwFWdtwHxTsoL1d7XKRql/E28so9prme4+5w/MJz2Uz9jPsK+R/Pr+h7jwtofs2VAIAV85J0RugYyjOayeCWVka0WienbGcp8hx1985kWnMa86Iz807OJXHV1Nb/5jUIgIPPFy0+jE5NyajmJcwGYMsVDR0eGa69tYmxM55pryihZcBPZPbtRFJN6X4IOdw12u4uWMY2TL/4OjO+nMmrxvuvP5TnPecSGbNT5JerKHZxQ7mTF5i+Q1nZiAsMpjcdXreXUA6txaEX05VyEupNsKXsPnnCGsVgrhLcxNuMTlCfbabCeJ9mfIZ5xILj9eIUuerN+EFwgOhBSm0B0knOdymz5+1Ta+zGdBp+MDPLdDhe6IHJwqJguKcBYwsRhE/jT9vmsv7+cH/w2RmzVOKYFOUTsdWPMm7mFnE3jUnE/9wxOxNhxBkLIQsy5sGX8aCJY6Bj6KJhRTANcDhGn3UTTLexiG9ee8Qd+mNrP4EufID1s56ePH8StOLnqHUs4zXEqm4a2ATDnvPW8Sz4fBwbjD+7k93enKZka4Lxb5iLbDl1TCgKEFsDohvzjUL5g3zuWutjdqrKhKcfIuME37hnn4lNdXHuRj+4BnRu+M0w2ZzF1go3bPhF63YJ+4cEN2M28h7ctMwwrHoOLrmHmRDuxBg37ziYkUyebFWkZUpheDcxYACedC3++G7x+ePYP8L7PHNt5fzc8cX++PTIIY4MokVKKD5ZydccE9vrmMecD03CeKUOrg2ebdpAyUqiDKgde6mXuuyew9ONTOeESP9LO1eCthpJjvdvVlMqzPzqIIV+AN9XDvC9fjvRXBTPPPW8JT/1xjBZPCn/AyWmhEnpu+j0l48N058qQsdAcGklXEkHpRHGLuF1uxnfXgJxheMIImiPHhOEtCEOl+BkipYfISCI7ZsYxkxGmtA6jygKzB5txZZdwYOlBvF1RFEMAwWLUpzDodZILDOMc0uhkMlq6jORgH6I1QMt5WwjvraLz5J1svu5pfD1hal6aR1ZzMDChCf2QXJeIxLEAzZnFOeTDPu5CTimkouPEPCY9bh96OodvMIAz5saWdKKknPROGMUx4sWWsWFL2jAdOdLFffhGPTTsKSFkDbFD2UuTbS9jjihN566ltGkiXi2M3WtnvKGb5QsfJetNkvUmcaVn4Bl347GKEOMKkmTgjdqR7TK5uIogwmjrOPG+DNlh0HQBX4mLiafms9cnnlJMvGOMns19CIZBycwo8z48i3W/OoDskEgMZEgOZjFLVMSUDVtLgNYP7GbSExMpjlVQMa+Yns0Dh9/jV+/fWVjs6dqLmcwx3fPWPJcP9+X1Yh2qPyccKqJa4B/nTQnNO3fufNMdzpw58x8OpkCBtxvTMskaOVRTI2fkyBkquqVjWPkfsQ7Jjk/xUuWJErQHqHSXUeSMUOkup9JdzqRAfcE/uUCBAgUKFCjwtlFXV8emTZsIh8NHLR8fH2fOnDm0tbUdp8gKFHgbeA2RGaC3N0s6baDrFpIELS3pvys0/19Yu3acjo4MS5cGKS//q2zovicOF9ej7/G8fcHrFefWk9D0OdDi+ccTPwuRpX//wJETIdsD8T357G7PBNj9BSKeDBFPEvoOHnl91BEmusf57bmVZHQLMZ7jB792MZyNMZIuZkRpZEZyL4+0rube9Sdj6DnmlrTw/KV1OBSRiy8u5oILipCkV4XHE44J5w9/6GdoKO/R++MfH+CcczZTHJjEpkQpfTkbRs5BPGmye3CAxJ5BZLGa5pEsy7ddg71SQsqZ9JgGSoXAp1aM0D/oxpK60S0JpzTKu/V7sfR21KwLUZAZEX0M9gXxGllqGpbiajwPZ3w3m/94B6WyxvjBfqQhD+UlZXQlJyBKCnY76GIpJucjqq1oiQ3oOlhZEKwUPmsKknsq3uBebEmLgXgxFmCY0Nmvs7Epy9C4QTprYliAJDIh2gOSQNpmY3G4jXt1GyINiH1uZNFElrLMr1jDeMbJzoFyZAV8NoGQX8LrFqmMDlIZWI7fPc5ojwtDlUmLFumsydBY/hrzuslXo5oaY+kUM7RLmVilYOweprM/jWXBs5s1Nn6vn0sujjB36qFrzYmfz/uHyz7w5QuQOR0iX/toiJt/Psq2Q37Kj65I8/4LvXzlZ6Os2Z5FEgUyOYvWLo0pdUefX7qpkzASTL9sKsZdjyIJJkFfDmqO3AzxnH42z68e4MLuu1ElFxMeuwWm/QCcLoiPHRF9N66Ay68H+9/MIJAkDhtCSxJmKMpYdpRsLkfcmy/gN34wwXTXPPojQ+zONaGqGhIS8yJV+T7SKTJf+QRWbBxX1In0wc/D3JOOOszowRipwTS4ihlRwwz8tBf/n4Ypnuxj+qWTKJoc4meZFnY3HSRoN+j8/oOE2ruZowo4mUsLM0kUj6A5NHZKEWaE25HNLOlolgElAwiMVvfy8tQxPvhwnAPMQ7QMKq0DJPoN9uR8DNtsOOIyp2zKkay5k4q9DTx8SSedC7qwpyVKEhnCMT99LhdjqQa2BysQvCLKljoaM0N0ztzPmg8/yJmdzXzi4wZGv4s1eEgn6/DukzDmd4El4B3yUb6nhtIDVSQVhdl3nE3nsiZ6Zu6jr6GFx9+zmVBvBzVbGmh8dgHe4QCGZKLa09gCEvsX7UA0YMHaEPZxF4ZgoshpJF1DlcGUDAzfMFo6SLo8xZTIZBZf28Aneu4lbRvHMi0SJaOMVgxSs2EGUiqIIduYfGEd7oDI/sebsSQJTBNfhZfhljg2LYfT7SBSGeDEj0zJ3xi46RXUhIoALPr4bCaelR8P531jLgBjXUkevmE9STVFf7oPrTzF9LopXBg+l6DHT9Xictb+dCs9m/qYefkURlrGaHmhgw7XQbZNXYveqnF1ydVcWnzp3/vkfU28X/gC6d/+FsHhwP3BN7ipWOANeVNC86xZsxAE4Q2L/QmCgGEY/5TAChT4v2BZ1iFBWSWlp0nraUDAtEycshObqOCSnUzw1VLsjBCw+an1VjMpUM/8yOxChnKBAgUKFChQ4LjQ3t7+mr+nc7kc3d3dxyGiAgX+9bS2ptm6NUEioRMOK0yc+PYUxly1aozvfvcgAE8+OcQ990zF7T50iewsh7FDG9qjry8yA+SGjojMkPdlfiOhGaDi8qMf24sg3ZFv+2dAqg1MLW/F4SjDJgpgWNz8gy72afWM1YSwZtqRXVO5fW0DLf3diGoZErBnIMPPtsX5fwsCAH8lMr82Hk/++sc0TZqbm3A6lyMIywlGv0IgEGWXUzvk92qApKALAvFppyMGisjmLCS3hSFA936dSFDCdM2kmEp0sRu7ITLDmSE+3ckOtZKm8Sm8UHoiRrOFnkgjhNOYmoc969pIjOqkEvtxCgZ1/l3MqNfxji+mY0xGsMaQfGn8iZfY3xcF13R+vqGCTy64G0GayANtN6EmnfSWzWdY0zENC1EArys/vf/6+4ZpG9NxRCA7BrpH5MX5Z7EgspdIqpknO2cymi1BcGWwcgEUKYkimvQmawg6hplQGUWxKXzgYi/vO9+Lyw6/fHiEtoNlHOwXqR510FHRSq57JmWuEkobd3DX3jZOKF7IV2Z+gY9/a5inRgyeZoTrig7A+Aj77RWsTfsobbfY84sx7v5KlKKQBKL8uoUpK4rkw0JzeZFEMm3R3Jm3FDBMi65+nSdfSZFImSyYkReC+3J9fPiFn9B50MWyGRF+eNP1CNvXwcnnw6zFh/uePdmO95wQjqeKCPpEnGPd0LYHps2DshrYsS6/YbQUbK+RgBUthcs+AquehrIavjurn9z2V5C0ehwDlZQoIuXzirEsix53J/0f2Y5jcwS9KsVAYxswk32/X4+7qROA1HCGko4DxwjNwWo/joCdxECGvpYsroEcHSMJ3GEb3Rv6uORbjch7t9MI3OtJM6evC12UkCyRqNRPqzCb0fIRvCNeUobCF+pqwF+L2yihf8pLCJbOWFUv0fVR/EYzbsaZz4tIBkxpsuPoOYv2mT3IDo0uS2V64iU8IxaypeMZl5HtSUa9Cqf+9HzG3C7aZuQYDlgEeyXsmoK/x8noOX2Uj6S54qksgbiInD2IKuxmM/UU7ZvIkjuvQA33U9xejJJ1oCkmwZyBza6T21xLUhmnt6YFZ8yNJZp0NrYRbSujYczHWMkY6z/wJ+SkD82ukvNnaDuhlkV7K/Fs9ODsDYIG09fVkpqyna6qND7Jz8J7ijjhYC2iHZidQR1PIY4ohDvKKG2uQDFcyJaC3W/DQsCwFIKTS9FzGoJpoCYSpGMGhqngUE3U4Ri6apAezaImjhRtjXUl2P3IAbo39TPlggmUNhbRtbabSUuDKIFKzpg5nWzDmUx2T8Y9Pe8337ttgJbn2gHY+tvdXPjz05n/oZlc0XwFupUf/2tja/8hoVmuqcF3881veb8Cr82bEpoPHjz4dsfxL6OmpoaOjo5jll9//fX87Gc/Ow4RFXirmJaJbupkjRy6ZWBaBpqpkzNVNFNDQCBrZPEqXuySjbA9xPzobOZE8l/45a58xeiwPVQQlAsUKFCgQIEC/xY8/vjjh9vPPfccfv+RafWGYbB8+XJqa2uPR2gFCvxL6erK8pOfdKHrJooiEgop7NyZYPbsf35Gc3Nz+nA7HtcZHFSprT10iRycB9l+UAJQdvHRO+aGoOM3+XbV1eCszBcSTOwDyQGRo0WxV9E0jTvvvJPW1lbOOusszj333KM3mPwVNj/zKLrlYOH8dyLoCcgN5D2txXxcWzYNM9q5F9kXoa2ijvKIG79ko3VoElOEH9N7qCsJA6eQAgLHxNGX1PlNUwLdhJBTxGcTedcVJWiaRXd3jFRq7eFp6dOKWunOVjF3XECth1Z7BYmP3Y6VTIIviMelkFFBFAXMFgu12GI0YWBpZUyM1uHxurHaF6MGtmFmujhv1nZMJIrMEXZ1JGnKNdAY7mBn7GxGa+ZA1wr0QRWbz0047OPgwQAZiim1HcTtMWmmlMiCMzi4vhItM0L7eIDPvXwtNs+pNFSEmRqWUQdMJtlXMppJI/sW0zChlLX7s+xu1tDLQJwI1maQPDCoBfjMvq8RGR5iMDuE0wOJUTumZZHRnOQEOwFnkhGtFlfAxxXnernhvX5sisCvH03w7PoIB7uWomoqC6ZpVDiqKF8icdHl7fyk5W5EEZ7vXskl8tdYsUlCUQTqrC56ezfR6O9hg3YBgboqFKeMbsBozCCWMDnQoTFnio3SqMyO/Tn2HtRYMN1OXYXC+y/0EvCKxFMmF57ixmkXqKtQsCwYjZmIIryyNceqbTlu/39h6qsUfrN9FZseWoiFwB+2mVz65UZOvPJTrzlO6xdPgs1KPitZsR3JYj7n3eALwPgInHhOPnO5rxM6mmFSI4wM5Lc/6Vw46Vw0U2PNrktgdjE05pjTO0Tdo7Ws+u4m9j3eyuybp6BMNEjUH0REZJJrEoPNMdb8eYxZmShFjiFyWdCnLTpGuLJ7bZz3w2W03/04ExOr6Blw05SsJqXrtK3sQpWXIPh8WPE42UiMbn8pNb0jWBLo9dMo0p20myJD1WP4B7y4e+roizgJ2FROXhfC797K2AEXV63fScwsZzbridCLhoMhowRdstH0rgOYdpX956vc+TUdd7aLWQ+8l3hpEsMXQ9ENKnvT5CodYMr01o/jHXYhagqqUyXnTZNURvAlQTYtJNMibI3SdO5qRisGqdo2kaWbJDJSmmHJhYlIurqfqg6L0fI4LaduQrREsoE0tqwN35iHzlmtiFknmifO5JUzObCwmfGqfkwJMr49bBEnc3p7jKF0kPiEXtyeDlydtVz+1OnYvTbSoyJrQ1sZbUty4owL+Mv1v8Qs0jn1t8uo2zSJREYla4A+ZrD7Ly343DmclWH8tVFmXlTF899aSU6UwYK0JtIwOYAoi/jKPJQ0RunfMYTikjE0g8c/vpysmGX1c+tYsHQeYy35gp3VJ5SzaO6xN1mGD4wdbmspjXhvkpLpUWZ6Z7IhnreZafQ2vuaYLvCv5U0JzdXV1W93HP8yNm3adFSWSFNTE2eccQbvete7jmNUBf4W0zLzgrKlk9VzpI0MKS2NhYUgCCiigl2yIQsykiDitXmY5CphgreGsCNEwOanwl3GlEADJa5iREF844MWKFCgQIECBQocJ14tCCgIAldfffVR6xRFoaamhh/84AfHIbICbxeGYbFu3TiKIrBggR/htQrG/QvZuzeJplnMnHl8/SkzGQNJyguXspz/7R+NvrbFxv+Vk04K8Mwzw2SzBpMnu6msPGQD0Ps4tP8i3w6fCM7So3dsvh3iTfm2OgITPgmWAZITaj6Yz0B+DZ5++mleeOEFAO666y4aJxZRXlUHthAA9/1R56GH5gNwRvcIN9xQDc5SLMvilzvibOmNcY12Cx9cuI9UzsvYgS+g2TzEcibvnhTAPjgd2djIHnUa8/2DXDvztf2hv78pxoExjV1DKqqapdEzwAHfOF/94AKGKOebvzybA6ueosgBN163iEhRvvCbKlp86vl2dksaaTPAuOml3qHQvFZjvM8knQAxDXrQQu8pps31JUrtIlURHz8Zbef9RR+hztnPjf4/ApC8XOTmhx0IIzIH5UaoKIVLb4W2NVTsvQun0cPCmiL2jw8S8R9gWPfQNeBh26pS4jE32EDw+jGtcWzWdsYHiymuLSYotrNmz4NYpoXf9yxS/Y+xKylyORtWn4zSAIIdnGEBSTWpzKY55wyd32/pxx0ZZN9T7yCLgGFJGJZIV7wUu6JzxpQRokE/C67owWkXmD/NRs+gzkjcjWm5SWTt3HdLhF0tKp+/fx+dwRx15QpBn8avX+pASJSQTOnExDh1DcPcMX4Ko6JEb1zA4bM4aY4Dy7L47A9HMcx8JvbHL/fz7d+MY1nw0Ispfv7FCEUhicvO8hz1nt768RBPvpKmb0hny7685UsiZfLQi0muOs+LOVaCxTgAgimTHPVA3eucGBNnwEe/Cm17YcZCCBfnl4tiXkR+la5WuP2zoGkwOgi+IMgKXHwtnHYxiqgw1T2VPak9IMKE9ASS/SkAhvaNktul8/0532dLYguTXJOYaJvEA199mWRC5NnBd1Dp7KK8WqC4ux950rRjwnQbY0wd/APDgTFKE3ES7pMZkOtRgzk+teVLVH+ugo9sr+eMjJv7TjhA7wvDOEM++rvrMXIqanAatZt0FFWgqN1CdesEonu4dPVaUG2EaUbGQJRH8OgxLETAQkGjv2EMw64hYZL2jfDJT3uoWt7IhJf81IxIaBShWBo5ZFxxCU0KkLVn2Hz2doqby6hrqsQ17Me9bw6rbUmWZtaCJfDcPBetS7aDJWBV7qK8w084DjtcjewJVTO2YBMXJptQoxmekCRkw4Yt66BiVwOzn1jI8s88SlN4IzP+cjpyTMc1qZ9hoRcsAVF3o9vi2HsqcXeXYA6EyNnnUrfZgSSaON0OxhMqYy1JsCzsK2UaIydRsbEY95ibocgApk0G2YSUF8uQyKV1bONxzrn5DKrmF3Hf8t+TE23YEnbshp0TPjUfUcyXCzz96ycw3hHHFXay/BtrGPYP8vylj5NzZtkyvIEz2s5DFEXcRc7XHJZVS8rY/UgzWkojUO0jXB8E4Kbqm3hl/BUcooMl/iWvM6gL/Ct5y8UA/9OJRo+uGPztb3+bCRMmcPLJJx+niP77sSwLk7xwrJoamqEdfmxaFhYWuqWjmwaGZaCaKiIisigjCxJ2yY5X8TA9OIUZoSnMDE0j7AgSdeQtL5yyA1mQj/uP8wIFChQoUKBAgX8U0zQBqK2tZdOmTUQikeMcUYG3mzvu6GDFilEA3vnOYq65pvxh6cNnAAEAAElEQVS4xfKnP/Vz//35XNjzzovykY8cW3zrX8XEiW4uuaQY08yL8e9/fznnnPPWzwfDNLhn333sGT/AKaUn8M7a89m5M0FLS5pFi/yUlTloaHBz991TGRjIUV/vQpYPJaeMrjvS0V+3X0U7klmHOgYd90KyOf+4/VdQdEY+21NPoo9sprUnhL9sEqp6ZOq4leokt+1zMOSHiTdC+AQ2bTpiv7Fx45H2lgGVx1vT1LEPkXaiVQ5CiSzfm9rKg+4pNI2obOhX+dTs9/DZ2E2QeBjK3knXoEBLyygzZ3oIh4+I9bGcSW9Sp3c0jqGprOg32DRkZ9f9K1DfdRJS1am433MSt50WoTr4V6KPnmae+SzjUiVI4A/Wktob5WAsizzejmlYOIVitHYFu5XFtBz0JOzEasfRBDdZ8Qv82v1BVmYbGTODnOF8mQ8uzZFLZahx/IjPZb+FJUqEp87gt6epNHhTtA+1s37vLXzmyXch+WpJ6T4sZAQhg2BL4QmsxX7CN6hxVHBu9xQSucVs766G4FVkh57BqQ7j17cxxe9kf6aIeNaNusmGSxOw9WdI+r5Bt7uNza+U8sCXbmbFDo07lrsZzVmoOlhSBl0XwNLYsnUHa5scqIYDSYKRcQPTgmTaxG4XaOnSyKomn79jlBF1JsKclfQMxphXNoXVTUWEBgYIGBnmWW0MxV0kDTu2kJ9JxQofu9zHOSe6eeSlFEb+64BE2mL9riyvOpjmVIvOPj1vrWFZsO4RiPfAKddQWeLlo5f5SKRMPvejEXZ1jrDf9jyjbS62/PAsvnX9IlYU76BvVGN6eZgTpx5dBwCAVc/AE/eBLwQf+hJMnfv3T7LmXXmRGWCgG1OxIXoDsPllOC0/C+DrtV9ndWw1QTlIGZW8wOr89gK4oy4ijiCVjvznTS6pkU1oOMIexKwP27hBo2cfqTt2A2B0d6NMm4Zt3jwAMhs2oB8cxB104y0qoqHEjib42OXbwpQX1+BLpFl/4XX0P17HLDVCbqrK8IFRsmkNQVRI2W0YioUtZyHoAouesFGvm2A5CNKHjSzjROnSJxFQ2glLneiGjb2Oaoqaw7izGoYrRa8njSCU0FczQjSSRBwIoKDiIIaOjdaaUkbLRKKdZVTvKWXOjgGq2Il1/1JGnB7WB0zGM3VEjAztHgPD2YGcs+Mwk2TcLjpSE0llynGN2xgItHPDLUlymQj+HhlJlwgdrGbiyhMIj9iY+3wDbdX5Wd6SJlO3YTrp6BCJoACii6kvh5E6S5AwkTQJRXdgdymYOR01Y2BqJoJlARaWaRDe5cMx7ELISYyGRnCbAQRLJOs18PeEAAFJESmdHmTEGGHjZS9Q3b8QJWPHcyZMOPnI95ogCsQGVUa7M9SfWcM9Hb8g68giINBS3Mo0o4/AcBBTM19zuAUqfVx05xnEehKE64MojrycqYgKp4VO+/tjtcC/lP85ofmvUVWVBx54gM985jP/1iJl1v6vt3ewDgnAhmUcFoQ1Uzv8WDU1DMvEwsSyLIxD2cd596u/6gcLy7KQBBFRkFBEGZtkQ+TQY0lEEiQ8spuII4RDclDjrWKSv54iZwS37KLUVUzUEfm3fo8KFChQoECBAgX+Gfw3WdYV+Pts2RI/qn08heZVq44Ip6tXjx9XoRnguusque66/1sML/Wu4umuFwH4TaITeaCKX92Wv3Z56KEB7rxzCn6/QiiU/zsKf+ORjGXfjGM7r7oamn8AWPkigUMrj6wThPyfqWLtupHW7QcYi5ncvfMjvPMDy5g1a2feOmOWREWJC8PUkPqfhvAJzJnjo6MjA/CaxQ9HKEVHwe+HULGd7MRG9r2iYaY1xoYyPD7QyqkzOxAkF61b1vDZ+2eg4SYYVPjJTybj9+ef57UzvFzzVAorNoDoDpCTvND0NJv8S/D15CiqdJDUBFb36VQHDx1cHYWRDXwo/DySvoDutMIUVx/7Q+9iy+he9EwCRB2iHeiV9Wg9InJLB85JDWiiiWXBuC3Cb6xP8lJyIoYpkMVOubYSmTTTpP0EM0OklBBhsjQE07hJEAklUYQ+srjQEkkkRwRDlZAzcT407c9cdPGDbLPb+INviN1iNRv/NB+XksPmUIlVvpvkXAXbhH4au8eZbgyw5mADvWo52CGWG8OQDxCTYmyLxpEG4V2z5vLHyACaoTFadz9K5Wa0eAB5wxX0pxuxshLCoeejaxZul0DAJyKKAmPqKCf/+gfEioNIO67EufrzXHSuRuNIKWuEUQZlD3HFxUUlSUpPm4ptTxmqw4fTJjBrUt7veM5kG7+3CWRVi2hQ5PyTXWzekyORtigvkphSd2is/vlWeOyn+TG45vfwjTUgiHjdIj/+XIR3/PEHiAPN9AugJ8aIJW/gyW/MpXfIoLxIxm77m2trTYU/3wWmCekUPP17eP9n//5JNnEmKDYsLceg26Bb34cz5aO+5kxeva0xsGGE0oEq6k6pQpks4wo76N81RP0ZNUQagkd1Z/coNF5Sw46/tOP2CswLdCIIMD5ion71m9iCHrIPP4zvttvIbd3GM19aS71sEfb14W6cyty7PoHZ08rAU7cxacMoAgKV334A++he0u5S+kpPwhVykhzVsUwo3m+ne6JBcYeBoknUTW+gdY1CWaaFEJDBwwbOoMdRTtfEWfjqf49oWDw/Y4hJr/Rw0nI3K06ZjCjsIYedoapRBmsGKR2QyeJinCgGMt2TFMI9JlM2mjhUlUnufcxwbkYaXMLLzjBjIZ2HP9FBumyEirX1hNrLGSsfpnR/KSUjBtusKpqrQ3RMMWirqMGKi8g5O964E8+4j+q183CaKTyGxqw1VYSGRvH35TBUD+nREiZ0L2P3/FbKts/DEMIkwhb+YQvRsjDdOUxVRBc1yIkYsoWsSoCAgEWgI4KoKhhiXusZrx9iPKLi7SuidNyPP+zkHXechuJU2LZlJ5qQZe91y5EMmYvdF/LMZ1fijrpYdP1stj/czvaH2wGoX1rCrLnzaHbtR7LLWCMiVdWVuCuduIte35PfGXTgDDqOWd7bNMqK25vAgpM/OY2KWa9xI6XAv4z/OaG5p6eHm266iWeeeYZEIoGmacyZM+e4xfNqgUXr0D/DNDEs4/DjhGRy5p/PPiT8JrFyFrqpH/ImNo/8kReDwcKyOGwxARwWf/MPhb8++KGKsPnFr4rLryIgIAkSoiAiCgKiIGITFURBJGQP4LP5sIm2/8/eecfJVdb7/33a9LqzvWZbspseEtILAQKh9yaKVxQRCwpiAwv3igpWsCAKIlIEQZp0QgghIT2kZ1O2ZHvfnd5O+/0xm01CEpoo3t+dN6+wZ8552sycmTnn83yfzxdFlJFFmSJHAV6LG1mQscs2vBYPDtmOTbJhk6zYpMy+XFsOdsmGVbIii//nTsEsWbJkyZIlS5YsWTjxRC/Llw+Obv+76ehI8uMfNxMMakdYU4wf7/y3j+Xd0HXzPRPZHYu0kT7i8f7mCKaZETAiEY329uSo8HoUZZeDowK0KOQdY+VrYA7kPA6YIEg0qDoMbKbY4sBb+zXoeBxaH0Ad2ksoVISISKVvFxs3zuGHP/whALtev46t/U2IQKGriFLgM58pZsIEJ6pqMneub7S76QUWzq12sKGngDcHvseWXW3UTSzhlLlTqXH1sXLzEKZuIrV1sy/uZ9ycYbY15qGqOigwPKzS1JTghBMyz3duiY0fzA9wV98qgok2DuwewtI+RBorpgR7h1QkAf62J4bfuQs93cTigadxGQkc6Q4WKVHCbjsPJb6Nt8ok3zVMOpkmNi2HWF4ZlkgPSrmHgmQ78yYKrLFV0mla2ZQuJ5W8AJ8/wL7uKP+IadxY3E2sfQ/dPR6SO4P4SkXG2/pwOgMQjxJPyzy5pRiFQTSxBF3XELqHyHcN8vaWsVSOHceSyVuJdNfwzKbzSWh2hpN+4roDaiXSLoFuj43xkzaxZ42D3pAH8+Dp5BrAVMKomklalKmursbnU/jBtX7+vn4fz7MVZJ2gazuJRUF48xvY0h5MEwwz4yQRjZsjVsYqcU0ntu5UrJOfxzumgUBiGkunFvOrh0LoVgt5BVbUmEpOjZ/Zn5tLRUhgV5PK5LEZL2aAimKF334nQEunRn2lBa9b5Pe35NHeq1FdKmO3jUTd7145oh+A2NKCmBoAW8biRFEEFH8v0gCZ454+xlYo2KwiVaWZ+qZp8ptHw6zcnGB8lYVb/suNTbFAKplp3/4+EnCWVsG37mLfnhf4EUlqDoRRZZG5i6s4A9j3cgvrfrcFgH0vtVB7RiXxwSSeYjd9uwbp3ztE3ricI5qc/ZmxTLu0ElFLEv+fLWxZHmYgZKcmsQZPuUnan6R/9wpiP36Fjq5amlmI2wu1Zy2ltkTjnsTvmKDGiOsJSqUicg70YQs0Emvbwpj+FbjHV/DC4HhCUQu5qo3+jW5MWUDUoH3TECnVwwZOw0WQFiaQxEVfoR3rkI2dxQGqB4eoGFBxttaypqwe9mrMaCqldfJ2vL1uKpudzM+/Gy2Ww9vxcwlSTP0Gjf5KDUmHsckOpuZux0WCRc4V9A4EeGp+N8Pj2pHQaDxtJ/NuPx8zpWB4+vj7lJ0Mp11sPcmJIRkEvXNwJmJY9DhVm8ZRsGcMMU+ashYPom6Qk4hR13CAA54kIbUWQwnTqzioW7aA4aIohjxA2+Q8cjsECtoEZFGhwtKAL3mAXrmQfc5qtIQFW8KKAIhJDwIaAhbC01V2Xroaa77ILfm3cLn/CgQRut7uo2dHP+7dPjwdfgZK+5ASEq7Hchkwh+ncMkC4L008fsjOtGPLIN/87ZcQ/6LQEW5nkXM+hlVHUkQmX1YHwHBriM1/3okgCsz6whRc+cf/bVrzx71E+zPn7lv37OGye+a99/mb5V/GB1L5dF1n9erVTJ48Gb/f/94V3oP2aCdOIQhkPHlNzNG/BwVYyOighz/O7Dskir7zmG7qqIY60l4mKtc0TcLBEFcv+TRT5k7juw/cyn0//COapnHA0cnTB17AMA2SehLV0NAMDdVQUQ1t1OZBMzT0EWH3YP+mmelDM1WSeoqUnh7tzyJaOBBtJ6JFR8eW0JJYJcvoc4BDQrCIgCRKSIKEgIAgCAiISII4sp3ZJ4sKXtmLx+LGLtuwSzZcihOrZEURZCRRQkREkRQkIRMxLAkSiqggHtbO6H9CRlC2iApuxYUiKpk6oohDdmCTrFhEC1bJgs/iHRWPsxHGWbJkyZIlS5YsWbJ8OK6/vpxZs7woisCMGf9+ofnhh7tpb8/cmMfjOl/5SjmGAaeckvMeNf99/PnPnTz9dB+FhRZuu62G/Hzr+667pOQktgzuYE9wP4uK5nLq2BNY//R+kkmd0lIbNTUZIS2dNrj//k56elKcd17+oaSDgTnv3sFIDpg9wf18a/s9mKYVa1Lmt4KDwraHAJBFDauUJKk7aRkey6mnZvpUdZPbgtczk2UkcWDGzuVmMh7ts2b5ju5KELhmiodzC1Ncd50NVa3h5Q3gLAryzRorykN9ODWdyghEEvWkzV3c33smK0oDuHT4Us566i1vwvAC8GfsEK60PcrSiT8llkywrzjANz1348gJ8IlFOTy8N4ZLEehOv84d2/+Bx+hjmd7HXQVjEOylLI9dwBvqbA4kfEywaPz+h3V8/d6/sds3A9Euk46IWIUhdO0ZJp5wDm2h6XR3xTHUKFv7LUwLNOL01LBTP4mnXcUMNfyA5rZxuFIqbj3Jp79YyNbQJfzyVSfrnHvpTPeiWiqxWRzYbU40RxSH3YZpGBQkBEqMFIuNASqrX+KuriLaQqXYLBqpkIy2Bw7kVHLvJo1YZ4qU2o3Hq3Lj0p0kjS3cHVlMTA1zVe3V+Hw+/vKPCH9/LUZSsGMtUxiW2xB1EcGmIs96DOmtryPLAqIAyYSBTzFw5VpQBRBsfcSTArG+QpwJG1ef7+Yn9wUxTBgIGRQX+vji2XYuuXQKoiQyxgVjSo6e7CgIyBQEDkk1XreI132kT7k5bRGx7dtQNZOBwjK0Tif11YeOf7LuHNLmE6RSIt854XzcziNzFu1sVFm2LhM937W1iVWv57DkmlvgpUfBmwPnXPXu5/9BCksRPSczvP95No7YrJxpzXyH9DUMjhaLdMcwUvoRVSXl2HmUrE4FUPD+4hd0X/YP9EiM5K69hLub6ctP8JTwIud1utFMmYTpJB5RqEiZ7Hvid1z81DoSLgU9z09uKB+pyIO/2Isr2U1v0saeDQlKfS8jTy1ilp5i/YZ6GtXxqJpBMqJi6ib9lNHCJLpr2ukPFZGWTNx6klvvTyDpFiRDZ5mqE8lxEi5TKN88lrEr6rEkTTzePQwWJ0g4IN4vQMxkwu5hUo0CqubEY9cQHAYyaeykmZb7VwaCFpaTBFMgbTqxBt1YxCATBnaybt46gi3z0UUQDAl/eyHeUB01W2TKttSSEp2khCDtBQK1+m68vRrL5pjEx6yi+gUX9mAugjOFJWmh4EAuqk2jrS7CqkvdLHoMZq8LU59ci4FGgdpOt01g89kxhgr6KO4pQ4p6yF8/Dk8sQFlnLb3RPQT8Hv7W9TfmuObQ/cdhml5rBcBX4ea0p86jz9uLZ8iDJcdGokCnc0+CwZ4enAVOFLuEIAqUz8zDmWPjBzdcP/q+q9eqCJKIbMms6H/jx+toWt5GOpqm5Y12rn7t0hG/56ORD3MBkK3Z/FwfNx9IaJYkidNPP52GhoaPRGi+csUXkByHTojjCcdHPjr+XjNTmZG43kx75sF2TXofbiXuitF28TC/afsTLZt2Uvj1an7ecw90Z9rTR4VuY1SoPljfONjWYVHI74bX4mVKzmROLz0FQRCRRwRg3dTJtQUQR0RgAUbEXnlUxFVEeUQctmCTrJm6goQsyKP2Ex8XaRPSWvq9C2b5X4NumiMR7YxMzpgYmFhFiVzrsc34s2TJkiVLlixZsnx4RFFgzhzfx9a/zXboZtxqFVmyJPAfFUjS15fiqad6AejuTvHMM/18/vOl77u+RbLw3WlfP2LfH+9IEG1bTV71VGy28QA88UQvL7zQD8DOnVEefHASDsf7ty5sDDeP3r+m9BTt8X4KRQUMEL31VM6YylsdZ3PBxCIWFP4CtkaRK67Gbi/l9cSlAJzvOnop+LHo7U2jHuZf2tGwnVlVGmfWuWhb14PNZ6Pm01/isY1xNtpD2C0m4+07uHTq49jDVoi8AVN+C45SaP8rASVCQIE8d5Sfz44xYdxsOqIab3SlSGgmot6CUxFBd9IUT7Gny4onFifROZnVQRdSQKUzovFyiwNbzfkohkHasCDlFeFXn6TiQhsrxfWY+jz0tIKmgWkIDP3tL1QWqlw6ZgvjPDVEL76EPz2ykTz5VSqm3sDre3xsWO5kt30fSXUBgsWPu9rghMIqOnt1hsMe4kkrxendzFcbYb8Lu5HDBF8bOfYoJe4tbO6djpC0kUhDx1qTRGsJIioOaZh6/za+MucpHlpTT2DrJ7EIVSw5O7PUfuXmjPja3+1E7fgMZvnzCLEcpN6pyLUrMcxMxHCF12Rfq46bFLF+A81hRY9UYEgD1DonUCpM4L6nI3T0aggC+N0i0+qsXHVRDuJxIvS74z28PbCDCf5xjBE1SPWDbxqIR9/79877Nve/Xki+0MEr4oU41zzFzJTKBWPOpMhRyOXVF3Jy8QIUUcFv9R1V324VaO1WOaXzUc7WXmVCzApf+RrccMf7OhcPp9ZRy/Wl1/NW6C0mOicyxzuHpJYkOiFMYnkSu2CjcHIe4y8aS7Q/wcC+IapPLien6uhxvZNArZ+ebRq76q9ke+GzbJjZgtEWZoP9dHzJCIYuo8peWlccYMm29TSqadzDKZZPcfCn+gLOWh3homiSjuF81g+eQMxmobl0MvunJfmHrvKpDbvQUuMwD9PATSSemVLL25fuxzGwBSm9h6lNXuyv6aiKwbOnR2kOPI644wwqtuVjD0vIqoYExA0XmqEQ03NIiTLxgmEGLRKudBx/r8b++Djq0rsQLCZSKk5YkDhjWZpwnkhHscSs1230hVOYNp1llzbTnFND5dtxLPEcdKdOYDDNgsfHYQtZUZGJlIdI+OMkgJXntuLqdtA3vh1PUmBv0ZvMuucaJHWIaCCELepGlwyiXhcT35SoftuGK9WDbkgIgokua8SL23nrzLfR7To7pLepj40ndGkHX9p7C9td/aiDKbr7+3Hk2Ogu6uHA6oHR1y0VVZF1mdz2fCSLSO5YP41aF731QSZapmGxyMz53Fg8hQ5c00Q2hjcy1jEWr5yZaDWtJi3JJorEItyym6HmEKlIRncaPhCie0svJdMLj3meLPrqBN66pwHTgLmfzyRB1TWD9XdvYbAxSM2SCurPqfnA53aWD8cH9i2YNGkSzc3NVFZW/tOduy1OZMtxlit9hAhkbB9a395J3vQChn7dTv/GHgRRIDflZ4z32FmB/1neDg7QZpzAIz3vFOpEIHysKkdhSaf5ya2/AuA7t95A2vLxCcxZ/nMZjYofjVg/uP/QX0EQEBFGymSQBGG09kFrldE6Qqber6Yuosbl+7c8jyxZsmTJkuX/Mpqm8cgjj3D66adTWHjsm6ksWT4qPvOZYuJxneFhlU9+svg/SmQG6OtLk0gY2GwiggAezzvE3+AW6H0VnJVQcgm81/jj7fh7b8dv0aF9Jbj84J9OKKSOFkmlDJJJ4wMJzTNyp/Ko5SnC6QgF9jzqcqeB7ZvQ+RTYS/BUXssZc2yw5zYY2sWQrrJty818Ydo9bOzy47dJXDzu/dmV1Nc7GT/exe7dUXJtbSzKfwShMcmii+YSu+Z6bF4rslWmY02MuE1ENEzKHAMoMnR0dqCpGq68XeTWlKI7q9BDDQgC2O1OFtTW8N2Ng+weNpEEsIom4/DRHW4ExUFvx3lc/fI5pIJtdEdWoJXOwAhUEzvRwGYViBsWBFOlUB7EZQtjCwxi9wXYsjwX+p8HVz2GvQpHyyDt3ady3ZQ/MCkvgjvZSJ1f4flZv6ShK0XPPhFTS7F1yIEq1yB4OsESIZ500NoXQ01ZmbqwAFsyyTVtO+jZmcOY+T1Uil3s1yr44cl3oRsS3349l6AuMZjwku43scpgaCqaaWHR2GY6g15e2TuDogAUuRWefSPG6xsTbNiZYihkEE3oqNpYrAPXkrK3IssKOR0XkFup0NVnEImozHGF2Jt0EEwKyJKBKDlw6GVUqrUMJwxEAfL8Es0dKqYJrd0a9z0V5kuXH72CoTfex+kvXUpvoo+TLAL3FRThVpzgGQ8TbgdBIJky6B82KMqV8LlFGlznsjZi0Ob7OzZ5FYPtEpsHtvGnhXcBkG/PO6KP7lQ3kiCRb8lHksBmETjVeBNZEtA1A956BeYsITGcRLbLo8nW1u9I0tmns/AEG7n+Q5+NvQfSDAwbnDjRypLAEpYElgCZRJw3b7qN/WYzlk9YuK7oMyxeMA9JFpn7lQ9mW3rSzbPZ+2IzokXghf7nSRoiyGlstUmE5jwS/TqmLtPXGCXiSFM7qZbunh7UraWUDpfTHVfZ4mrDkHJQBSsRmw0hbkWJpKjtPYBdHqBUaKSNGsBEJo2FOCfFXuWkZzpYMdnFy6dEENyF9K6z8ebift6anmbAlmBw3uO4Ui7m/eFMAvtLEQwJazqXjbHLUarf4EBCRUhrxMt6aCruZ9Z98wi7VL47z09t0xgu3bIPhxQn6uvjvEdcoFvoLw6y7JStkNtGf7lKUoqz8/yXOPkX/4Ur0EbT3LUkAydgmvnsPGk77o5KMEXSzgRdk1uoGJ6MblgJynaGS3QKxnVQvreAtEMm4tfBcFC2VUKx7KZrggXnukqGKKDAbCOklvL8lW0IVgFDyKzkt7e5cM2wkJsnkvfzPCwT7QznDZHXUsy6X3QTjkXYO2ktrn0O6tvq8RQ7CbZFEESBt11vs/GiVUQG03T07+ET+6+lbkkpg1I/X9n3VaJ6lBw5h7vG3oUQk7l+0w1029rJ9eXw05qfMvHisfTtHkAQBLzlbqye469o8Zc6Ofu2GUfs2/dSM43LMtHWG/+4naIp+fjKj/a+z/LR84GF5h/96EfcdNNN/PCHP2T69Ok4nUf+KHo87/+Ne+H0xz5Q+X8WW5+N3pfaueGGG3ig8QGmTJnCyntX8o0ZX+Gqq97n0pAPwIIVT9CXjOMRPnzovsWAeRu2jm4b/0RbWT4YB6N7DUzUkUzwpmmSNg1UI/NPMw96YzMSAc+okHu4uCsIh+8XRo+Nyrwjou5BV21JEEZ8sUEe8chWBBFZEJFEEUlgVDSWRsRlSRCRxUy5g22LI/1LgoAsilhECUUQR9u3SVImUeNImYy4fKjdMrubKue/fylnlixZsmTJ8n8RWZa57rrraGho+LiHkuX/AF6vws03V33cwzgmy5cPctddbaRSmWvwyy4r5KKLCg4VSA/Bnh+CocLgapBdUHjmuzea6uWIsMVkFzCdCy4oYOvWCD09aS65pODoxIDvQaGjgLvn/Yxg830Ux3YhttzDb9JOdoV0FjvKuUwaiVY2DSK6zg09rQwZJvKO7/PTmT+g1lv97h2MMJTQ+dnGEL3zXXzijBQX2pdh1TPWJ0J4G666zH35QFxngyIQcEr0aUk2u9zsizSTMxCmI+hm+ZtPcPc9p/OT+A+o1ALk0IO99CoCu59jd1MVSA72aNUUWBP8xPUivaaNcFRlZUctq/qDdLbdD5iYkRXYpv03gpqHxS5gYMNPkHG2HlIIuKRe3mo8kcFECYpDwRUbQH55E1LgPCRXNdFULobZAug0HEjxzJudDHb2oziLsEmFGVsF3YmWCiA7ejh51jNE9k3B5ZvMQH8uXTuGOD+qkm+TaBgeg+G28DP/9Xx37q+QJZMvzPwHy/o/y7auHBIpE9N0keeRiKdlVvdfxqa/NxJwa4S0MobDOruaUsQTJhZFJRKTyPFJ6OkEPb1NGHIBuigz5BGoG2+S41E4b5LEuqeG2GTIaIJJIq4jiTpWq0xrt4okiqTSJpUlMkMhg/oqBUmEl96Ko8gCF53qJOA7JNq+1PEavYk+AMYZg3TFBcZ5qyG8G9Qg654N8+f7uhnw+Sg9IZc7vpbD7dfn8PdXwvwj2oc5osH1JwfQDO2oXEhP9D7Bgz0PIiDwxdIvMtV6KkV5MvFQJXmxvUiyAKVVbLxvOw3PNqI4ZE65dR67og5++VAIgOdWxrjnu3lYLQJvbEzwy4dDmCbUVyrc8bWc0cmq/uQA+0PNoIF7tYf10W2Up8oZu/T4wYpDrRFMEwJj3ACEuuPoqsH+17vo2jaEO0fkU0NXszm+GW/MR83EGuq+Xc3jX3yLZFgnkrSyXpjN5B076VMr6bOV4VB1CmJperUi6q172atUk4rnEKowKYx2cMqmBrwhKzO0lxjmE8RwI5NmLFuobI0yiMHkrn5WxjwMegV+dXY+hsvOoBQmJgpIapq87hwkZwi1PInYVkteIkVf7zSGktWs//n9jO/q5ZLHLbCxkm2uJNGSATomttJVZ8G/7TL08l7iyVxOGlyNWr6HRy+L0JW3jPY8hdwuD2gW0haBZG6MheoqNhX3o9Z14+nSGZq8lUn6JrZVutk+q5t0ns6YDZNJeaLE/RF87fnE8vtok5101uSRf8BBMF8gWLoF1b8ZJWHH1p9Det+F5FgGGett5aKZs7m36z5ICMx76FTGrZ+IvVrBcq0Va9rK6Y+cT8wTxRkqJeXTWP/JlxA2mDijdlrTbeQPF1I4KY+hliAbKtbQE+vGFrDRU7mf+efXsPPve9ht2UW0LgoCDKQGefxvL9H5lxQ7z9iP6k6i1xqszl3N5ddejt1vo3fnABVzS45KHvle6Iet/sg81o9TMstHzQcWmpcuXQrAueeee8Sst2lmks/p+n/um2cYBjNmzGDx4sXcfvvtrFy5kt/+9rf8/ve//5cIzQA+ixW/5f0thToW1sNeTp/FRuqfaOv/Z3TTIG0YI1YncCgpIqQNfWQPo3YommGgY6IbGSH5oA+4SSbK9+Djg4KsIoqjAqxLUrCKEj7FSqHNgUWUkEbKBCx2rJL0DnFXRBEkFDEj8MojQq8iiqOCrjjqlZ35ZxWlzD9JxiUr2CUZt6ygiO8/uiJLlixZsmTJ8r+PWbNmsXXrVioqKj7uoWTJ8rGxatUwpmni82VuV6++uuTIhIBqKCMyHyQ1wHvinQzucRDZC7YiCMwHoKjIyh//OAHDMI/r//meTasDeIdWANAX3M1w0kJrOp/v//EHPC39jc9+4rMsmf9ZmkPNYDZxnTWJM76SrgMPUzvlB8duNNoIw5syEa3eyfxtZw87e9MQbeKxvhjnjNmN1SKBZAf/rEPVYv3UshFrZRkrB7uxeLv4er+HghYPtv1FKFI/hmGwYcDK8/GvEU0bzG6L8iPvn1GECpKpGMFlv6Ovcw/fq9T4/OluZNGL1R5nKL4GI92FYvFgUxR8lh7KykuJAjMKnVzg2cHmlgYUYTOrHTmEohVIoh1DjRO35CHlzCOue5AleLj5G+QFfkeREefF1lMY3nUvWjyCGriSuDWAzW5BLJOwKh4ciQjxHVNZXL2GrW1++rqi5EYivB5dgIxOMjrMs46l1E6ZxqrhTzKn4A3sLjd3nfIquuJjS/wTxFQXbb0ay9cnACdJay5LznHRN2Tw9OsxyvIENuxKkFYFQEXTFPKcXViN9aSZjmAkEJUA1dVurjy5gobmNJudOooaxWUkGU64ccpRMC00dzhYeIIdTTc5oXKQJdX7eX1PFQd6cvC6RJ57M86eAyq/vCkw+r5N9NejiAqqobLPtONRXJkDjnKaNyR49Ve70bs1fMIArU4b2/e5qCmRWPdSB5o4if11Oxg3wcJVE88bFZk1Q2N/qJlcWw7PDTwHZO6HXxh4gaXjlnLDlV5WvPkNArHl5M31o85eSsMVLwKgxjUanm2kobJudIwDQYOhkE5RnsyGnamDjqI0tKhE4yZuZ+bzE7DlUOIsIrIsjuttDw63g3V3b6Fwch6eYtdRp/qW7z7C6kd6ialW1EUilmkgPORBjYHsshPrjSIIUDHJzqQTJiJViSyoNum97ZvkxCfRrOVhiLCrNMCByMm4dQ+u+AFMXQdTxpMI4nUMk2/roy9ejq9DoDwo4u6wIpgCYGAVwkRNDwctWmVVJre5hLGxFL6ZTpDTDI49wLRnZtPta0b2xqnaPAG/s5eLm1aTjgdoUyXanOVIMQFPWGDxnXM4Q3gM16CIPTgIagMbu07AGbIimyI750tsOqeYMZEO9EYbF60YAAwMaxJvbw55Vhu6T2Xs8jkk7TmsC19I3rpdLP/cq2DCaY0xWk7SmdnQy4LnLfzy8mq6prQx/oWFKEmZYGkv4fwBHEGdvkqTwaJMMJrmHcJqQOmWCUiaBZuiItpNzBNfYac8mVMGzqHgDxW4dzhABucBOxarBW16kudPf5y4FCOnqZThwkE6a5tYsPo0BBHSYhpBFLH5rTQ4ttNRfYBefzemaFIoFPKTZ25n7tqTiOlp/KcUMHxqL9EDaQaeMEnuFKjUZrDvE6tJhlWq7JlJ0MmX1sGlh86VvS81s/+VA+RUeZl13VQk5fj6yLgzKunZ3s9Q4zDVp44hUP3P2/9meX98YKF5xYoV/4px/FsoKipi/PjxnHbaaaM+WvX19Tz55JMf88j+M3inN/bo/qO2M/8/6Fk96ulrHu5afWjbPKwRk0P+vwIZu2v9oBf2qL/2iMe2CaqhA8KojYPJITuI0fZNEAVQRgTfQ9YPh6J6ZUEciSLORPUGLDZcsoJbVnDKCvJItLBFEsm3OvBbrDiljMAriyJ+xToqDHsVK37F+h+3vDBLlixZsmTJ8r+fL37xi9x44420t7cfc/Xg5MmTP6aRZfm/REdHEkGAkpKPJ8ilrs7J5s0Zq8HaWueRIjOAYwzkLoSBN8GaDwVL37tR0QIT78j43loCIB4ZufxhRWZgNIcPZO5jREy6VrUR3DdIr6+P3/72t8yc+SBVJ/yGM4OnkZtqQ0CgPrQaDA3eEX1Ksgd2fguMNCBAwemI7REIjgVTR5QUBEsO5M+EvMXgPzFTLzVARcvXudY2SEfcQrNyFn73PuJCEQ3bhjB7VcaffBZ9CQOLBM1BFUGAnUErmkfiet/rfOmBEoI7N6JZJNZFUzSP+wr+HDetznwM389xh6NghvAVV1B61nicTgmvAD9akIPfdj49/hSPNLaxtf0iVCkHinzIkR6snWHsfh+WZObebSBWyLPdn4IegVhCwow/i+m5krLSEB7XSna6FmLkWBFFG3I0F6NjgEhHBeVD32d7n4/+vhRdlvP5OZ9jv+ykyjWM3t7J1CWfpk35L+ZK38erv82GnQLN/UHe1r7Ctz7jY/m6ELsahlFEGf8lNi682EPZE79E2rSGO+RLeMs5CwRQNZnBeDG65XR0NY5gGgg46O9x8dM/DzMUMigqUohEdUrsvcyv2EwsZWUo4WMgnsPgcBkFObDQ/yCn1TfwyQlO/mftdzgwlInM7+zTjnjLZ+RN487ZP+KF9leZU3AiRQUTM1H4gQVEnhvEbs2cnzmpHqa3bqMiegYtLTVEoxoeqpmy+SauGJ/LVWPHjZySJre+/VO2De7EIlnIzXMxzDAA5bZyAE460c5JJ5YDnwFAMEzsfiuJ4RQA7iIn86fZWLYugaZnIpfzczLC3tRxFlZtSYJpUl2m4HIc+vwoosIdM3/As9teIeyN47G4wQQ9fYygxC1v0fDELoyghGLqDCzzYL5qYk8GEVQrquIkLRiIpkRPLMKuvI3o07vxXBFnz+AsdGKEJ3dht+aCZJIslMhpzGHMYCVWnwPRNog7tZLdkYlEIwonmK/QPlhLdLCIGD7cBGlyFnPA5sI5KDJcEOSZqQnO2WmntMtGb/c0Ft7npaD2MSr255PqzKHs7YkEFRdCXhvKvG2knWlaw1MwFANFTGDKMpJmULS9kiKxCMkSwUhKKJjkpwY5eVuc3tB09pwQR3VaWLRmN95wmrsurOD0VU24U0m2T9GpP0ulSgD98g28fuV0wk6Dccoa5t6fYuMEG1uWiDiTAj3FJotftaDnJQhP6ce5uZz81hxyhmyEPGU0L1iPrOcjpSdQ0CZgNSQa56TRrRpKyk5CkEnFnPRt+hSBrwWJnBVC7HagoSPoAgk9gXeSi51zNmEblEhuF2lYsIlAXwHuiIems3eSd+9i7INeLPl+fOPLsE0TcbS4UXyD6FYdV3MuW41tzEwvwGlxcn7yQqRilf6nBDTNRto2TGXTeDyNEudOXsxM78yjTpVwV5T1v98KJgw1BfGVexh//vFtcBW7wqm3zjvu8Sz/Oj6w0Lxo0aKPrPNL176I4nR8ZO0dn8wPvza2gqc3rqF39bOjR3ateIlEjptzVj87EsX6bi0c+9HxykqCQEc8Slh978R5R4qoBx+BPZkaLdMSC5EYWR71zv4Or5d5fKjFQ0kWDxY0j/s8D8m0cKzNwy+/DvoBj0blHi7yHlZSOGzjoFVERvgVkESwSzJ2SR6NDD5kASFRaHPgkDPH7JKMTZSQRXHE/kFEFMAqSrgVCzkWGw5JPsIuQhJErJKES1ZGLSWyZMmSJUuWLFn+U7nssssAuP76Q5nYBUH4X7F6MMsH489/7mTt2iBTpri57rqyDyx0appBf79KIKBgsXx09npPPtnLAw90AplI4gsuKHiPGh89l11WSHGxlWBQ45RTco4uIAgw9htQ9cVMRO/7tRcUJLD9k/7ng2uh+XeZfsd+E1y14KqG0suh7zUC/lnYUg5c8gsUOQpxKc5MQI1p4ra4ObviXBLdz+GQHTis/tGxv/76IOvXh5g61c0Zs9pGRGYAE7qf5YpcD70pOz0Jk8sCW3DGdwAzIecwQSayG0ELU+NTGOMxuLN2iG/uO5HmoUmkJwQomWFiKda5bOcfCDs8GMyn2quQa5e4M3ETb7bECVv2IQgiggkpWwFt4jja0x4s5gDlU6bgtwdpPBDBrP0UzYMWJvh0TLOXeGgVvtb9XNr/JrZUmmviuYiiH1MAyZePt9tCd0hD0EVyvBLFueLIOW9y1dJ2phefzds7Itx4ymNIKPwwncfG4ETQFNI2D3rch9/sZPneTlJxDwNOJ2usIeTiAmRRpTeYR0lRikljLcyaaKXxH0Fu/OtiNrRVoZoWhomzaLrExre2M9jlRgns4xu/7uHv4XxOjG2iKyCxeGANm5lCzPQhiGJmykDKwym2YBR5SEvlvLwxjZWMC0tpoYzNAqdMfxRHzWvQMYm8eAnBlJft6lUsmWXn1Io9AOS5Y1wxr4ufvViApkNJnsRl3+ylJF/mu9f4yPFKXFx1LhdXnXvUKVdzkoWNT7Xha2yiWtzNmf49FDz+No6b7iE318LAQBqX4mLRjPLROn2JfrYN7mQoadAbizFJncrFk+djl2XOzT26D8hMtiy5bQG7n9mPI2Bn0qXjkBSJu2/OpW9Ip77KMjrpc9pcB0ZDB7sf2kHhgJWBfXPJG3fos+q1eLj8v87jja71DDUHGbu0Ev+YY1gyRkPkuKL093nBNLFY4ggRGUkTEQWVeCpOyi6ge8KkIynkfgv+5/20RDPR4BJgj3vo+9oB5GGF8xadS+S7Tobb4lSdVEzDq5281uFCMpKcxf3sZwoOwqgovMoVBOt2s+aKN9DFRyjfNJGeCc0Y9jCdC4aZ9vwM5B2VJKpXMH+rRm+wijgyVhI4VCvDpo2yFxdi9byORdcwREBOI0opRE1mx+I9DFpczO/qwbV/DEJSZ0L+IxidSXaW9dMetLN0S5A5uxoxdYVwTit5QZ1HzoPhvG42I3EJPuoMB5KiYcx4lhNaQqQcGmevj7B9gUx7oUFFu5Xd1TK54Rjjl1UhiBqaI40zYkWI2RizYQLqBZuxWnuxuNz05LYzXDzA7pPXULSzCl31IyMgRBxYe1OEV4Z55qb7qV1dx6TlM+g/rY8fBL7LuvYNtKVakWpkBFVA71UpshUwYVYdSwfPY/CtFKIi0bV9iHO/fBZvDWzAGfMixGMErZ34w5PoahygcmoR4ybUcuDH7Tj6UoR0nYJ6H5VzxjLjyovJrTraXnf7s620b+wjFtRwekci9lPZ66H/VD6w0AywatUq/vCHP9Dc3MwTTzxBSUkJDz30EJWVlcyfP/99txNSU8jq+7MCOJ4weoySxz2iWRSGtjfw/ILzj9hf+50vM5xOHbvSP0FTJIluOkhz9PKQY3GEyDuCoh0al6bloGs2OEa5I9s5+Cockp8RBKRDjsBHtCEcVfuYB0brHRKTxUMJ5hARRy6Sjnwehz06wqM4858pCMRViB/nuewZ3TKA9xbss2TJ8v8v5ntM8n0QDnqlI4A8MlFmEYWjvud+Mq2Gib739x2eJUuWLB8FLS0tH/cQsvwb2Lo1zFNP9QLQ3Z1i0iQXCxceQ1A9Dsmkzne+s5/GxjhFRVZ+9rOxeL0fTZL1l14aOGL7eEJzJKKxbl2I0lIr9fUf7W+lIAjv7/WQ318SvY+U5t9lrDvUEOz7OShuEBSo+hKUX4kM3AR8vupz/PznP6erq4uLLroIn88HgLPmizhFID0MZZ8AQWTv3hi/+lUmadWaNUEKcyuYZivO+EgrXrAV44k08P2K18CaC8GdIBdm/KmHToKcWRDvAEMH0QpGClm2siV6Nn2DHoaGVXRBIJ02UU75Iaa9D7kMvITQus+nwCnzcncO3bKHxJRc3OEeokPb0aqnolrdSDqYNj+dQ0k6hnRsBfWM8U6mOS4gqPu5cMxK8g88DH09qORSro3hFNt2no0uRkRHUnV6+3IoLezFK2ssmm7nq1dN45nXFXLcIS5bugTtQgsP3PkTHFYJTYMTLNvZJY8lJUhMdsLEzh4CPW7iPZUYTgGXLUbaGkVM7SSalIiYVvoDDk6cYOGJZVFuueuL9MdkvNYww6kAadPgz88EiUYkmPoC6WnraJYN/qc/zs9EJzbJyQH7ZEodKjGnQceASDKtIyBh99dgn24hugnUtImiZK4UW7s0YkKa30pBykJjyMvfz+f0GDMVL9edFSCnsBQaToDgZrAVMXfGbB6c66VnQOPGXwwBsL9N5anlMT534fFzVzlzrLTOGk9hdCvTgjsZCEJ5YRo3Me68cxwNDTEqK+0UFBxKlua3+vAoOWzs6cYEukJlWMOnc+l7fFZ95R7mXj/9iH1FeTJFeUdLR4MvNZDrFtCiabY+vJslPzxSC4pqEv1zp+JfKjF1nv3YHZ64mFMvewP3Ey20R9w01TgpH+hC2l+BKQr05g4jxXKxJyxIPU6M1ToCfmI5SeR+GQSBhZOn4F8awK/4GfqdzPb1uzANk+3PtFF+Yi56/xD6QByPOUiAHnqowEREQaVx5l4QdSSgZc42RE1CMSGNhb48leHzXqNnbBszU1FyN4dAyyeNHUQDRQoRmbGMsnURkmY7nVoNuYkQnX6DgfIedp6+ma3WJA9XpwgYDdx2WwN6XOWF82HH5BQD4VWc+scCYroTKWpjyKcR9Gt055vIqoyYFtjj0Mh7uwwhlkYR0ggmKCkZDR3roJN0YRp5XzWXPdHJYEkUhziANeVCSYmECkMM5vfQsGQ1FkNk6osnoDrSbFuwjpg/QsIbYfkNf+a8m2/EEpIQVRnVojIcGKBjwj76Kw+QGL+OTy+r4NH1SSRJJs8uEPRryCknlAicXnUa11Zfw/BUgzUbMupNwTgvE1vLuHTlFRTtfJWBwrXo9hi7a9rZfOkGbvzG3bz03Td4wfMcgxP6mTM8n8W1i8mv8x9TZN63oou19+0FIBaTcebKFI73U3f2f2aOgSwfQmh+8skn+dSnPsWVV17J22+/TSqVEUIjkQg//vGPefHFF993Wy8vOP/fmgzw1pW7eGBnIw6Hg5aWFsrKyvjCF77AjTfe+C/pb8GrG+lOpslVLB+6DZueGN32ybkk5eN8Qf8H8U4pyDzeAcwPMoOQJUuWf4KDFjYmJsboNkeseNAP2tccvn24YY55mGXNwb/moeMH9+mGiT5S+Kjyo9NgAgdjjwTh4J7M9sEEmvKo/U3mOIAkgCweTIDJ6IoKRRAOJdg8uHpCyPQhjia5ZNQT/fD5MFkQsEoifos84seeqVNos1Lj/s//zs2SJcv/X2S9mf9v8M5LYMM4drnjsXVrhMbGTKhGd3eKNWuCnHG6H7QIKL6DP64fispKO729qdHtY5FOG3zjG/vo7EwiCAI331zJ7Nm+D93nMTE0dm9tZeVakbF1Hk45JfDedT5impvj/O537axdG6S83MYNN1QwSz4k5h0UEDOFfwsTb2f16mGW/f11JhQ38NWrTiNQ845ALMUL475zxK7BQfWIxwNBGU6+E2LNYC/LRGJ3PQ0IYC+B1C8OFVbDMLgG9t0BpgGucZh5J5N01KOuWsMSunndMo22VBliOkaep5fhdJJ4LIXDuoX/mfkJrDYbzzfGMADZIVF1xqWcNebTPP2PPhqSaVRZIpUGceJlCIULSeSWosUsTBAFOpMyj+waz+I8kzFCCl0PExAHsdk8+KPDGAhIso6sxCn3DWG3mBR6NrF+Ry2nzyuhrjKTIM7QDISpM/AMvIxkjbK092Ve2lOLU+6ipDDCmaevwdLv5nenpfnsiqnsblqHmW4hYZYh2GtxOSQ6elS6+3X+9kIfAjEEvHRGCtFNGVky2bZTIzF3DUbdKwj2KJLuYqNm5cXxi4k/08ugs5ghI8CYgI2+wUEsUhTVcJGKOVDfNnH6TYbDmSR/uR6JWNJAcHeQNCR64kU43F5sY6cxYcInceRlvsu3it8maYsyc4qPaEJkxcYEDpuALIE2EpBps77L59VQoe81xjmjLCucz9T4GgLmEJywAIor8ArCMT97FsnCzVO+S0Pvi9jEAgLKdGLqB/yiOQadvRr/WBkn4BWRXRb0VEavsHqO1jxu+e0QHb2ZJzkU1vnkWe6jG7TZkb/5UypP6aL5f9ZTGeul3aWyeM5r5HZrbKwrpfSFAnTZxGU48MU8yHkStRfWUDUtB1VxMf7caiyOjLT1h7WvkjSSqFETKZIm1GmjYHIe/Tt0evqrqDG3YSWOiUAYP54BL321HQB4u/JxDfrQ3EGqN1dRsLeC3stWoMoCDy61M9/VTuHyqZiAJoiU9Co4IrPRWMk4Ywu5QhdtchnDhTKF4jBz9g6zdkYC1WHiGY6zcY5CSYfKzmkCnfkChiPCDv8JaPunIGgyDWk36sQVKBp0eW049xWSXF3OH/LTJL/wPFYlSZ4lQdEArKuzE+svpGKZweW/r+DE/iauucvDrpo9aMOVNJy9lU2f2ICJzpRHZiLHZfafuIuipjL8nbmYngHKe0zssQGKLbs5UF6KN2SnY1IbUbtJ7Rsz6DzxbSIOEW33ZBZ/M4lc8yblMY2w3cJPv24yLqee/5l2K4IgUHoOeIsd7HqhDdOAPS+34WooxNFaSGUyB9k+hE2LsOnLBo4cO+uK3qLJuYaqtjjLnbvxvurH+ZwLLaVTu2TMEadIpPeQJuYudnH6j2dSUOf7p8/lLP86PrDQfNttt3HPPfdw1VVX8dhjj43unzt3Lv/zP//zgdoSRoSBfxeCIOD3+9m6deu/rb9cq4V824cXmq2HZUbOs1pI/RNtZfm/iWkeHQf6rvK+eazJAvMIr+13a+dwQdF8p9B4hH/de7Tznn29nz3Hb+vw8R09GXLscb5Xf4eLsQdfdcM8dtlRx/NjdDDqVX64b7kJh+mtR9nZHPF6HrTJMQ+z1hm1rhmJ5hWObEMQBGRRGBV5pcNEWzh6LcThbYojEcEimXouWcIpSyOWOpm2JTICsSQIOGQJryKjiIdsd8SRvmRBxCIKWEQRh5xJpikLh8ZkEUW8iowsClhHylhFEZ8l46eeJUuWLP8/0NTUxJ133klDQwOCIFBfX89Xv/pVqqurP+6hZfmImDrVzbnn5rN2bZDJk90sWPDBkhQVFloRRQFj5EKjvDAGW2/OePv6pkP99zLi5Ifg61+v4LnnHAgCnH123jHL9Pen6ezMWPqZpsnWrZGPVmjWkwys+h7fu7WStGHnRfd4bDaRefP+9cmcDtrUmKbJD37QxJo1QaJRjWhU5+6725n1229B6/0jF1kymCrE2yDRge6exsN/dPNf036DKBgMr32DQP6vMwn9jsPTT/fy/PP9hMM6TqdIXZ2L+fN9IEngmXCoYPknRwaoj0Qyb8gc12IMbP01kf4mbHYHjlwrt/ScwIFgkkAkzULbTix6hHXBKpqffRn/hCYS1YPYRRvOl5I0uH/J5V/+AWJYJ6UZGKJAKEdmddogbU3jjiSJSxZ0JNJOKxRX4LBJCFUCSTt0DuShCXEaY4UUOgdRDZEt6lRCrtlcHrqHfKODek8HgYVDrB8+DdUm8tCjwyDfQ8X4S/j1dyqoKlV4uTmOJ7Ech1MH7KxqrWZS+m80yPn0F21HLmpDSsvIw25qPBvZmRrATA+CxYZoLQbBht1qJxQ12NMcZiDhRTVkHEqSlOkibesklr8XY8wmZLyI1ihxI0XLgXpuOjAbb6WHgO7Fk9I5oVrEFn+RfX0TCakOctNBxF4bUsjAbtgw3S4qimQGo0m0/nEkwhXY/R1MLJnE2fNuwTGSyO9vr0R5+IXoyDnVz75WDYsCFUUyC06wEw0NMKdgFadOLQPzlGNPEDX9Gvrf4OIqEz+zeaHiTj53hgRTj/3ZPJwJgUK+PuUSnt4fp8wtcUHtP7cCwDRNbvntEIOhjGB95sITGNvRhJo0yKkrIBlJY3Nn9Iq0ao6KzADNHdox2zxI55YBTMMkqsYwUm7+es4U8h7Kp3K1CyMtISZlEm6N4dI+pkpTGX/OOPQKnUffeALxBZVPTr+MsVU1RAtaseqdpNNFqLY00dZeYppBbCjFNvkknGoQD8MU0cJ+sY4JL5+ILWIn5UxSuWYaQtKNTQ5hUTUM1cG0p05iz+ItDJX10BetpXzKkzRb6snbMhNZByNWQIN0IpPETXQ6ctjiqKOuoZ1JRidDvXFO2gG3Xh/AmjLZfkKQlBUGfDDgF7AqIVKaj32FDgRBJ7BnPE/euI7SXWPwDIhMffI0mmdspWXBAAOT2sAw2DwoU9uoENLyKWgo4prno4wd3okpiIzdZsfW7uS2z6+mdWkrKXeChXeeTm5bAWJcwjXoZv+s3YQDQeZuNZGAmjaTl77+N3q0ahxBJ/WvzMUtgmpLY49amLa6jrhegL1bwN4tEMh9FVtelIt3FnLBl79+hJ5naAZtGzMrYoZaIiSHdVJaDfZ+P+MmP0pqYh7Tls3gib+9SOFEN9c82YkzpqFjEio+ANJEhpqCsOTIc2PcqSXsXdZFpC9B+Yl55I09hgXL+8QwDR7ofoDGeCOn5pzKyTknf+i2shyfDyw07927l4ULFx613+PxEAwGP4ox/UvZv38/xcXFWK1WZs2axY9//GOqqv41Ifcp3aQ5mmAgqb57weMKURmqnlqd2UgakIy9a9njHzvSyfnDcvhv36jwNXrwfQzoOGXeuft4z094rzImR01emCOJB9+LQ6/Q0Y9HUhcew3DkcE/sI0d1cP+x+j/28xNGVccjxjKycbzX+92Cwg9v5/3M6bybocrx3ut3rfMOMfOY5Y7v1vKefbx72UMP3lnr0GtySBzlsH1HlXtn/WOIrwcjccWRvwcF1Iy4esiq4QhjmSN8zQ/tk0cEWkUQkcRMtK50mBf6wT4EASyiOBrRa5MOibsHx3C4aHy4GHy4qHwwOtgqSqNisF0SR5+PcFhbwmHPWxKO/rz9s+iGSdowCaUMhuMGU4ttlHk+lMtTlixZsvyv5JVXXuHcc89l6tSpzJs3D9M0WbNmDRMmTOC5555jyZIl791Ilv94BEHgmmtKueaa0g9Vf8wYO9//fjXr1weZNMnNhLxl0NaTORjcDJG97ypuvhs2m8Qll7yLj/HQRvKTe6goqqG1O5Mge8aMj3iVamg7vR19pLUaIA3pYTo63ofVYawZup7JRHWbJqhDUHx+xkf5MNJpg0ce6WZgIM2FFxZQXe3ANE1+seN3rOpZx3j/OG6e9HVCIQ1JOlTHbpfAPRZKL4M9t0F6ENIDoMVokWbSu/tNcqwTEIWMECdgZkTo47wXnZ1J7r+/E/QUObYeLrnIyjmfCSMIElBz7OcoSFD33czzO3Av8b1/5C9/X8eCuhRILt6On0Krw6Q1YrIxMo0mWzGf9LyKY82tOAJ5zFztpqqvjUIxgekL8frgPpw6VDTEGPDLTC9ZzWxlL9viM9jpdeLfugz/7PMYCrsJhU10l4i1swnJW4rsKgbBSq8xhgeil1PF3bwVmsR/B6/FGxD4jL2B8uRaxlhTJGQn86e+yLW/jhPqKkIQdtOYDNPU/j2qShVceifFbCNBJur1tKlO9u4NYZb20YydzrQTa8pBOJXL1tYkZsFVUDUJAj0Iylak5jKu+68ETR0nU5GbwkqSYNyKTTboMNKkpv+GpJQCZy9yOgdbtJ5Ex1jsnfOJp+MkrBEi/fm4XDL5JU6+8dkr+etjz/CnV2W0Xg9GUiMedaJZRZANEo4WxIrNBAZzuGLmlVx3VjVFHh+SeGiCZ8POzDk7FDJo7lRH79t8bhFRMPjhwp9CshtaASJQcsHR73e4YeRtV5lau46Jl3yaCvf79xmfKFnY1aqS6xexfkglYGA4Ixg77cKoyAwQNC2MPWcsL926hdYde9n5fDsX/XoOilXCogicMtPO8g0JZAlOm5NZHRFLGCNtHRkgUjg5j4Z/NOKzeOl19JOqSmCepON6KEDMMEg6QqTtKvvK3ybt3MOOzRvZ/YcDVK2dgGPAyX3+pzjj8jqmv3gfhOPsZTq7xRNIDqrIMpiGSdBSxHLjSgJKHx3pAmQJdMHCuNVTR8dhn2AjsTeBqSkImHgHXcx4aiGCYLJ/3jaePLuXqGYyd6AS5wEXCiai7uTeWbPpEmoo3ycwQd2O3wxhawmQ16Jw7RfPoL84jTRhFWdv3UNaMHn4Qhlvk4eCJity3ELKrjNQ0cXJ956Fc9iNd8CFUw+zbmI74TFBEIyMdYasoCOiG078+8azO+ViOHczsdhpEM/hqSteJ2mNQ1rEkAysMSsYIJhgSViJO1UW330pE/P+TpnZydo6k5A/DfEgNcvryG0txBQglhehbOOJ1HdZMT1WKCjG0jhEYbwIo93gxILvU2HNJNrb81IzTa+1IjmsoxN1mmrgr/RhHe+D4QHm33Qy8X9IDLdF2b+7E99rCUrFAIkxQZzDLly9IQYrJSoXlR11/rlybVz2h3mkoip2r+Wfuv98ZfAVnu5/GoCdsZ2Mc4yjxFbyodvLcmw+8N17UVERjY2NjBkz5oj9q1ev/pcJth8Vs2bN4sEHH2Ts2LH09vZy2223MXfuXHbt2kUg8NEvxQoHHQiqRDjx3mUPcuyPzIffe7Qj84fh6NofpL1jeU//K3n/vb2PkscQcY/1fN5LCP1gr8Dx239/RiOHiZ8cfg58QJH2iP2HyaHv2+1EOEJiP1KQ5x37D24fLVYfLPP+Rvru78CxPh0GAu8+v/6/iX9+OdzHgSQIWCQBWWREAAdZBIsk8NCuCM9dVPRxDzFLlixZ/m18+9vf5oYbbuD2228/av+3vvWtrNCcZZTp0z1Mnz4i8PbnHzogyGD5iO9t+l6DvmUgWCH0NgoCt13i4vZXvkXasH+kyQgBsBUxriLMxMpBdrYEyMl1cNJJ7xHNbGiw+3sZK4lEB2BmbCeCW2DaPRnrCT0OxRfx8F9Vnn4645G9dWuEBx+cxI7gTlZ2rwFg51ADq/rf4pOfnMSf/tRJd3eKefN8fOMbYzJ99b6cSdaneMFIs1ZfzE/aTsNEoGBBEYngagrcPZRUV0DO7Hcft6lzTs2vmTpmB7ZZXfTGa8FaQLF0Kw7xhKOK98V03BYBuyJCtJFIXOONBoX+sIA7t4yQXA9OgaG0iCDZsckiu+RyDKuG3dJKKu3mFL+IpuloDoG82TPwemUuLd/BFM9fqSjYw/cTN9Eck9HdTvz+CIsGfkJa+Aorm0rYF76f0MAe2nbauOO2/+a3cQv90QhTnJ0YUZP7Yxejxx3EJZ23p99FaeOV6OzHbVXp75VIxAwqnQ0YpoBNEZhWl7EiOam6hKZWD+lUhFyHxLTZ57OjuAxP7z28vL+Trzz9FaRoPtaIk2SOCTYDxj0NZRvQrRGkqvHkF9qYVGPB5iulWGil1hIhJZfTO7gHQU5nLN9Chei9lWjNlyDjJhhygBJFyt+O26lSU2dh8540S+cV842bbqC16ye8HQogD/vZ7p6IbFGwJmKUN66hZvIyGubmIQY6KPXNPOq9mlZnYV+riiCAzy1hGCahqIEoCCyYrEOyG1UzeWtvgAcflamYMMSXL/cS8B22GiFvEem2R9gV3MMKsZi31n2Xn826lWpP5bufV4Cqmtx2b5BkOnM35bSLXHvxkZNC63ckeWp5jKJcmS9c4sZmPfKz/OIDG7nnZRH8uXz+ilzOmSWy+rU2Uv4izlnkpGNlC+bIyopQV5xwV5xAZWay4Guf9HLuSQ7cDpG8HInX1sX5zWNhBOCrV3pZfOIha56ymUUsvWMRoY4Ip46dS9AaYsLsOl5oXsW+t4J0FfZgaGnSSoS3kyGC6h70SRB0DbLggaXE0wm67n+GsbJBXDSpMzexv97F/vwogZ4C/NuKSGkCAzkSHV4HJ/asxaNH2WafgRjMy9wnGgbyYBqrxYJuqpiaSi1bUYw0e4QpNM7Yj+FPIYXjbD99A4X3nEGv6WPZZd3sPfUAAi241qtY7lUR0RCAYYpIRwvJ35dAaFlKz5h+KhvC5G71sPD+JeT2+BE0mYQnQb+ZJtDrwpoU8cV1Gk/dR+fCffhDLoQ0FG6rZc6fZmNLwI7Fu0h7h1iovIwzrJMS23hDvhw56SbtjGHbX0BaSbHr1E3MenABukWic+pepq6spqxHYo9wEb1VK5HX1lM+EGZ4/Nt4hp0YrmGkeACP5ibypW7eNHsZ/49FjPVW03dCE8/2hQl78qh7Ps7S2i5e+9UWGp7dh67akS0ipSfkYvW7qF1URGwohZbSmXb9PFzn1iIve434UApdNYg7C7FqFeR15JBO6kTm1nPWrxbjKzv2pKUkizh81mMe+yBE9ejotolJ3DhetrAs/wwfWGi+9tpr+epXv8r999+PIAh0dXWxdu1abrrpJr7//e//K8b4kXHGGWeMbk+aNIk5c+ZQXV3NX/7yl3+JT3Oe6cdmmOQ5PtyytSxZsmT534GJZoBmgmaYJFSTuGaQ0kwEgYwFhgTSSHT3QWHZaxXJd0j4rCJ+m4gsChQ6JWyygEMWyHdI1AWydkFZsmT5v0VDQwOPP/74Ufuvvvpq7rzzzn//gLJ8LAwPq6xYMURBgeX92UXknZTxZ47uh9xFYDt2Ar8PRaITGn8NmJnoS0EiZhRz452zWLt/gOIyLz/8YZIHHpiA0/kRrUJylCFP+gG3fX8dPcl6ArXzsNne457KSGVEZsiIwJigJzOvS9PdMPRW5lh4N/39mXs/TTNpbIyzbl2QgolH2gq4ZCdnXlrIeeflI8sCknRYyIK9HMiI0rjrWRs/GVNUQMmh11HKpIv+RI7QB9YCkGzHHXJJiY0vX9lPYd92bLlxRG8EovtA9hAXt+AgIzSbpkl7e5KH97ewtnMIl1XhR0umUJV/KgWRPZw0LcAbu2U88jg+MW8RQkghnNSJpRxYnDXUFW3knBvree7lHiYVBHB54hi6iqrpqC4XohHj+jOeINLfT1yXCSZziOhOgtZCNk25CUf/I9x70nKaDpxFs66jTD+HCYUHqDrwVZaXJcBaCKLCpm1VHOivIyFayHVJuO0OXCj0hirxeYJ0p8r59MK3ufu5JAgi37xogFx/5n19ozvGw4lLmWl0IHSeyOamcXT5kwicRmE4woHhatIpB3FDyuToIIpesBsQQNSJO/pIpj/FsnUJbrgqQFoNMLHGQiptcsUPTNam3ZjKEKSdGLsvRE/7sDpciEIcU9Cgr44ebzP9e+x4xVx+fK/JOH+Ey0+qpqf1r+ywXoqeFjDTKRSSjKWTc9/cw97yADXvEH2ffj3G6xsS1I1R+PbVXlTVZHezyvb9aYrzJD5znofGdpW3+6Yhh9bzs9dOp2G4AkdXDEUWuPlzfkzT5K9Nf6cp3EOV+xRWR2Q6RQ8YKjuGGt6X0KwbJin1UMjOwWjig0TjBnf8OUg6nmZHXx+uliSfvWUum3anicRN5qfX8Myj3ZhpDwz18do/yvjBwM85u2cAi2csgfLb6Rxvo+9vu4lKuUhlY/AUO47oo6r0UJLSx16JjfrR/+2V6BFCM0B+fYD8+gDJSJo19+5lXaiFk38wlwm7h3lhXYJX1MeJuENIcSumnglXigXCCKZA3BOm0Z5kSsyKmYY+i87qT28kbTPZOrCVueHTcXQUknLEmBNaR43ZjCMhU5AYZoVwMYYpYwKx7mhmJagiMUl5nd0LdhFz6kxa246syhwo1KhU+xg3ZMVGnCG9iNZJ3Yw9EEc0Tdrq4iRlD23iZKKpEpot1aiGia46MWSB7eZC/n76Csob8iltdSKZOhI6EVuanN58cmklvzuAbknh8jZS32WhYLuPHeNSTPrrHOQhH6ozSP7eStqXPofaJKIO2jGUKAWhFmY/fCrRoiAtM/qIdkLx0BbOHFzJY/NyqVk3DUdfPl05EgN5wxg9MxEtIrVve3HvUunyhjACkC6J0HTudj6xspXCrjTbFjdQUHoPt4VeIp5UkMwI83tXkvtwMSuiL5OjjQV00DLzfVc/cTKKTUZNaqgJHYc/IxDPv3EGyf9eRzysYy/PZbv2WfJie1G9haTSOXRv6Tuu0PxRsTSwlPXh9TQlmjjVfyq1jtr3rpTlA/OBrwS++c1vEgqFWLx4MclkkoULF2K1Wrnpppv48pe//K8Y478Mp9PJpEmT2L9//7+sD6ssYJM/fESvkk5y46+/AsAvr/8NquX4FypZsmTJ8q9AM0xUw0TVIW2YaIZJTDVH7VwMDibpyyTWsysC1T4LMwqt5NolKjwyxS4ZtyXzfehSRBzKv9ejP0uWLFn+t5CXl8fWrVuprT3y5mfr1q3k5+cfp1aW/5/QNINvfWsf3d2ZZfdf+ILGWWe9tx8rRef8awakxxldX6b4wUhy37MT2LivlKGwRDQRZ+JEkZtvbmRwUOX88/O4+OL3v7R/lNB2aH8MrAGovBZ8U5F8U3nfi5plJxRfkIlcdlZnbC3COzJib98rIGd8c0l2ceGF+WzdGmbduhA+n8Ltt7fwpS+V88UJV7O6Zz2TPWUskBIQ3Y/VVZtRT+LdYM3LCMdlV4DszvRReBaTcl2sSGVE7jK3jNduA7EiI3iroUzkc2oQEu3gHgfSIYHt9POnwZtpjHQ/7SkDVdYhug9HzjQgIzLffnsLb23pJTizF7dbIJoWeGnrOr508mngmcDXJyf4dNLH7qiVn70dwzDS9DcmcDTFMVwy539NplfQmXhOCdP8N6I2/Iy2xm0EowJ3P/EMX/vGJErSKsMWH7lGkEK5l/XUksKKIOlsKrmSPP+tXPfVOG8tvwCJNP15uXRYh5iib85EkDsrmTRvPt/IzWOdajC+yk7N8lYOdEymtHgdPfESOiu/xUVV17NovI4ogjU3kzCvM9bN51Z9i4Qe46nOPMzlZ2CmY3hKRU64oAzNGCaVcmIaIAgmkizhtnoZCpUiFG9DMm0YXSfytVcn4PRvY2ZNIX/7YTUeVyY69883V3HSF7/FoLmL1EAhVg0ExYGIglW0oiXBcEYQDTtGqIRhQ2Qo2cBeMcZ3hp/jsxfcwM/fKKFzRwoNBQmNRfpWyl2lfGn81SypWEJ7j8aO/WlcDoH7n4kAJss3JPC5RE6aYef71/pGo4WXrY3z60fDwHXEek+iabiEpGZFSJkkUpnP2isdr/NYU2aJ/3pM7HIuak87w30aL2xyU3ZBiunjrZCIg9UGx8hVYrOKfPZ8Nw8+HyHPL3HZaa4jjquaiaqBtmcPZjLJ8PBu/qpGeCyYOfdW6AZl1mG60x5QVU7oX43Z340n1Yu5swdty9uULn+QvJJm1LSA/IXbUKzHnxAqyJHoHdRHt4/H2j/tY/+KbkwTQstXsXjSPr4+u5aGTX7q7s9hf22Yjac0g6kw7q06Iu4E/WP6GDhL4JtTb6Pp0XUMVnvwTnsONaER7OkjlN+Nq7UY14AHj5RE1GRMAWxmDElIkFIsSJqMYIiZZH+izqozG9lyQhgEk93jGql7/WKscSsFzYXkrDyBbnIAkyueTDNW6wOg0V1IS1WYVNTLK3UqOxc+g2QIzPz7fHJai0kkq8nbHKJu1WRShp1kThRL1EXEH2b7aeu4ZPcOfGYekitKbmOEPXOstBdpVCyfhHdPHUrCQjLXilMKUvXyYsT4egRNRtEUtk4NUbhegIEcKjf50RP7+OILw4iILC4c5rFP78W3JsVgfg/dE/Zx6p/OwBKz4IiaVHU4cdb189akAfZO7yFRsp8/ewUuS3pZ8Pd+Nua9RvS0GKZkoKHR7+njsTP+xErtDc7a8XncnQFMyaR4ai6KLSMzKjZ5dBsgp9LHpQ8spWl1D317Q+SU21n/G3n058Xq/ecjlt8Lt+zm57U//5f383+dDzXl/KMf/YhbbrmF3bt3YxgG48ePx+VyvXfF/zBSqRQNDQ0sWLDg4x7KcRENg/lrnwfgzi/f9TGPJkuWLP8/k9JMIqpBUjNJaSa6aSKO+DtbJFDETCSy3ypSlyNR67cw1q/gVAR8NhGvRcRlESlwSFkhOUuWLFk+JNdccw2f//znaW5uZu7cuQiCwOrVq7njjjv4+te//nEPL8u/gXBYHxWZAfbujb0/ofkjZHhY5Re/OEBfX5orrihiccVZGesMdz3U3sjwy60UVgiE9iVIp00KCy00N2eWIP/lL10sXOgnP/8DiAaGlvE81kc8B0U7VH/xgw98zNVQcklGDN7zYxhen/E0Voczf00dSi+jttTJ3XfXc+WVO0Yjlbdvj/DNpadyRslC2HY9DHYCAtTdDB1PZCKNLbkw6WdgzYXic0e7XTIGcmwSvXGdBaU2JFGA2AHY/d2M0Ow/EcI7M8/PXgaTf3ko0tleBNP/jLj9BkrbY8QDHhTNjS2QEfv6+9OsWRPEbY+jEiOddiDbJYqVwZH6JbzZnuA3b4fpiISxyQJGQmcwrlMYN1CGkvz29SnsqFjHUKyWYMTOHPkGivb/lv72OP1RKy+v24dWeBHzeI516ky6vU1Ew4sQBGM0T8f+ZB5/GKpBKnGgRYawOzQEdwk4h8BWBEXnYC08ky+Ni/Cl0FZwVvOX3wQZDJ9FV9dcrHkBrvrmQui/C/u+O0BywOQ7AVjbtxGDzPmTMHqQHa0IsXEMtOj0NufhDOYiEkcTRBwWk6I8mcI8iULnt2iMvk7fgMjQvnpMBKLDHvYPdDMQHDMqNNdWWHn69hp+/0Q+67ZFCcVMkmkBiwJlhQ5kycGeTolkxD+S38RAjEUoDYRQtCTPr4CWHguCkEYkSQ59rBPnccYXzqR0zHy6+zVu/PkgybRJKm1gmKCqMBjUcdoFdjSmWb4+yVkLM9G+LZ0HjfsEgsJYcgPQO6hTX6nwmfMythPBdIiBpkp6do7H5olwz8QBOlbsx9ujoPMQPwuP5dHpzyC8+Tx4c+ArP4LCoz3fz1vs5LzFx04C6PdIfGqpjYc3RimUQ5xn38q9+8bDyJzmttQY/lrxJ57uHYKCMs69ZAqW79yBpMVBEJHeehZ62rE6FaxOoHUbTJwI+3dAbhEUHDlN9PWrPPztlcz7/IkzMvqRruo0vd6GpIhUnlSOKAqkIpkcV/G2PhYkH0bdbBLet5kZpwhs+Mwu2vxJSgZcnPDQudi7xhB16hS05zP+tTretueyrW0qanuSaEInVhLEnpIp3luGYqbQJIEtOdXkDXdgS1lpYiIht4FuGNgNE1PSSLoTpD1J9haNRGeb0OF1kRuzMu6tSTiGvGDYETBA0Jm2BcQcL6ZkUBOM8ONrk5TuD9FcGscuRDElgT2Lt3LyvYVY42lOf7Ke9nyTcCBKOCdM88xV5LcUIrj7GMhXqRjowhQF9hZLdNp1lHSIsrYKBF1E0CVcXcUYUZkDBUF+dbGD8R0JjK560mkfKU8EU9GwJDUCTc2opgUDO7NWm+wSynn2iy8Rs0cRBNi9cDt1qybTZhXRzCoq9ns5rb+bgTKDAacLXYjx1iSNuu0qmyauZsz2enqqWxFzDdyzbSQqQyj9IsvufpDFv7qYGdOmcM53D1kFJYaTJIJJ/GO8R9wXVs8vxGIxWf2LjaQiaQI1PqpPqaBy4YfLWZDlP48PLDRfffXV3HXXXbjdbmbMmDG6PxaL8ZWvfIX777//Ix3gR8lNN93EOeecQ3l5OX19fdx2222Ew2E+/elPf9xDy5IlS5Z/CeZI1hHVAN3MRCWrhklCy0Qma0Yml4xJJiLZaxWp9MpUeRUCdpFcu0SNXyHPLpFjF8mxidjkj9iHMUuWLFmyjPK9730Pt9vNL37xC77zne8AUFxczK233sr111//MY8uy78Dv1+mvt7Fm28O4XBILFjwPqwzPmIefbSbbdsiANx1Vyuz/noNjqovjB6/7CoXew80Y3fIXHVVMem0yaOPdgMgiu+wmRihszPJSy8NUFBg4eyz846ckDb1jM3FQfTYhx+8khHqcI+D4KbMtncqTLwjE2Fs8ZNKGezYESWnyGDj/gOYmHxy8uRM2WR3xi4kMzDofgEiDZnoZTUIA6uOSNqmaSayLDC98B3Ces9zGZEZMgkKrXkgWjJRzdFG8E48VDZ3Pky/H2nPD3FHk1DxmdHs016vgterEAr5mde/HqXOpL5Q5LzpnxqtftfmEN0xnZRuMJQ0qXDIuNMG9lTGp6DPtgdBsNEVmkpSDdPtnMJq+XOMDd+PJEmUjpvMo6Ey1nIme2ON+NyvMbH4WbZ2XIooyLgUg3Xi+ahyLn6HTlDKx5sjsajgdYZTE7jtgQsYjHj4ynW9TJdugfQwhmBQtqiCrc+WoJj5zFg6KzPYvEWQtwhVNVCUzDXlWE81NT6FtrCGZrcQCeZjpE0sFvAeELC7ZLwnuNndlMJuE6i193H+8At8dp6V1nmf5b5lEn8Z3s5gj4IAlFXEqSg6UuqYOcnGzEk2HnrOzi8fDhFLGISiBpGYSdeAjsvuRFDSGKZBfanA+QNbuKZyF88OTaJHySHHKzIUtuFSgsi+XAo/9TXWiB4mRg32t6kk0yamaRJLmBTmSqTUjC9z3og1iMsh0NGr8aenIwyH9dGU8WfMt7Po9DZcVgtzyyeMjneu/2S+s85HXE3iiFfTEmtg3oCb4YSBQRt6Igkrn88sLwwNwRvPwuVfej+fkCO49EwfZ+5rI7V8Ocgyc04uY8/OzLETT7DhOuUCPqXlwLjFIEnolaWY4TCi359JehnIh8G+zPlaVQ93fQda94Mswxd+AHVT6d7ex8rbN6CnNE6/fjpVhyV8W/2LTbS+lfm89e8dYvZ105hxZTUDTRGie5M4HAYIAlpcp65gPPfYG7G1OxGcUQZqO6nqGoM94cLe5GZgf5AXXnkFnF4sdli89Wz0ov3kNUcwwwkGTR+KqRPRS1kT+hQewiRw0ZevY4oJnH0KCgY9Y/tpmbEbUcshgo4oqsxeWUxFs4+kmoNAJqoXrJimTLctj8pELybQXKnyq59KOBPD3Pkpg/byJDHFgjeah+Tqpqcozdi9dvIHFfoKVcLF/VgTdor2l5HXXsCDP/gLnUVpdEPgjYkWYrY0vpRB0hNBtaWxhzN2G0rCSuOc3ag2Cx35MtZxfSTczYx/czKCbqHpxL2Yvl4m3umkpNOBhoIRysPdnUuiOoaUlhkuCfL2ReuY+fg8Csw2pqjboF8g8EyI733eT1pWEHWBN10zSe0uIHr6Nry5MnnTAjgCNqJGmPG5dQS9Qb785IXM9B7yKe/Z2c9r31tNbFijYl4Rp982j7AexipYsUk2Nt23HTWuYXVZkBSJKZfXf+BzN8t/Lh9YaP7LX/7C7bffjtvtPmJ/IpHgwQcf/I8Wmjs6OrjiiisYGBggLy+P2bNns27dOioqKj7uoWXJkiXLe2KaJiYZYVg3M8KxYYKqm6RGBGTDhLQ+YmshgGGaCAgoUsbeQhEFZEmg3C2T55BGPJIFCpwyhU6JOcU2PNaskJwlS5Ys/07+8Y9/cMYZZ6AoCoIgcMMNN3DDDTcQiWSEvnded2f5/xtVNRkeVrFaJSRJQD3MY/XjQBiJaD2c+noXjzwyCV03URSRcCzBwxtf40BbnPPOzSMwEo17EE0zuPnm/QwNZSIVUynjCHuNcEzCWfE5pPYHM4kMyz7xzw+89LKMuKsOQ/6SjLUGTkzT5Hvfa6ShIUpD7UPYTtHJL9d4072Jy/gp22NDSMkIhYJKwBqAwDzo+CtoI0mkEu1A5rrsrkfCLN+QoKJI5rYv+fF5DrMDEG0Zf2jJBdZ8EEduvWUX2A9F7i3vfJPUrt8zQ+knP28mjP0GWDKTC5GIxuCgyo9+VMNrrw1SVHQNZyxxIMh2EDLXa481RFnZniSSNnAqIicUWLjjpADGBBeb14cZN87BQHknD+xbj0WKoVCKJEmctWg25y3JoUzaSrHya5oTFbyUOoPxOS7S1lZM06QmJ0ShvQyn4mTAXoY3maZIjuFKRvnChDyck37HDbfsZ1sogS+i8vTD65h+xXDmPTc6qT+9B+fMcYjKDiaMz+RLGhhI893vNtLWnuTE2X6+dVMFkwMT+OWcm9kXaqLGMoWTn4a0xcRmEUgkTOwWcDlEcsc20WNdz/4ug790TKTq9VWcyn1857PfQnFV8kbTbiZMCfKjc88cnez4xxsx9rSoLDjBxpwpNk6dbeeZN2LsblIRgGg8c92smeB22Dhjjp2TpsosrfsMntYNiI3VCHvzGQPk+iQWn+jH7xFZtj7Ji28Fyc+R+P7nfbgdArubVfqHDZx2gblTbHzxEg+rtiQZX6WwcLqNG342SFOHhqabDIcNSvIk+kse5zfNqwC4Ur2Yy6svBMAluZngqyPQ8zLj+17FllNOaZGFtJZiS2AxN37Si/C4HZIjqwB8uUd9BFZvSXKgS2XRdDtlhceXfpxf/Sq2c89F8Hi4MDeXsY1pIsEgJ6rfgcFQJsFocgy4apEu+DSseBYkCU46NyMu79gAxRXg9MCerWDome1ta6FuKqvu2UnD7ljG3eP3244Qmnt39o9u9+3OROnnVnn45AMLaXy9gs7btlMeXYNUWMwJS26k7JW1DCkGYcGJPlhFAifowMh9EroJiQTJlIhFNMgflLFKLiaW7GJFt4c4frxdNlIYhEQXMcOJt08j4omgOgxi/jhKNJeKddMJFvdw0qNzmc8L5MQHUOVneEs8k5gWwBQE0DTccoo3JjtY6wuQcCXxBgUuHA5jIPLlv4k8v1ggbtOo3DXMH7/6Mj1VA5y+3MWcJ+YSyokwxrKb0kcuZMiSh2FJERgu4o3ZbShJgTNXxxGAHVU6289eyZgtNQiyA5QIqqLiHHbTX9FLypFgcEwXSXeCngmtaDKU9IIrJnHAXUNCKWBraR4Rq4CWl0BUBCRN5Nz7r8E0JcK2FhzWTHJUTCjsdFGxpxDJW4o8XEKf4Md3QKPo4XI2/fgZtrCFvEQeFsVCyAhRKBfyhPEED3U/xKr4KspXTmLWWwsxt9lJxQw69zbTOHsvr5Q/g0208b0x38PqsRDpzkwoWj3vLydPKqay87k2ZKvEhLPKkC3ZXGj/qbxvoTkcDmdEDtMkEolgsx3yCtZ1nRdffPE/3jfuscce+7iHkCVLlv/jmKaJbmbEYoODovFIMr0RoTilmyQ1E2PEugIORR2LQiZwQRIzwrEoCCiigCSCUxEpccmUuDMJ9opdGTHZMhKpbJdFvNZMVHLW2iJLlixZ/nO44IIL6OnpIS8vD0mS6O7uJj8/Pysw/x9lYCBNT08Kz4houW1bhLlzff/WMXziE0V0d6dHrDMKsduPvqEXRQFRzFxLvDHwBtLSl6gGdgKNoanUeKtYvXqYJ57oxeuV6etLI4/krmlry0Qvm6bJT396gM3r26krM/jyt+8lv+gjiuAWBMg/5ajdsZhOQ0NGNDYsSfS8PpzFDuKahc5YNz/Y+isUPY9Jei/X2D0U9i0DJQckZ0YkNjJjb2rXWL4hI/K1dmu89FaCK0bsAAhth54XMskJBQWm/i5jmxHbD/7ZYPEBsHVwB3f+8u98pWA32ySTEyauI5DzJhSfR3NznJtvbiQW05g61cN//3f16Ot9OE/ui2GTBRJaxr84offRm27g1EmLmD7lYGKtcyh3ldAVjdE2PAERiSvqXeRgwJaf87NgBetN8Lq3MavsRD5V/iPCqSj3bvXRGMxERc8rsbLQ2sm3//4wnng/P13m5umLz+BZJR+jyIYtT6EyXk6v6mUw3E8kBvuTUXJLtlBTVYdIxr7hhRf6OdCaZHdzms27e1ixV2T+TBfzp1VjK6ri3s1xAgUJYkEDQRA4aYad8+fGeGbZ6+ywPk1w2ED3xFBUeG04wKnxKG6nyE2XlTFhdQCXQ8Sj2NEMk2//fYgnn4yRDpv8/okwv/tOLmcucPCT63N4fmWc19Yn2NeqossmwWSYuKMVsaiJK1e9hbg8jXnhNbgn1OFuj2KzClx3iYczFzh4/JUo6oj7Rd+Qzt9ejbJxV4r+YZ2aMgVJEnj2jThel8hXP+GhMDcju8QSmUmj7n6dUNQgzy/xYuM6JtSbWBSBt3o3jArNOV6JmeNeZs6W3yMpKt7OMLYb/siE0iomlFZlOg/cCiufg7xiOPWiI86LNzcn+NlfMhH1L66K88fv5+FyZCYnNM3k7sfDNLarLJlt55xFTuSqqtG6E2ssMNwGDSMR+aEYvHAfTLgYLvoczDsdbI6MmPzakxAJQt1U2LIa2hpBTaF78hhI5mPrjLBun0E6pOMgSk9X4ohxVszKpe3pzaRsASrmHWm1UXNyBaL7Ft68bRWGJhK4c5CvWk7l0dYdCM3VlGyvATL3SId/MkxRwJHvJtC/manqq0iqTufgRCx2kUg8iSbrWA0TzZCRSWMP27GGREx3FEJuNMNGJNdB0a5qchPdBIRMVLOQUihy7KHf4adLqEQKOkmbJtVrx9NdVo4iKszv2M4wcXLoozic4JJnc1CsQZ5d0oJeAJa0g8YqlcZbluFQVVIWnX3jHkQPVuBvrKcsOoxoEanfrbG7BgQT8oMmyoCAnBJZe9VzDFX04u/24xx00XTiHsJ5IUQMrGmBpA2Ke6G4OcC4l07G0ubi+fOGMEt0mietwVYs4TW8zPXMJZU/yAB9xN1hVpZrjHkzDZJKhyOfrtIEdVMM8l7PQexRsIYdIBhM+f5canLDbL1xPeJYkXqlnoga4c/RP5PSUpS/MBnlmXz2JjrJ6y7H7pYQZZG1q7bDlZA0kjzT/wxf+/qNbL5/B4IoMP3qSUd9rx2LZT/eRuf2IQCC7TEWXT/hPWpk+bh430Kzz+cbmc0WGDt27FHHBUHgv//7vz/SwWXJkiXLv5uDQrBhHhR3M7Pjhgm6kYkaNgFGhF9jRCTO1MkIxcbI9kF/45HiI+1nRGKBzP2POCoWgywKyALku2XG+mW8VpFcu0zALuJURBQRFElAFsEmCZl9I57JDkXALmfF4yxZsmT530heXh7r1q3jnHPOwTTN7Hf5/3Hy8y2MGWPnwIEEoigwY4bnvSt9xPh8Cj/8Yc37Li9w5DkrCiKxmMYvftGKpmWESpdLJpnUsdkkTj89E33Z0pJgx6YmrpvzS5xKFHP17eh5NoYiHuwTvoKraslH96RGcDolxo51sm9fjPK2pShTXsBtkfhC/X/Rk+hFMzQ0QaHcCGWEYSOUEZcdYwABcuYA4Lanuaj8bvKtbWwaOgWf+zChr/+NjB2IfUQ4U3ysig3yRt8BKqJWzq0owmeT2NPWS+/OYigA2dQxhvdD20O8scnHz/7gpqcnRXGxla1bw3R0JCkvt7/z6VDqlgjYJVTDBCHIsPEWv9v9Fo3hFr484XOj5U7MOwHygMrDKiclQGC/NtKuIPH33d1sfU6mLXUnqZJcJpXO4RvTzmFinpW/b9pD/uAuumNTGFuQZPCt9aSlxeg5STzuPMadVc1V7d/GEt7KnkgOcvsgn+r4Gd7k2dRMzUwg+HwK4ahBKm2iG9DQqqEKSdbtTqFPAU+BiLNOwN4kEY8Y7NvXjeT5PlNzBniDLvpjFaQNAd0zTFE6CudkvOtvvWeYfa1pmjs0br1HoGauwvaOFF3tGoYOPofIrx8NMXuylf2tGkvmOPjaJ70MDBtMuqYRYc4dYIuzsb+ZZ20u5K6F3PsjaA8MoWlgt4l84eKMUKvn7aBLGsA+XEGe185v/poipRrkaP24GjsozknQ6lzI6xuTNHdq/ObbmfP98xe5+eXDIRw2Aa8rI8W4U7Ug7AJgUs6R9gFj8rfjLe7K9Amo6QSW0ip49QnY/CZUjYf/+gaIIgljJ33a7xCQKZBuoKn9kK97JG7SN6SPCs0vvRVn2bqM4HvPE2HqKi3UlitHnliuWrDkQKwfnt4Hog6rdmf6m7EwU+bJ+zLRzQANb2eE56p6tOEgb+4ZR8ffBcRnlzNYVENNtIGzUo9hs9rh7ypcfA3G0BBjt/yRUr0D0V1Mwdlnj3Zvmia33x/k5ZciSAPlXOLrhv1BTvUZFG/x8fy+GtLomEiZ6H5JRDB0HFaVdIGNnCltjH9lAwImBgK5ahsbtFmo9hT2hI5oykikUAFRNDF0k5A7gSVqQzY0ZMMgJ5HA5mhDUpMouoYqgGgdpFLZC8M5xE0rKdNOEW2MaU+wh+nsFubSRyWzWIZVCCNZQ5hKCqsKzrhAWsslKMrYLN0MBXR68k1M4ozZ18tAfoovf3cRFtsgb162BjlgYktDSoEvPp7mzcpt9NV0kfDE6Kxvw5RVLJpBbrcLJeJBzenBFEymNpjMfGAxeriUtCrjbrTTefUerH6Tjp4YUlQm9LpKJG87inWYibtcDBUYPO2+mIIBiReuWE0qp4eh0m5y5wWofXoGptUgHg/jHHChGTqVD07APM0kMn6Y9uEuNI+BKEq4OnMwBcBhYnEpuArtuAucdFfLhEfe20JrIZ4iFwu+cyLd6W5k5f2tph1siYxuDzRH3qXkB6M10cq9XfciInJtybWU2N53Ctosx+F9C80rVqzANE1OPvlknnzySXJyckaPWSwWKioqKC4u/pcMMkuWLP/7MEdE14Oi7cjeUcH16AoZMfagNcTIrtEoX/MdZQ/+OVzsPbzeO4qOLqcyDxOCj3Ujb3IwUviQGCwgIAqZ/bIkHNovgEUS8VkzQrBdFnAoAi5FxCYL5DskbJKAIh0Skm1y5rgsZmwsFBHsiojHIuC2iFgkAfkY0SpZsmTJkuX/X77whS9w3nnnjQZ1FBYWHresruv/xpFl+TiQZZE77hjLli1hioqsVFU5Pu4hvSdLy05hX6iJfeEmTileSJVnDOGwhq4fuipbvNjPOefk4/XKeDyZ21CfT6G+sAGnEsVuieGXmjmw18tg2MNrT/2Dq79XQWHVYUFOqQHofg4UHxSdc8iO4gMgCAI/+lENa9YEyc2tZfLkC0ePpfU043w17BzYjxkSicfsaMUmcbOG1e1f58RZBeTl1gJQEH6AC+uWEYxqzClZj7fCAlyWacg1NpM8EcCSS3s6xs+2/5b+yBhaBgR+49zApWNrmZE7lWG9m4e2LeS2Ux7HqySIdO3EbLyDoaEf0NGRxG4XKSuzk5PzDiFwhO/N8TM+EKUrqrO+7y+4bTuIY2FvqPG9XwxbIVR9kVMb3+ShWC5bh30E291s6ziAYbuEwP4hlFiMhPPHvNl8HT3JExHlp7hw/DZOLG8nroO3fS9PF17GSUUiAXEPPekJtKdnE9OiuOISr6+p48yxh77TlizN5W9rQzS/GiW/wMVQWsJhE9BMUEcifiumKwwPaoSDkBxqoH8gRJHDwgTJTocrTsyikFtsMvOca6BgHABN7SqhiMnAsE7/MLSv0EikDQwddC1z3e6wwU2/HKR/ODP5ccvnfMyebKOoKEXQlsBEIG0qrBgM0Nwzl33pIno7NCQRLIrIT+4f5txr1nDfxg20dkwnGelC21mOpiWRzDSVUhd1tnauNV5A8ZXRyVgGgoe+s0+caOPR2200DXVz51PNpHrHcO2ir2AdswVFlFlUNO+It2fGwqtpWrWcgt4hXOXjscxYDC174R8PZgp0HoCKWph9Kn3GXahmDwD9+j0smvEjXl4TJ540GV+lUH6YdUZ6xI4nFDFobFe57rZ+vvZJL2cvPCxpoOLNJGtsfB2kezJWMAAH9hwSmvs6D5Uf6GH/pHJepxtfrw/3eqjc+zfCvmpOPXMM1lAzRtRJSYkCbz4PF32O9MaNGP392DxWiA+ibtuGdV7mNdjTohJf8SpXRTbT2Bdgd1M5E42d6PbXKBSgzuFhV2wCGjKiLFBQ7+VEXsAvNjBsE/n92RZKd8bJbxIwEYjpDpBNLIaK20gSx5NJ5oeJYQoImNiHnUQLg1g0g+ouCR/tTEmuYr1xNhbS9FOOMSiRTzs2RGTCCATx0U8xLaiYtJmTCVJAA9OZbz6PrCUJWQRKewQmLZ/IthoLZVvqSLpCrP/sc5iARTMZzNHI741SZtuWEY/7LeytTiGYkDMss68mxdYZmwkXGFhiVjRrGouuEmgtZP4jS3DHRPrLBthw0Qq2jU1S61FwhUUGPRIVnX4+fVs7m/M6+M3ZEkOBFFFbhL6JrVSvmUSLvZDJWxJEQn5iuhVZk7DEBIYaNtNmjXLy9KXoKZ3urTpCQsI8ICMMevE9Vkl8YRdFS5rZV7OHkBKkb2ETVdsnMlYYy4yvjie/1ou32MH5J07myf4n8ck+Liu4jLSR5pamW9gT34Nf9vPTmp9SaD3+tQ9A/RmlbHm8BUEQqF/60SUO/GXbL2lONgPw645fc0fNHUeVMUwDUcjaS75f3vcv86JFiwBoaWmhvLw8G2mRJcu/kIMJ3I4URg9F18IhK4XDxVVzREA9KMByHOH1nXWNd4iwummOlnlnvUz5gwJshsOjds2RwZkISMKR0bu8o/w7Hx0u4B58LAkZW4jDv9aPaEsAmyzitohYR0RgaUSoPZiHRhIFxJGyFhGcFhGHLJBrl5DFERFZBJuUiQzOs0vY5Ezk8MH+ZVHAIQv4rOIRdcTsd2GWLFmyZPknufXWW7n88stpbGzk3HPP5c9//jM+n+/jHtZ/NKpq8Oc/d9HenuTcc/M48UTvxz2kUUzTRNdN5H8iea7DITFv3r8/CeCHRREVvj75yERkHo/MtdeW8thjPRQVWbn88iJychS6u1P87GcH0DSTa64p4cJPzUXZ+yxeh4qAQDiWia6NJhXWvjXABYcLzbu/eyhRnxqEMZ/5UOO12SROPjlw1H6LZOFbNd/hrJvWcV+sm5xz/8bgkMZTW85iZ4+DR59PcvfdGm59J7Q+gIcWPLY4yG44cF8mAaFvKhQuBdmRSSyYu5jGwb30JQboGF5KjFfYGRrD7nUh5hSO48zrl7Bm/wTWyV2cIW9CT8SRiZKbqwAOZs/28eUvl+NyHfvWPccucc0UL/QtpzX+D3rivSyTq6gvuoKhhM4vNoXoj+t8cryLhWWZ1/YI0aRwKZcWLsXa0s+aF3rRwjq6lACblzHOPkzdwr27i/AMPcvezvPwlF/PqWO/REuvxj3PdRDTW6nvb+Xn1+XTnCpATwRQzULQZfT2Xk4pCzE1+i3Y/gZM/hm/3RZma60Nq9+CLyUx17DQO6QzobCDBVM283RkLlZnEVvCSfojBjuNKtKmC68Y52pxDGdP/QF1U334rT56Grv51i+/hc/nY0L9f7FsjUEybSKKYAxCKg3eQgEzClXFCled7eZPz0QxBJWWwCN8Z1s3N3iX8pvPnsTnnp9Fm7ieoDyWVN8MgpKf3PIAPW2Z+5uAT0TTBbYO7mToQDm6YZIkhaGJiKQwDA3Z2M8tZS+QH2lhfvBlHneP5VNnjVggxZoh0ck2w8at236DVqZRN6n2/7F33mF2lGX//0w5c3rb3vtutqQ3UkkgkNB7ExFFFJXyqmDDAuhLEQQRpCmiFGlSpIcSQk3Ppm022bTdbO+n93Nm5vfHCSkkYOKrAv7O57r22pk585SZec7uzHfu53tz4rTrkMT5h7y2jfnjqbp9FVHvAO6cctbvSNHxrpdjQxpJ2UtfpJ8NWx7jjMnT01EyexGpKjFw/0+yGA5oVJcoyLLA4GgKny/BibPNtOxI8Le3wuRlSZhNIo++HDpQaIa0V3jd6VC1AnZvA4MCE/cTw+efBts3QTJBdP4J/Lz2PSJZVlS/hzM3DjFhpYWs7u0YGhqZ96VGlGU7009++SUgCEgVFekHNF0HWUYq3efdnDPcymm9D0FSZYoU4EPjacTCJrZL06kcfpsyqZUudzFi0kKpY5ii+jKmu2JsGYkhGSNMCuexqSHJnA4HHi2PFn0OSZuEMx7CShijEEbQJXxCFt7cEEJKxjiaja3DwQxeYxzLkFDRdY0EZkYoI44FM2FSGClhJ4OUkUsv+XShI+IkjIiKmyFm8CYGEsR1CyHRyBZbNo61xzCt2YwpBoaiEbq35XHR0hBrJscYdCRZ8FIJpngYf9Eo4zqTPHiezFUPZpOtD/LkySkGjUY0WSRhgUJvgvMXQ6iznqIOCUNKp2gwh2idjVVjc3ju4s1YgjtQkjrfWTyKJGiU9CRZuEzikW9E2HxCM2UrG8jbPBaDliQWd6MkdXRNZ/KLM2k5ZRlin5PjNhkZe00Wgc0mahZW8NeVT5NYYSYhivhyhyhZW0W9NI75y48nMT7K1392IcJsmXgwibvUdsBwOi3nNOJaHKNoZHNoM22RNgC8KS8f+D7g3PxzD/k9+IjpX6mlZl4hkkHEWfivewEb1fbZuUTVA61ddkR28MuOXxJWw1xWdBkn5pz4L2v3v5kjfgW8detWuru7mTNnDgD33nsvDz74II2Njdx777243V+cG6IvAnGjmXMe37V3+fPKR8LoAdv2fnbg+t7l/UTLtECpH7D/PnH1Y+X3E1I/sjfYK8LqB7b7aeU/qb/7r3x8v/0tE/Q92dY+SWYU9isv8LEF/ePnZ9+ee5c+iqhlT3TtflG2eycoCnsE2P33FYW9y/u3+dG6yJ7ZRYKwx7YhHZWriGlh1bjHksEkC3vblEhHf3wkvBplMMsibpOIQdxXj1ESMEoCkpgWmRVJQBEF7Eo6QmuvML2/SL1f/4Q9yerS0cPp9k2SgE0R9gq64sf2F/b0LUOGDBkyZPgiU19fT319Pddffz3nnnsuFsvnP4r1s+Tvfx/i5ZeHAGhtDfGXvzThdB464vM/ye7dUa6/fideb4oLLyzgggsKP+sufaacfHIuJ5+ce8C2e+7pYtOm9LTn22/fzX33TYExd0KgldBAGyOt79I+WMDmgamc17SflYCWgmjfvvVI57+mk6kw7LoH4gNQdDZPPlFK/26RWKyQyx74Po2NVqzWtEe1z5ekuztGo3ltOtFgbBAIgykPJBPEBvbVm5OO+hyIDPJA28P4EwG8qRY0aRta4lj0bpWu8CD9+cVUlTp5M3QCJXEPM+07aU+ehSAILFiQxXXXVaMoh/HSou/vlFuLyFacNCpu7JWncnezn03DCQDuXOtnar6B37bexaqhZspsZRSKVzISMXHpeDvxuJkyq5NtgQgpTUMKjSLZBXr1GsSol5howWBKQSiHhkoTyzd1oogJFGc5yqgXv9fIXX1nUaiOEtIKkBJ2pqoKR1f50EI7EcP3gL2e19tPZDSmgg16nSrLv51HovMl5J4/EFbDVGpv8c11d2BtEPEPqwwm7TzS+UtuuniQMWPHgTk9i1rXda666UrC4TB9OROINXWQP7eCMUUGRjZpOKwimqZTlCfjdoj86jtZVBTJLF0TY3nwLTz2NeRaDTzY9hgPzJnI1ok/5qQfbkVMWektVohUrkF1bGDR2KnogXwGDGuZM62M+rJpLM9di7AjD4NqIYGGKOi4LIN81f0Kpb2rQJT5Mg9z7vePwTj3ePCug7Zfgq6xLBgnRRYg0ubbwVBsmELLJ0dymhQLpvwq2nuS3PCAF02roCcyi0blQfpLnLyQHyO263kurv8+I+oDCBjIlb5D2yu7WPPgJiSLiPu6OexOmNl2/Y2M8a/FX1rNDdddgVPOZmlL+jkqx/UJidVkGb57M3S0QXYBZOeh6zr+niCWsiaUmx6BWJR+c5DI9sXgzkFQBQK1flgjYVAE/DsG6fjSudSfkQ3hAMw7FQDDmDHYb7iBZEsLwqTxPCa/zdDuIc7IPYMxoh+p1MDIsI4eEilxa3S3S4R8KutrCvj1lwQk76v84uEouUEX+btb6aofxG/xktSSFG804mutYJtQDYKAT8xHSZmI5o5QlniKSKgSn1rAuln9RG0ao+WDjH1jNjk7aoioTlIYkAxxwqIZlThyMkxCM5HARBQb+eymkA5GycdAkiRGhilmPs+RTw92vABoqkTYX41//RmIqoTNECGV08+w2cVpfx3POP86xm22YQvJeGLZJLO8JM1x1tbJ2AdyeL2mhOquGnYUrSHi8GPxOCjZVs5lT1aTNWLCY5NQkwACRiHM2M4Eg9FptJ3wDgExgRwz8pqUpPBNDdWksn56DN2oE8+KEXVFSJjjOPwaJlXA6V5NT6qR3AE7x/zhdFRE/EYNl6Yw6SdHAfCHlfcQ8Nswd7rQjSrjF1VSNdOGHoWx59ShDmos/dV7jPq9HHXuRMaeOQZP0sMdXXfwnvc93AY3p+acypm5Z6IICgk9/fep1FR6qNF3EFlltn+802HSu26QVfdv4CjhGD48awl6mcplxZcdsM/jA4/jT6W9yh/se5ATsk/IaA+HwRELzT/84Q+59dZ0KHlLSwtXX30111xzDUuXLuXqq6/mL3/5y2HX9ZP3RpEtib2C4sfZP6rzUBxKwDzg8/32+0gY/Eh4VDXQ2Oen+vF9Dqpjv/Y+/tmnsdufJJTQDr3/oY75kLWkb5r1aApd3yNF7lExBUFgj955iJoO/gIIH//k4xsOEcW6b6Pw8V33VnGohj4e7frxPu4VPj/aV9jn7ybsEVA/Elg/KrF/vz+KUJX2iJ8mSUwLnnsiaBVJwCynLQr2ibXC3uWP+vBRWx+1u79wuddDl3Tk6kfriihgNqRF1HTE7n5RuR8TUfeJxcIBYrEifWSVwF4v3/33l8R9dg2KJKQtFYR92z/y9pX27PNRlK1JTouyH/V73zHti741iBlxNkOGDBkyZPg8cv3113/WXfhCEAik9i4nkxrRqIbzcxDU/Oyzg3g8SQAef7yf007Lw2L5BAHn/1NiMe3gZec4cI7DVgrlzjD9y0f4+cUuJk7e76KKMhSclE6yJ8hQcASRZYEtsO0W0OJQ/T+QM2ffZz1/g9EP08s77kBSf4Wup8eYJAmcckoOH37oJ5nUKCw0UlFhhth46H8JnGMh2g3mMjCXQvbsg5re5t9JJBWlxlFJkbmHnpCN3pfiJDvNDElxKhZFYLqTIdN0XpedzG4K8tWTvs7FHOH9urkYIp3YDFawj6FtNMFr7RG6gynKHDKyJLDes4mVg2tpD3aytLuHZKoTh3oVS9rdPFHzFxoMx5NVOQZ3dgUTm7fj7c9mdVUEiyLTFyzEZtCZNiEb2+wHafLdz+Nb3yQpWhiTncebaybw1utZ6JKCND2IIKbICvViFkMIKRUUIwy8TKXrVLZ4kui6Tr5VQtd1pPgO2iJteGMhoqqGJKxgVKjCeOaDJDeIbPJW8vCKS/habhZjKtKHq2ka8Xgc9CQjziosqoo1SyTLLdEgCfh8CX7iep4GyyDmWfMxli9E03QWzjDTsSKHhEvBZEzXldJSiKLARceW8vQbYcLOFmyTnsBpE1HFtWQZ3cSjQ3wIzFCu4OFLzuPD8UG2rxPYsGWE0cEeTpzax3l5x5F6ohVBEpA0FeOujTD3ePA1g54e6w1ijMXJOEhmcs05ZBv3WZLS9xIENqfHUe68Ay5vz2AKbc/XZXHRl3h6VitZe74egiBgFhoole8C0prG2j+/yLKilawqWsOjbzzBwsQFzPGvRdRVSre+gvrztVxZ2YRzyg2EUxKX9N8O13TCnBPhzK8fOLYMCtSN31v3OzeuoGf1AAargUU3zyWrKpcKPZsp9ik0B5tx5ZZztGxHkDYwTCmd0VLGiSIcd9YB1Y7Eo9xnShKeVI3btoJlw4sB2BDawCNj/0DWhEayOtoYLKtEleZRV9ONsqKVh45zEzAEGR9MEnWPkvI7iRkSvFJnwG4opkswUP9IHZGBPDQBdF3CqEVAMtB6yihL3FaKBwfwxEyErGklQE/KCBETFVoLZkIoJEgqCTAkGGN4DW9gAmrcQRQbRjmJ7LYh6Cpxr42N6lxSKFSzAQHQkEhgQiJJFCsb9WMwRRQSgozB2c72+csxDhWhb83DMexASCnIeortjko2TTLSOzVEztKzWbTahjURY9nCHVhiBWiih+KNdUx6YRa+ThdRNYUakKhyvY4cN+NM9vNasI7yiJn+UQuamo2giXRJJoblIUSTB09NCkWChFund+oOGpfMQYgoCLlddE5ZxpaUTv07kzF5bagoCDr4U/kAtC8bZPJTC3ml9lk8ld1MKZjCO6f9lTsSzYyxjOEW2y3sfmCAJxoeZVdlCy/2BLj9Bwt4eJ6fp7Ka0y+SzJW87Xmby4ov48bqG/nA9wF1ljpmOGfgi3tYPPgKbwbfIZAKMMkxiZ+U/wT5n7BIOhxW3N1MYCSELxng2LdO5Ct3nHPQPg55X44Eu2T/zDSUlJZCQ0MRlc+k/SPliK9YR0cHjY2NADz33HOceuqp3Hzzzaxbt46TTjrpiOra6Usix9M3YoeKJj1o+z/BAaLpnsjRjwvQB35+eO0eTn93dSZJRnX88U/20vuHw1Tft5+g7xEj99u2vzJ8cF066IeOuBX0/cRQ/eDtgv7xdjjg4A7n6/VJ5T9eVtyvLXR9nwCtC4j6/uUOfLMg7FdWB6KHvGpfHB/Dwx3rwh4rB0FI+wWL+4Uv7y8qs9/vfWX3LvG/l7uZWG/8P/c7Q4YMGTJkyJDhP83pp+fR3Bygry/O6afnUVDw+bincbn2PV5ZrTKK8l/+Yj82CNEecDSCdHizL7/xjWJuvz2dJPDyy/dEsUU6IbQTnBOpc7dQN2cDuKdBahJsvw0iHZB/IlR9GwpOAV2FDd+C4Pa0KDf1YRA+RdDvfDhttQHQ8cCBQrOWSAvQahQi3cxw3IZJOp/cXDtFRUZyc438/vf1dHbGGDfOln5xYJkOY2+FaBe4pgE6KK5D9qHBVYfNYCWUDJNjNvPziVdy5f1DpBwiOWYL0xBw5SvIYhmXjR8Le6Knj3jkVP8PmIpAV9GLzuJXb6YjKhOqzkBYZUKuwms7HURSGqNxD0mtFIQIcXEZ/sixiCkfD5T9gX7XmXS8OpbOfhu5QKchi/hRBYx16Xyt2sY5k2wIopu1jdUoZ5ahDkUonjeJxfefSakrQUtHhOTTfRTKXsIVMpXGEQRNBIMD3NO5tt5NNKkTTOj8zxQHgiDQ72rC2xFBEGLstKSYOelGxO2n0rq5BfWdMJ2RjfytPUD3wPf56815AEiSxLe/cTwPPXgLReJmLAXp5JWTixWuPctF6p1XMTy/BHzAc5uhvpE/fuDgr68G2d41Bq3gHCLTX+O6E06i3J4ehxcsstHVn2LJ6ACRmI7TBuFUhIHoEKFEFIMos2Z4Az8YfwVNx8FoTZDXrltHRM4hr7qIFxdv5vS4CUULI2e5GJxwFvfeNUoqNJNvNa2gNm+YY7LrsRZ9nd7YKHMLZqBIe4Qjz0rY/SAAumcl63bnERYrmD3RhCQJTKo3Upwn0TukUuK2s2jst3h42ToKXVbOrzpz3zgIBxFkA1q2yqriNQAETSG2Z21kNgKWVBAzMUSDghQc5etVWyHog/Xb0uXf/jtMPxaKKw45zAJ9IXpWpyP3k+EkO5d0Mv0yF6Igcl3ldfTH+3Eb3Mi3GPjDimfxDqYwJ1PEvSE2Pd1G14o+Csbn0nR2Lffv2MCa2DARfZDtnsfINkcpNhYTUkPEDQLKNb9h3R9WsfmVXszuMEfddDodq2ahr78LQVjGrlwjYYMRQQBvh87G8jIGR804HqrBO6iQlwC3OkIIO0Y9ih7VCbhHGMgTGbIbsQ3H8RcNows6Vo+DGb2dNOgbiGIlhoV+m4HikJdcYw8T9HaSuFnPfMbmbsepBACdYmk3uwfzcTBKiCy6qcFEEF3QSOlGlnMyfnIQ0JF1MEVlosVdRAv66PaeyLrhmbiL1zNoKGXZGI1osoDGFXWYOmykZOhsitB+/jqSrjju7QWMeXsGkwb6ULQkTjzk0Uu/rwZVFNhaUETEY8MwbTFFa6fgrd2JqOs0fDiWDSVbybX7yApAQgavTcE9WEzPTRvZHOnHuM3EkDOJMbaK0bwYRZtrUGImSneM4S9ddxF/Q6f27vmENuuUmCfScvJ7PJv/KOF+L4pVZlQb5Xfv3Y/hnSI2nN+KPeTH7/TxlmUVk/7k45Vr3YTVMCE1RJ0lbYfUYG2gwZqetZLcsoW1PzwDS3CEyCKNXcdVkCDBB74PmO+e/4kCb1SN8uzQs8S1OOfknYPL4DrsP5mIsDW8lagWZWtgM6XeHOa75x+wyzeLvomISCAV4MsFXz78uv+FNAea+XXnr0lqSS4vuZyF2Qs/k34cCUcsNCuKQiQSAWDJkiVcfPHFAGRlZREIBD6t6EH87bR8HI7/fBbl/xRHX9JL37BGrvufj2IwqHF+svonAPx6+q9JSp+Pm+j/FAdHVx/IF0dGTqPpOvEEhKMasbhOStWRRAFZBpMioBgEZGmPJ7AsYJDBIAvIUtoSI/0bPrr1tFsEDLKQjuIW9onQhj22F8LHBOiPlnPdErXln/300gwZMmTIkCFDhn+G3FyF++9vRP+E5L6fFRddVEgqpTMykuTss/P+Tz7Nn1dUVae5OYBF24V5189QUwnyymtwzb0bDuNZpaHBxkMPNe3bENoBLT9KC73RnrSIbCmHoaWQtyAdDQrQ/XhaVLaUwtYbwbc+HSXa93dYnUgnLjN/glWJbDtwWVfB35L2oLWUQWhX2k8ZgUpXGxOruoibJ4CkUFhopLjYRHGx6cA6HQ3pn39AnjmXu2bezFbfduqdteRb8jh15nZaW0MAzJ/h4ozZ+0W1+jenhfWsmWDM+Yf17zsuK5R/FQBV04kkB5EEHVOwn97OHVgL3YzWTaHGcQWDpmsxChLDYRFJz6XJMkCdeQhFVHE4YuwIJfdWe0L7KDN+0Ei2WaRwP5/orlAPWY250AheU5DScjvJ9jAMD2CWE2TpQwzsENjxwilkn7+Zzfkl5DvncZRL5v5FZmyyFUncI6rbxnN31gSE6Aq6NYEvITO+oYNfvO0nqikICESGWwlHNZ7b/hbXvfMYWtTOOIuRHQXXUawZOd61gorG8ZxY5UQQBAyp2L5zo+sQj7K13UQwrCEgYhyeSkP7bI627/Pqfn15hJffi9A+cBRBixP5lCXMGe/i1Q0fMuDRgRStKS/6OJ0WzxbWv7CbmNfAc1qc1U+GKRmpplW5gmOsCezHzeeld51s3RmFpIU74z/mviu6QKln+vpmcOdCxX4+4fHRvYvdA0keW9vFrpCbNa1xLjonwXB8lDt+UMPwKOxKJLn7L2OIj9QyIIsscYucfRxpkfiFv4Bs4Pizv8Ofd9lJySmcpXZm1IzBoE5DWrsYy7CO4MwikNR5K5TN+GiQ2o8aFwQwpsd6LBXjt5vvZ2egg0XFx3B+9ZmYXUYUu0IimLY8cJba9/ZbFESKTcUAhEJhnPlGHPkK0egOOl9dg6HXjo0YWz4sYO1Dm4iaYpjOsbCx9K/owxE8hghuWze3rC3B9PqviJ/8NTa/kvZkj3rjLLv5PSzLX+TCoWFcx1Syyy7QGjsLuVykf8TCmAeNJLy9aCmBkSwVLWXF7LMgoGMkjBaPM+HWRahnGhiq7iJlimEMG9EFUKIGXGqAHmrpoxIVA47hAYKKgYDZT9awg/c5Bw8FjBV3oSEBOsN6Ocs4HpkkeXTTwmxGxVw0OUmfVg2azHBVD5sXNpMbSPLD5wY4+a4km6yNrJWLefx/NuCrFXCMhnGqT+MxSXhCVmZvn4Yqymw8bzkxdwhjXMBiGsFt2U59opsOZSoNidXY9CBD2Sk6GU9KSBJyx+ie7Sf7lVLG3b2AUPYw/twAlqx+SrbrFPaLmKIi1UE7Vzm+yW8tz9Hl86OWejGHTNiSNrqOaWG4qRMlaaBk6RucfluS3kaFd6xGiiz1eLKGGSnqI2j1Y+q04x3XxwgjrHuxgwpdQZAFgqqMyZYkJ2IiGydlpjKskpVz8s7hipJ9fv56PE586VIiTz1FMuRHROCU16Osnx9G13WeHXqWO7vvpMHawA2VN2D+2AvNe3ru4X3f+wDsiO44ZCK/T2Lcd+t48zdvoCkao+f2sTG48SCh2S7b+V7Z9w67zn8HTww+QUxL/z17pP+R/06hec6cOVx99dXMnj2b1atX8/TTTwOwfft2SkqOLPNjenr/5+fG8F+NgECuWyIv658Xmo1JOKX9GQAeXvhr4obM1LvPM/oeITkU1UildGIJnVRqn5ezqoHJCPnZEkW5EmUFMgU5Em67hN0qUlks47CKmIwCdouIyy4iy/+935EMGTJkyJAhQ4b/C58nkRnSSea+/e3D85r8onLbbR0sX+5jrOPvnDQhiFERCYXamDR5N4JjzJFX6N8EegrCuyAxAojpdXs9JPcPZBL2RQx/NH1Yjewp2w47fwvjfnPoNqouT0eLqnEo/1raRsOzKl2nMQdM+ZAcBTVKlrGTX33tbd72zKeqLpfjjjs4aeCRkmfOJc+c9qqOpWKceVWM6ZvclOdlM2WKIy2EDi4Gz2oYXQGSAr3PwsT7oOdp8KwA53iouiKdbOVQJIP0tr/BlpCbxprZfGO8nV+93oa3tx19w6vsXOlj4pW/o6p4PNVZ3+Ev295janY5P514NsdbVyP3F4ExH1Jh6pueY+uacTgsucy5rJ763PT57o8M8HLXG2QZ3ZxSupA/bHsEgDMqTsR3yU66XhjEvVlFjep4AnlYTTrP9k+mY62LWGE/UssD5K5ZyTtvZ6PIbo4/dirZWQle6nyNvkQtx5Q1c5EDJpsDjM2dwvtN43i392WCo1ayCsbytTMVvvf+XfQEU+jyVnZsH4vbY+XE2jeZPbKViiEfH478kOoKO0+0H004IPBV61vULpgM5bXMmxpmw/YEgx6VbKdIRZFMUZ5MPKGzbEOMHV1JugZSqAkFIdRE5/PVFGy1kz9QjMHejyFux9/n5N6mh3ijZylDgpcyaT6bw1PRjUGGigZ4MauTBLV8e049Ay8ESLRtQ9ESpLwiuBfCbd+Dge70NTv7m3DMaawcWssTO9/g/OgwU81OWkfH0xFuQtc13m7fwIfL/kxKSzExexzH5H6XO5v9rNkaxyAKjM9V2LQ9kRaaX3siPZaSCQq3vsXdF9/M87tfId+cy5eqz8JYZ4RLToYdm/GsXcktoyW0RcuQtCLunzRIoa8LZp8AOWnP6Ne6l7BiMB0V/dedz3BU3hQq7GUsvGkOO9/qxFlqp+6EykMOR1ueldpFFSx//mXmR57AOOijbCRKyFhBQVBmY+IUxsba6HlRYePpfiTRiJw0celzEYr7hhiSRsgeGMBgPY9kOEkqoRJdvBRXeDvWqI/zX7SwY+b3ifs3ss3nRDQn2VrTSn8oRNbOMuS4QiB/FL16M89PmYdjBOa+4seSCDP9b3OQ0Okf20HzOW+hiSINS6axVXJRoPUS182s4jgMWpKokKRkeCsdWjER7KhINHunMCtnGSoyH3qOJoGZqEFmoDCX1lnL0F5pgpAbDRnVGOLty19B1EVS0SCpHD/JERdm5066FvaiheowaQEShZ2E+iWSEvTW+xG+/hL57fnozh4Mqo6i6jhDSRYNfEBfXiWa34vZ76G7PMCTF3nI2pQkoTrZccJWButEpko6m897h7AcpnPaZgSHF/uzIjPe1omZzEx/x4JF+yP8JoxWqpHQEmhWgfKsLJRUEvdQAjUWwlsSgxW5WIZ78E97mpZjqxhJjjBS2YsuaRhjZpJiEtEuEndFSWxJUbdkOsPjtjGl10/pgMTEnz7IjdVmcg25e19EfETwlltINjeTam+nTJfpygXdYWeyYwrjbONYGVgJwJbwFt7xvsNJOQe6KPTEevYu98Z7D+8P8h5qxldiu05iR7QdAYFpjmlHVP4/RbYh+5DLn2eOWGi+5557uPzyy3n22We5//77KS5OD5TFixdzwgkn/Ms7mCHD5xlN14lEdXxBjWBYQ5IEFAPYLSJ2q0hjlczYWoUsh4hJEch2SRTnyZTkS7gdmZcGGTJkyJAhQ4ZPJhaLYTKZ/vGO/wJuuukmXn31VTZs2ICiKPh8vv9Iuxm+OGiajiDAypXpxEhbe8s4doyGYhAIRGyoSuGRP1wCOCeAaEhbWIgWEKX0sq02bQfR+ae0kJx/wt5EcNR8F/wbYPCNtCWDMR9SwU9uw5gDY65NL6uxPSIzgA7JICCCaEx7PxvcNM47lcaKxn/maD6VuBrna+9fxQ7/LvLNefy+9hbAAb3PQNdjab/nhAcc4yHhYdeuPxPfdQ+KaKAi2oPsGH+Qd+9H9G24ne+1jCcc9yIsX8wDXzmRb5k28sL2vzMgqXRrKqnEIELscZa3ioQSp+DFwOrhLZxYMRu8y2Dkfbq6VX7xl7MJREI0NFTx9fnpKPF4Ks4l711FIBki2+jmvKoz+MvRv0fTNbb5dvKnobthFjTWyrhfP4nBdwyU5Sr0ihH8fQaMgDfuY81LhUSH8glpufiCQ6hjU8RoIiXm8No2A41NS3k3auWpVy+i1ydQUDGRH1xu4GsXHsuAL0n/RhFVkdHldGBXvWuI+YWb0XUH7Vua+bDvFa7dcSw5LgnRNZtb3HP58zl5+HuDCH9bzmlDKu6TamlaWMD4WgXFIPCTu0Zp3ZVE1XRMRgFvQEPXBTzJUT60/JG5SikpTw2CoFNaFuP53a+QGEzh686mN5FHMuRCLOrD3/gkgjXM5pJRrlsxjeF2O91hN1NtXVxpW8LqdX52xdYz22DHEsli2RI/RXlRbu+/l0gqwrdDMmVJE9OtF9PqbSeYDJFV8wrVWhIBgQ2jLbgZQhBNuIokfH0qCU1nxvg9/yey86Gvc+/y+Owmxmc3HTxYasfSZqmhbZUPAFWS2XjspRRWppPQqsPDCFZrOhl8MsW3n1pL6XAA15YC+J/fkFXpYvplrn843mdeOZk12b9Gfc2HEoiDIYVCHEURmBJ7Fj0uUSYoXLc8n9uO9mOIGCnstoIUQFM1ooN+Flw/i01Pt7Hzrd0MRLMZDE5irGk9RjVIljjAumg24aSCmEjQXL0GSZHwF3qwjbiYs3UWry7UiGtJhtwi26YZKV+mo5Agoejk7yritN9+C6NNxBf0E5QN+A1lmKNGUA0ksZCKyvgRsBDETBgLfoRImNVdY+mgiRQKOhKjlcPE7TE6j9mEnNVN033nEkemb/wOYrYIUWcYbcBOXLURLA3w+LkJdpUGCOopJOcoFSM6xEU8JjPmsIbq8DA8zkNOt4aqgDkmcuKj2Th3FtBcMJ1c2UO/KY+tlUF0WWV4+jp21giMVsmIqgkxJFMabmP29hH6hkL88Ryd339FR0rCUW1GhHiCuUvNTHl0GoOLOhiqiCE6DfjJ5cLlKqsL+ohJUY7eLKIZVVJyEn+jTrLChy0hoQ0WkJQSBJtGMeQaUGWVjRe8TbFWiAML8ow8OipmsPpbC5hln8nETxgjydZWAKSyMvKThVjnTWLieedx8Zhp7IzsZGVgJXEtTnu0nQf7HiRPyWOqY+re8mfmncnvun6HispZuWd9QiuHRhIkbq6+meZgMwVKAdWW6iMq/5/iipIrsEt24lr8M7PvOFKO+F6grKyMV1555aDtd95557+kQxkyfF7RdZ1ITCcY1ojEddQ9vh0Wk4DDKjJtrJHZE0w0Vhmor1SwW//7pkpmyJAhQ4YMGf69aJrGTTfdxAMPPMDg4CDbt2+nqqqKX/ziF1RUVHDppZf+W9pNJBKce+65zJw5k4ceeujf0kaGLy4vvzzEQw/1YrfLlJQY2bo1TEtrDSOeS2goHeKki05BNh2eJaKq6rS2hsjKMlBSYgJbDYy/i77mZ3nub+0YpSgNs45m7riL0BF4uvlCdu6MsmBBFjM/csaQjDD9CfCuhR23p7dVfOPwDkYygbUqLV4DlJyftp3oe4G+yADNug1NyOP0IztFB9Pxp3SUsrUa6n8BBjuvd7/Nu30foqPTHxnkrd73sMoWOjqeoTTWR5HiRIwNgq4yIjm5tuWPXC4MY5ZMyIJMxadkdWkbjeH3hdn67CMkIhGuaXmPu375YzZsWI/U3c1pZ85GLbye2aPbGWvMZ6ehlZvDl9AT1GBgMXjXQCrI++uK2ObNojfpZuPyJCduDLJgqpObNt7J+tEWVF1FEiQiqRh6Yi5r3n6f5S//ni5rP/rCcixOAw/fVsTbf3Ay+GoXqiGHgcnbKEPghNIF3NaVR9jjJOU0EPMnMaigakmSxpeIaV082CNwRdlV7OwSickaQvFkeqNG7n06zAsfhhGKvwqmJUjJcqwFIRRDHKdVwWVW8AY04qoZj1/DbhUxGwUisfQ5a3m6jWBfmFyA91qY9J0KFJPIm10f8Gz4FSxZJZR6zuT4GWbeWROjLzxIaPq9eIxhRhvbmBuaTSjg5K3dufRbZCTrLuKtF+MI5+DEgD3PwbDLgCLk0z6o4/H2UuyYQIOvm7OyNxEt6uDGUQ+UJXne04fx3a/ij01C/4OPYFMZvpx3GYqNoOoqQfu1FMytosDjJ2HfhC+aj9ucRZ45l4VluSzf1kfNVIkszcpP5rhoqt5jWfOt6+CFP4PdDad+5VOH54RchTK7TFcwRZ5FYvoen/vQPfcQf+MNBIuFRdf/HPfbfsa2DqJIBswvvwjHngsTZh7216Bu2mlE312GIaUiOCVyqsuI9cgku3tBEBFEgRNKJxJePg8jRnxZbcRCf0fSk6TO/BZ5Ddk0nlFDX/MgakMVsZatJJ3FjL3+TIpKGnn3xA/RdBCRqXtzNt1f3shIeTvZQ43MmjqDNdIy7H1DBHUnRiGMGZ0oNlKmGLKo0tnYSUKKUrC5jJy4B5Pmp91ZhsXnwKDIGLUwlkRo7/E0sAajFCRp0KiPrWcFJxDGRU9JH70zW3EqAxhzRzEQRyRF9/TN2EecSKpExJ6kj0oKhWaCNgG/VcIa9uPulbj0EYWkmMAZVEmadN6dqhMVzIzd7uShy7xk73AzODKL5tQYqj3bGCOtRRA1qnfZMMwKkBJhwibYHVIYtlkJTFzGzx/qxRWNY1gJszcI/M/PREIJF/0xJ0MdU1kerURaW8Q4007eqVyCMSaT6LMz9rEwk/MLyLHbMPfZ8NTl8eSpi9lcniCldXNU1lHo2Toe3YOalUO72k5ci2OXrRxzxTgqcyp5LPIYeWI1x8rH0hvrPSiS+SOMc+cSf+stfHEHLdmnY1Trme2oB6DGUsOVJVdy6+5bcUpOUnqK2ztv56lxT+0tP989n0n2SaT01D8V7WuSTMx2HZzE9fOEU3ZyVelVn3U3jogjFpq7uro+9fOysrJ/ujMZMnzeUFWdQFgjENKIxHRsFgGHVWJcrcyMcSZKC2SqSmTKC2VMxoywnCFDhgwZMmT4v3HjjTfyyCOPcNttt/HNb35z7/Zx48Zx5513/tuE5l/+8pcAPPzww/+W+jN8cdE0nYce6kVVdXy+JJWVZmbNMpBIaLjdU+jXoaahBLqfSttYFJ4OBvsn1nfTTe2sWeNHFAV+/ONKZs1yEdYL+cYtR7Nu3QQAyldY+H1FEK83yeOP9wOwdq2fBx5oPDDxo3sqTN8nOqClYPutaV9n11So+xGIh3jkbboJht4GJXtvYsAOayPfXfFTdF2Htr+SZ8plZv6eqdRaAnY/RNuG7azqmkfDrGOYPt35ySct3AH9L6aXg1th4FUovYBAMogkSqS0FKquYjfYuK7515iCIS5IDqHqKuUV30AtOInvrruf92MpSiSFOYpGxFJLRc7RaV/qQ9hnNFaMJfzyRhLhILJsxtezk6GhIX7/+9+j6zqv97zNyIanUUQwSFHqxU4KTTJXjB8L2ggAMbmA3AKd3qQbRCOaorAskGQB0ObbQZ45l52BDiRBpM9fwY0rtxP4618QMeOdoIFngJhSzlM7VnPlFVdxY10WMVHke2OP5atNVvqGdB5PrKEb0LUYlrwwNYZBNvgDxA1BbMlsiuV8ppaV82rd39CKn6PXW8pD23+Ia7ud/pE4uc4p+FNjKSmNcueCMo4pt2MYbGJg21IWt5eyZmg2UxskFEUgltD5zrnpFyCKTdl7rmSjhCiLDEaGuKftAYTsBIPhnRhT2Vx1zBmMrVH4yYfN4IgiCDprrCJTG6p5+7kq2sOdaGvOQK59Dqs3B0PQiblAp3bcAL2hFLEUmGIlJDonQE4WlFZTOyPGlsn54F8O5bV4FQm1eCI2axYCMNNwDu8bVmNP2SixFRONh7An30GWo+AVOD/RgLLwPI4tmkvOcw/xwKplDKci1M7NRnZfgT88jp8/9wF1zS/zFf8uXIVumL3oExP6AVgVkTuPzaY3mKLQJmGSRTS/n/gbbwCgRyKor7/F1FQpipL2ONfDIXSj+dCJKv0eWLkEtq6H3EI46xtgtnBCzUV03tAAHW3YC6eiR8PEHlhMatdLuM1eVFcpOd/6Bt8qr6VnTT+r7k+wJngVM66cRO68tLaUVeXCnGUiCtjnz2DCTddgyrPz2vdXoasG0HU0oKS1EdOLJjqvW4a5VoDiUb72QjavCgNk9e1m8poI3TSRQkaMWdh8/FraZ29F1zWsWRs5/5UoelKiIbqTd5WLEK1G4t4UOfQQw4YihDCIIRLmOAYSmNDQBFAUDymnl1BNN85EglNfMKNJ6+kVq7F5HPiLRrB7zVhGqhjSa9gyqZWIksCgxbnibwZmbRDxuEN0FAkYBu04BrNZNCiwrrCAtolBegv9RHxm+i5aT0UV/M+rXei6TtQWJ+SKcPYbEqrJyPjtLp5eaGDxDCfThjqxpRJYo+nLU7dTp7Bfp9doJWZPMOAwkyWaKAr14XqrgqzOC4m5o+yY5mCT08PR27by4eV+nv9JLyUuC6PJeoyxLpKpJL2JXr5d/G2+UfQN2uPtXLj7Qqa/G6Rul0z5CUFOLD2RE80n8vLwy/xs+88A+GrBVzkn/xw0nw89FELaY7trveoqlKOP5q3bevEHDdA8wgf3bOGUm9JRy4uyF7E2sHavhYaOflBuBqf8KX+LM3wmHLHQXFFR8aleaKr6RUvPliFDGl3XUTWIxvU9wrKGrqdtMEoLZI6bYWbuJDMT6hQMhs+XH2CGDBkyZMiQ4b+DRx99lD/+8Y8sWLCAb3/723u3jx8/nra2ts+wZwcSj8eJx+N71480KfjnjUhEJRJRyclR/vHOnzOamwM8+GAPFovENdeUH5y07v+IKArY7TI+XzpBXHa2geOOy6alJYSm6bhcBsrUR6D7nXSB4Na0kHsIQqEUa9akrTc0TeeDD7zMmuXC50sRCKjoevoeOxrVCAZTeL37ktKpqk4gkDpQaP44nhXgWXng8h4h+QBkGxSlY5b7IwMYRAOeuDctMu9hNO7Zu6z3PMNgy3MEuhLUapv47W053Pn7aRQW7teX0A6ID6fFb9FEOhX3nvokCwy8xmmxjWxzFfB6XKfKUc4Z5SfydPvf0SU3v+4/DnH5eGrcJ/Kty4sI6iplthKeCouskEt4Ycz3oflrkAzymmUKbWIWcwtmYNCaiKR0jqq7iOtOt/PLrRuxmYzYTAoFBWmvXUEQmJE3lUfMlRAepdCWpCh/Fi+UTuHJP9/Dc+EQBRNP441gBeZiK5Vn2oiNymQ1WCnZ48/c4KqjxbMFgyhTYSslFalB1UE2W4mFAkgGCUWxYjFYGIxEGZ9n5C/nFhNN6eRYJLa2J/jp7z2oSSuuYIQmWxcnCy8z37KFb7ZcwM46EUGQiMVk7KY4Z51wO6KQRNV2cF+ykN53jyYcVDF/MMqsBSdx+ykVVOfo3LrxbnYFdrOw5Bh2K0cTisTJcsBNV2VRkr9P7pj45QbCkQhPGR9HG58gN2ihdkcQffsmKkQzI1mlnD1d5ITZFnwBlZubi4jps9FSOxDWH0P/4NGkUj3pMaIbUFMFFGRlMSrbCE9+DU/2SgSfFSVlYvzAz2icYmHaWBO1ZW4mNTThDnbx0ur1RFJRGmsqEIZzae/WkCW4cE4dVxY/xPXNtzLi7eLSTTEMHaNsypaYYSjnhLAdqs5IH8iad8iJ9pET2Q3r7FDh56KdDawfaqHS3UrCk8P3/ALSh4vh/O988ncFUCSBSte+BPGCxYLgdKL7099RqagIccIE4ls2IMX9CBNnotRPPLii4X649Xuw/sN05vqaJlCMcO63ACgPm2BdGzgGSRQ24u5YSTTPQSxuIe83d0F5LWpK471bV6PGUxAKMLC0lao9QnP/iyuwettxFhUy7WfHEB6K8sRpi+la76fc3IGqiYwmc5B0E6Y+O1nRLESjyIZ1LdQ+V873WjYTjQk0a1OJY0NEQEiYGS3ypWcpCwJ5qSF0zQ0IOAQfZjWAGjKhaQIbmE8t6/DlJmi1T+DYvhakhEKfZCdhTiDqOpNfq+Q7SzbRX6SxfkyAYsObWFou5Li/17Jh0IIjZx1VyXUsvVXlK1eeQ97rAqXhAUptG2ivHCEpa8SNIlFnEFkO0VssEKrsZusYBcOoESEhowK+fA/rpwQYE+tBR6O1SqCuw0DWgERH4QgBbT7R5GyIrcNjXYo9mP7fnJAlDL5sTBYHui2JUVIxSSl0k4gW1qgZsRL1QmmPRmHQxiszinlm7mp0QaU34GGWcxZdsS5sso08JY/mYDPfin2VijUD3NU6n9Qzz2GWZCp3LkMdN4iUn8+ro6/uHSKvjb7GaT2VBG+6CZJJjCecgO2KKxAEAWXiRFRTAILphHfJ2IGa4teLvo435SWQCvCNom987nIzZDiYIxaa169ff8B6Mplk/fr1/Pa3v+Wmmw59Q5Ehw+cVVUtbYYz4NDQNJBGMioDJKDB9rJnZE01MHGNkbI0h8wctQ4YMGTJkyPBvp7e3l5qamoO2a5pGMpk8RInPhltuuWVvFPQXndbWEDfcsItYTOXUU/O47LIjS3D+WXPHHbsJBlMAPPhgDzfckB4/qZTGH//Yw7ZtERYsyOK00/L+YV2JhIYogiwfGDF7/fXVPPlkP06nzNe/XozNJnPbbXXs2hVh6lQHzv4H4aP3DpHOT6zfapUoLTXR3Z0WFOrrrQA0N/uJx9NBHgaDwLx5bubOdRMOq7z/vpfu7hjT5skI+QOoWgWS+Am5TiTLgeuy9VOP9/Gdz/DUrr8jCiJXNX2DyTnjWTeyiUp7OfML09OpY6kYr+x8grzRTpJJOzaDFYk4Xm9yn9A88j5svx3Qwd4AY29N+0gPvpG2zjDlQ9uNOIHrHQYurvgfyvKPxpQY5MKy43m8801a/j6V0mQT24YiPPjAAJde8WUe3nw/Yy0Wri+tJ3/oZUh4WR4Jcn/nI+CeypM7PsCp/QSzmM+cYhPfn38a8Zib/v5tzJ49i/z8/L3H6ja6+Pb8p/EMvU+uCIbcefzh1jtYsWIFOtAizmF8fT6R8G6mVW+naFoOOSVH8+WGdHR6X7ifHFM2JskE6FTnDhMNlRA/9xqUllcYoZa+XC8WyclZWefwyvthptS0kGvfhBafTvPWajzRIGpVAMkuce6ZWXxt7AixRCHjNhSjD3+NiG0HPxw3iwqHxuaoSiQFoqhT5RjEi47TkiBbe5PvLTqblxYH2a2voaegGVGCP61ZAu2TyHaZCcd03lwR4etn7LNz2RLbxq8n38JOrY1yYynXb7+Om56JM4Ec/myXMSfdBOKz0GfrbNiWoDFRRCp0Bt6NEoaExGYvlBVnEc/ehKloO/rIJIoqs6k1GihelGC3KlBZaKBrIEFBlsSVFzipKN4n4lbYy3hgzh0MLHue6m0D6LO3sNk1k8IciaI8GSjioaPvQnvmAcShVyFeyllrO6HOTPgrJ3H7utvYHezm5BqFc9Yn0pXm21C1JLsTW1AFCVWQ2JIVQUuAtCeh35EgGAw4brqJ2CuvIOXlYTrrLARJQq5+Fj0QQB437tAF29ZDJAiqCmoKwiEIpsVqNA3++L8QCQMguncCYHalX4hJWvr/mq7p6KoGPR3gG0FNrIJjUngNZSz90WvomghCL/njc1j/6jCda3y4hUEWFr5Cd7SMZt9REM7CUB1DTWg4ZSfVa+qJJFWWJk5FT8QIJg3oe+KxdQRKNjTgLRtAE1U8yToEfRgAn+BEMbUjh53YEQniYrMwC/+0Drac+wYNP7eRP6gyqJWhxW2kNIVybQs9ZQl+8cMIIJA/HGO62EblphIWbImSlTWClDLQtnsiOyJVmIkRxYhq2EjApWMOwhOLBE56sp5aaStBu8a81QbsowY88WIi7hCGqAmdFPd/dZTJXUYEIcmKJon6jXmc9bcadhUl+NvCXAp2WFlSP5G8gQBBcyvL50Z44zgFpWUcZV0apqSVYx0+HOVhXpnVz7Y8D0WdDRz12nwmm7opd2wlPNeEq89FKDdI0ppgjnMOM5wzeNf7LoIgMM7URODaa1Hb2ynq38XyGoFcexbSgI42OoqUn0+lqXJvgr4KUwWx5xfDnvuY+OuvY/3mNxGU9IusOd9p4L27WpEMIjO/cWBS2UJjIbfX3n7E4znDZ8cRC80TJkw4aNvUqVMpKiriN7/5DWeddWQG3J8lt9xyCz/96U/57ne/y+9+97vPujsZ/o3ouk4yBbGETiyuE4poxBM6kgQ2i8jkeoVjppmpKJIpyZcpzJFx2jNWGBkyZMiQIUOG/yxNTU188MEHlJeXH7D9mWeeYdKkSUdU1w033PAPxeA1a9YwderUT93nUFx77bVcffXVe9cDgQClpaVHXM/ngZdeGiK2J4Lq5ZeHuPjiQkymw0vaHAym6OmJUVlpPuwy/2r2j4UQxX0rb701yuLFaUuE9vYI48fbqagw7/08FlNJJHQcjvQj4RtvjHDffd0oisi111YyefI+ka6mxsIvfnFgoqQxY6yMGbNHyNVPgV33ADoUnvYpfRW45ZZali71kJOjMHeum97eGA8+2Et+vgGnU+KSS4r58pfTSf8UReS++xppGd7Orzb9mjUrY0zKGccNk3+MuJ99hKbp3H13F83NCl+aewInztyN4J4Ork//zrzU+Xq6vK7xes9Sbj/qV0RSEcySeW+QyZqR9byQMHK+U0LxpXh9xywaJlbuFcmBPckF90QvB7dCKkBndBYdo5OYWGrHFX9n764GUabO7ITtvwb/Bi6QLCya+gOuLlAYGVT3Hs/pZSdyWv+fEbQCiLVDPH28g6nEHjsQAU8siVn2Ml7sw755BZfdPpXRWAlHHXUcTU2VBx2vSTZRVLRw73o4nBb/BECKByExCkCdeYirsl7EX3US6wfidIdT9IVVXIoDl+JgXFYjN0/7OcGERiBeTrF9FilNp8OfYqhX5dYHfWhqL3ali7uvepPdsQ00a1fTwgCGVBClOII2W0Ao+hnmSBd3XD+H1r4sygpOoUfbyu9e28nU8U2YTbvRNQsn6ZOJOF/FLHsoLCzgjqc8bBrcTYw41gluJk31YLBEiaageySF0yZSnHeg1HH7pnsZSo4QJMzatSJSxM6PDUnMyy+gWi3BVeCmZTRA4L2LmRKPUtt3IoyU8GGoGoNFYCil0lDl5KkfTOaJXe3kKEHmmQUaC/MYFU7nl+u3gTvCVVPP4cs1aT/a3nA/S/s+oNxWwtGFs3C3d/D8Ow/wkCnKBdveYurlf4C8ugP6KRbtuW5ZeYwU5zP4rWtYpw+ytn0DAI9Uw6yqSykaXQxVAlLeAhZqEZ7btJ5+vYbzDCWIU47n1uxO1iy5hMk54/nR+KuQD2Uh8xHeEXj2j5BMIJ9xCbYrrjjgY7mi4pPLAlSMAYMCBSXp6Ob8EjjhfIZeX8nmxf1MbB/AVWJFlETkkiJk1UVqyxaU2bMxTJyYbkORmHHlZNZftQKLM87EMUNs+OAexBUbmWuz0BqZzmiqgkBbL97dUUQtidPoIaEqbA/VY5KiRIQox0sLWDDtB2Q7slm/bCtvbnyfuD+BqChoBiN6MkVS1tFTMuVrxuLuLETNiuHosvG+PEhNajPF2m4WxZ5njbwINemghB2sMxxPsMbLBbfkUD7QR9QZJJcRNoSOgqQdJyGevUDF4xDQBZGkBLMrN5CMatR29hMJ1tJWbaS/3kdl706OHvoQf/kIv7rBx2CejhyQ6ZDMlDGPybsTbJ27kzXjVHIGZGY+tpBAgQdjEjqPeQ9nQGCbpRSHx8asv1Rj7y9mncOAXxhC0kcYqn4NSVd4vmcOr40ppOvYVThUH4lJG5h//YnYRwoprX+C1y610m0LoYecdLjaqR4ejzV/M38Zs4P+nhxye3MRCmR8E/rpfurXFHTkMcY7n1J3E+d9dR5q+w/xJr00G9rZhcoDU4a5Mfgl5o1JC8XfLf0uVeYqNDROyzkNvfxZkqvSiVjFggIw7HsRUz4tl4v/Ov/TxxkQDydJxTWsWZ8ysyXDZ84/lRj4UNTV1bFmzZp/VXX/dtasWcMf//hHxo8f/1l35VOJy2a+/I2WvcsZDg9d14nGdcLRdMSypqVn8ZiMAmajwJRGI5XFMuNqFMbVKtSVZyKWM2TIkCFDhgyfPddffz1f+cpX6O3tRdM0nn/+ebZt28ajjz56yITcn8aVV17JBRdc8Kn7VPwjAeETMBqNGI3/HQ96RUX7jiM7W8F4mHk3hobiXH31dvz+JMXFJu64ow6r9V/2eHXY/PCHFTz4YC9Wq8Q3v7kvGjuR2CN86jrEeom3fQjZi8A+ho0bg9x4YzuxmMpFFxVx/vkFPPJIH1pslFg4yhOPppg8ecrhdyJ/YVrU1VJgLvzUXZ1OA2eeuS/SVtPSvwVBwGyWMBgOPv/LRpYRS6WjoNePtNC2cydZcTfZY7KIxXQ2bQry9tuj6LrOXc8dhb3hQuaOc6cLJ4MQbANLOZgOjOous5XQ5tuRXramz51FPjAqOseYjV8w8UfbZPQGnZ+f/RVmlFd97KAmpqOaAaxVtO2UuPan20ilNLJzDHznOgdjDLm4ksPgHA/GAvBvSO+vRnAHNnDN9y7gnnu6MRgEvvOdUtIxl/sl/3NOBsXFfPsgryuD9CWjjHM3Yo5kcS4/5sMt9Yz294NFYdUqaG+PUl39sQjv/UhpOgVHn8s7mzvJkRPcelwxu7UozvBmLspdy93Lz+Fvz/Wz252ivtKAKn8Di/0u7EaRC6vPBsCuiNiV9PWSRQFbTOPhxV6iUQ2jIUYgbKKlt4i7eo8hRhSxMU6WtpuysmaiwkzIOhuyZmADjsqGzZ6tXHzHcjydpTz18jc5Z6ZIV2c10VA+Z5y+mlxHEMF5DN++NURcz0ExW9EiTlxGlblZZ/KMYETVVKJxjYqifS9+wskwnriXLD2P3vVTiGycgjmqsMVbgEuPkEoUUW93U2dYjk32I/Vt41dT2vnrqgsZSZgZlMsIR3W6B1L8ff1mdgvd7KabLnM3DzXdRR51PDrvPuJqHLuSjgAfjA1y0qrT8Ks+CvVSbtRuYMPO5/lNUTc68IbDx5LhHeRXHCg0M3sRSBLbetbyM9N64rv+AKS9aQUEBElGnHMumK8ALU5CEKkxPcQ8i4tFuedxYdl5LB9czYcbXgBgxeAalg2uYl7hpyQ8e/Ie2NKcXvYMwc/v++R9P0LX973lKq2G798G7VugdjyUVqE9/QBLf7GLeFLC48yjMrEWuSmLplMupNsc572B5dQ5qjl+v2fwmgXl1FxuhLatAIz0tuByadhNEWq1jcSVWiZecxydPcvwd3bSGy2mP15ESldI6TIhyciujQH6j19N+fRc/N1+gkEJUZeRkyrWWoHXTnmFYfsAhVtqmPLUCThHsnHaTfRk7QCPgzl6B5oqIqVE5igvgCmbIeMYSquc2F6YjqM3TMS1lXC2H5PPgT/fi73LRQcNjAhFqNERkpY4Uc1KhzKbvshEus1hAhZQPQ6q3jQxIfEEhcJu3psfR5BUQiaJoSIQu1Q2n/MKf9zqYrDMQHYgxfS2OMWDS/lQnEJbdQ51/TYqR4K0i4WM+WAcUkLG2VtAX6WXaPYoknk1AZtKaa9K00g/w5YGshMeFC2OIOg0xFqI5+5Gs2q8UygTCBhRVAHZpJI31c0DeRsYjWv01oeJ21QMESvGgTjFK4LoGyZRHh6lwfAnRl5/jKIJ2QwkBtAEnZWzbLTXyewaM4P5UtqH3iSZODf/3H1D5sILEex2NI8H0ymnHLH+0r1uhDdv2kgqoTL5giqmffng2V//Srpj3XTGOplgm4Bd/uS8AxkO5ojvhD7uv6brOv39/dxwww3U1tb+yzr27yQUCvHlL3+ZBx98kBtvvPGz7s6nIwgEzDmfdS8+9+i6TiSm4w+lI5XDUR27VcBiEpnWZGTGeBNVxTKlBTI1pYaMx3KGDBkyZMiQ4XPJqaeeytNPP83NN9+MIAhcd911TJ48mZdffpnjjz/+iOrKyckhJydzH/mP+PKXCzEaRUZHk5x+et5hP/yuWuXH709PA+7tjdHaGv70BHH/JiZOdHDvvY6Dti9alM369QG2r9/CsVOXMcaxBbYuhymP8Nxzg3ujuJ98sp/zzssn2zxI33A34aiBsSXbIdUA8qGFypaWINu2hTnqKBelpXs8oY25h9fh4feg889gcELdjyktLebLXy5k8eIRqqosnHLKwfVU2vdF+EteieU/XIcaktjkUegqLqW+3oqq6rS1hQmHVX7/+y4mT7ZjNcZh0/chPgiSCcb+BqwVe+v6+aRreHHz7zCFd3KG8+BzCNDgruPqcd9h7cgGJmdPYEbx2IN3yj8+ffzxYciexYZnA6RSaQV9dfsOOt5cgqM8yncbvs1x5SdDKgwGByT3PFtbKhhbaeeBBxr31anrUPUd6H4SDC6ovAzMhbh1nZtjI6z3tDIpazy9A4MUtwsESuO8vUwnEY7jsom43YaD+7kfj28J8Wa4gOyv3k6uReKc43LSpgIjEkMjE9k8aOdHtd9DUEK8FPoKAznHctv0exiTZTogmvwjBgbifO97bQz5dXYEzTQ0OinLTWJ1xUn12BEkO7n2IGaLj+IcK2dWnMzOriSbdiQYX6tQU2ZgV7CD4GD6+gcjVp54vpYJNWmBpzc2hzNOd3D2NYOkUiJqykhKUhlXDw/MuZ3X1vaxQ1tGNFyLI57Fjs4UYyqMhJIhvr/y54SSYfoiAxQMX4zF4GLEEyeedJBrC2LOUZg1xc4Pxr+HJOogSeSKMb5f/B5Ou8S9iSqCEQ23Q+KV5i4qp4AowFB0mISaQJEUBM3APY+F2bxziNkTjYSmPcaA2gdAh7CdVv9W3pH6SUkCkqoxbNQZLS/no1cuuq6T0BIYJSPMOI4P2voZ3rEMb8iHRTYzv3AOgWSQk0uPp8Cyp5Rk4vmBp3jN8xrI8JzvaU4tOhHLxwLUPr5+EJHQvuVo+ICPUgmV7YvbQYe6k6qQfYNw/w3gGSK54ALeXVPCcNsoVceWMeM7Z+wtp635gESylKSWpD2Yy2vzTmD4q91cJm/h4XXPklATvM7bmGUTcwpm7Gvwsp/DqqVgtqK/+kO0yG5GJmjoDhPn/fZniCYTZ909lzU3jLLimRHeHl6IJGokdAVdhYRfJe4JERqOEuiPoCckJjlbybcO0XNJNfapOoGNBgbG7sJT0UtuVwm+vCE2TVlO4foyOra6GPTPAlWhSd7I+NIBksMjVHT/jdDoRDr0cQxrAoY+gZAziMVvRbIOowk6dW/MJnnuSxSENb7xmMTOYmhHZ9miVgq31GD1xrGO2NHV9Jgu7BWRUynKBzQKhwR6fRZshn5aZgTw5Al8/wkNSzJBzB2n3rCWlyaeQ17fadiNj2LxS0iqTm44glUbIavLSfWYybSaltLQF+EHD4HZvx3HDpmXTBb6q1Ty4lFCMzswOApYXeHmlOunsXHKIJ11Q2QN57HuynfxvG4lFRslKcnEJRVRV7ElEqhBN7oqUx/agdkaBElEV1WCl57Pg/HHaK2Jo6Pz9MDT/Ln/z9gkG43WRn5V9au9Iq0gSZjP2DdGDoekluRd77sYRSOB5y2kEun/Wxue6WDqhdX/tmDBtnAb1+66lpSeIl/J5+66u7F83JopwydyxEKzy+U66GLquk5paSlPPfXUJ5T6fHHFFVdw8sknc9xxx33+heYMh+SjiOVRn0Y4qiEIAiYjuO0SdeUStWUG5kw0MbZG2eN5lSFDhgwZMmTI8MVg0aJFLFq06D/aZldXFx6Ph66uLlRVZcOGDQDU1NRgs9n+o335TyPLIhdc8OlRuIeiutqCIAjouo6iiPsE188JJpOU9mve+QoMbUlvTIXRkhFycvaJkHl5CoIgcNaCfpYuNSMKsKPThHdwCHdxxUH1trQE+dnPdqLrOs8+O8R99zWQlfXpouZedA123Q1aAhIe6HoUxlzLBRcUfuo1WFRyLAZRpifcj/EpM3E1xe7BKMJQCAqLaWsLU11tYcuWMIWFRqJRlZUr/SyY0p0WmQHUGPjWHiA0O1N+Lo6tBUmH7sfBXAQ5R7N7d5QlS0YpKTGxaFE2xxTN5ZiiuZ9+bK6JexcnTNB56qkBVFUnaBygPD8EgsB7w5vSQrNshaZfw/BSMJdC3rEH1pUMQutPIbI7nVyw/ucgSBDahaflp3y/ZxNepRC7o4bfHXUj2anjGRt8kxkTnLy0bTLjJub+w2vSvcfXG2AoopLU0snhyD0Gq01jYckPyJF8hAWdC+yP87JrIdUuM+InCDtbt4aJRFRsBmhwRjh9pouvnn8SJsM0qgfjPLuzDZEIzu5aCocv48OIkUdeHkGSBAwy3PWjHKbnTqa45nl2b67AJBkZs5/VS0G2xKqWOAZRp0gJE5YFciqT3HHCpfSG+7mv75cMlUbQ82woG36CP5SOaH9uVTtLn5mE0VZL7czVjJ2awzuvVuDXvEiyyLDaxLFjHfzgqy6yxGug6zGwTYUwYEnx9VNOJrTczlsrowAUhuZhlDpIaglOLz8RRUp7zL67NsryjWmj8sXLokyoNuNQ7AQSQURRpMhSQF98mLBBRDRIlFqLaQvvxhy04437uGfLQwxHR5iQ1cRReVMwCDLbArvQdQ2DaODUsoXM3l+Q3UNADYAOw16VRDJCb0GYiVI+X9mpsVrtZfKkM5mWO/lTxwKnfw3+/GtIJfcm8PuI5Xc1s/v9HgAGN/YzmxeQOtqRbGZ2PPA6/fqJJOI6ax9qIbvaRe3CtPWHXFvPlIZdrN6aTSJLxbcobeMTTyVIqIm99feE+4j6YsR8cVzlDgTFCHNPBCC371aGO2/DUApjL70V0WRCCwYZ/dFPGVppwY1I1KTgVZ0Iso7dZUQ2SCRVlUQsBQg0OjYzxbUaWdZo3DDAm7PceN1GtLiKIwqKGiLaohE8Jk6hwcpa7TTsmgGzQaU1MRXnjhfRhThl0ntYxA42qscS8dagCnGkRIxc13ZiliT9xhwULcXd17moi3pJ6X7Gdi3jJwtNjNb0kL+9kqQpxkhlD+v7x1Lu72Te28NousiuIgtl3REePmOE7jIoXF9GwDVA3JBETojISY24ZEbFgNMbJG/bZFYc08VR74ZwBQ3YDe3kuLdi/NDOsoVxxmxSyGt3IScUTKkgMx+dyPrL3qZ5ZpI1R8s4Kpz8/PIhnsrtJ2nygxRhIKeLll0dGLOtxLMTJA1hzGErFtlD1YdN6B/ORpNU4kRQEjHcDQ40xYJnyULmDtRSP6GDLWe+T5w4OyM7yVfyUUSFJZ4lnJl35qePv0/h9q7bWe5fDsAc6+m4SCeIdBRY/q0z0puDzaT09N/IwcQgnbFOGqwN/7b2/ts4YgXunXfeOWBdFEVyc3OpqalBlj//gt5TTz3FunXrvjA2H7Ia5xsf3ADAn+beQEr675iieKSk1LSvcjSejloWAUURcNpEjp1uZWyNgaZqhYljjBiVTLRyhgwZMmTIkOGLyZo1a9A0jaOOOuqA7atWrUKSpH/KT/lwuO6663jkkUf2rn/kB/3OO+8wf/78f0ubX3QaG2386lfVeyKZHfsSw33eKDwDvGsh6Wdz4Bxu/Fo3oVCK2loLlZVmzjknHR05qo6jqngtoBHX3XQNuzC6Vd5914PdLtHSEqK5OYgkpYM+AMLhFN3dscMXmhFAkIE9QpOoHPZhHFt0NAAba7eycfVWFKNAwmICUcRikbj00mI6O2N7+1ZQYARLGcg2SIVAEMHeeGClSS/sb08RHyUSUfnpT3dQbf8QdftuPkydwNxTPiYEfxzfetTAdlZsa0QzFjN3rpvf/nYMHR1RXtQW06GlBYtG9342CZZSKP/qoesbfictMkP62vlb0kJ2z9O0hgbwqimIdhM05bPB08q0nCu55vWTGYwoFI2X2OXrZlR9G7d4DqJw6Ci8U6osrB+M0xF9DZNpNbe3jOGacZdjlIxYzSLzpucQ6JKQFQFbtps5M7PTQvQn0NhoxWqVCYdTZNlFzj7Rhd1qBMqYWPIE22Jv071iEh27qng+6eG3TybRBY2yAokxRVk8sTiIL2Hg+/POw7holEpnESU5Fp5+I4TZJHD+Ihs7OhPkB3ZgTo2i6FGuOibMuLzv8Ietj6CKMexWEc0cJrdigN8+5uTevwVQdQfRVAGhYRXJkOLihQXExlswb5PQsreTSGrceMXRSOYwt7e9STBp5aKac6kdv8+T/CtZKiM+lRGvxpdPmsGEsVOJpKLkmfdF38syDEdHSekpck3ZnOI4D9XVw/bQDs7PP59h7yhF5nwUUaY73EehOY9fb/wdwWQYgyhjEA2YJCMPbnuM1cPrMckmquzlxNU4WUY3I3HPIc/7Gbln8MyWVewe7KWg/yR+u1LiD/kPcN7WMOfhgr5m+AfvSKgdC7f8NR1FP9ANoQDYHBD0M/r3N2E4gZ5TwMBT6wnalsLoAI4Z9cjmfBIeDX37ZhxChOV3GMhrysFZbIev/5imxiU0iDLPVnnwh5qZYp/CGXmnsb5vK5s8rWSbspjgG8vzP34DNa5SNquIeZdVIbzyKB1bUmxaV4JuvBTfmgAbnluDllzFpKlJ4usF/BETkhncDo28hgIKxmZTOSOPTW+3s2ZNC9FkjHCFn6N2hRBlAUGA6No4VY9WUfudHBLvGpC8VkTimMIKBS2n4R5USSpmEmYTosmI7usDTUchiSbIeIVcYljQdIWkLlEd30FZaBVaRGCbrZQlY+O4N43QzAJGKcaSCNDUP0K700vryW/T8M5kRit6GEpYiLz+TcoFL1Pfe5kaW4oPjhnFOpDNnHU5bKmNggZ/m29GCQvUdRfwXvVMmppHcQ0NMOxyUNZch7PqFQqGZETrKEpIQbUaOW51Fr6hUpTYMLIqEBXMOPVBNoyViQkm4pLKxuQGlueqrJo5QFeeSErWUWUVLZIkYU6gSTq6oBHM8aHJBiSDn6LtoxSvbWBg/BSyou8ijMlioOlEQkvj5Cv5hCIjmEYcpArDhLQQgWSAIX2I7wjf+QeDbx8JLYGAgEHc9/+kJdSyd7n3lM0cWzqfWCDBhLMP9qD/VzLeNp6/Df4NDY0sOYtS4xczB8VnxRErw/Pmzft39OM/Qnd3N9/97nd58803MZk+XxEHn4SkqZzc8jAAf5n9C1KfTY6R/yi6rhOK7kvYl0ylhWa3XcRmFpkz0cSkeiNN1Qq1ZYZM0r4MGTJkyJAhw38NV1xxBT/60Y8OEpp7e3u59dZbWbUnkc6/mocffpiHH37431L3fzMTJzqYOPHQlgufNdFUlL/ufIZAIsh59TdTas7myev7CIeDCAJ0dcW48876vftPnVvP0y+kiEViFJa4qam1cf31O2lrC+P1pohGVYqK0tHCIGA2ixQXm6itPczpxEk/7P4zGPPS0cWWEii/5IiPa/z59djyrUQ8MTb4TAx4VE45JZeG3HX8z6KXeae5gDGzTqCpaU8k/rg7wNcMtlqw1x9YmWMsZM0Az0qwVEDecXiHkhSZ1nFqQ3q2bm5wE0QbDu09nQygb/wuwtASBn1u1L4i7lt+LW1t1Vx2WQlVVRZmpa5mad8HOBQ7cwtmHt5BGrP3WxFA2eM3bXBSrZgwCgJxQUIWDZQaKrnmmm20bPLRMRClZGqA4xd24NXeI8kgBdIPD9nExHwjN8yNcs2qtzBKAu/3L8cgyFzW8FWcioPcyZeTmyVDKsTb+tksXeFlQq7CefUfm+GgJcHXTL4li7vuGsOWLWEaGqxpoX8Ptc5KFDmKllCQBZl+TxINFVFU6RlJUJGb4r7X4/gSGsa3Etx2+as01cSQHVdzxQX77Ggmlia52vEHVmkibrGPXz51Ol9r+TnFU1czrPWSk1+MFCon1F9EwJdK25PHdaZNqMMbD6LtrOMJr41EMkmg5GUG3G+R5RB53ddLYDjAe/3pyMndoW4emXfv3nbdDolfXZ51wGHbDAeeh27nK4RKOwkPFFFQH2dG3deZwS17P39DXYogCOQouXhjXi5Y0YWzu5tlZRaWT61lKDqC2+hCFCQkMe1x2+Qew0BkiFxzDnPyD45mBshT8ljQfQfGDVEEBPpRSbo19r7C0dRDljsIXYeHfg0bloPJDFf8Cpo/oMaxi/X9+ejdHZTlDEFeMWgqCclBzf9egeeWN8kdfBlJkQiFd+Npn5sWmg0KzD0JETgPOI99+QL+d+q1DEaHyDK6Wfv7FtR4uo9db2whuvxKLMFuPJG54I0gOZwkehPEsCBK0N4mk7fH9gdBIKepgLOvy0bYshZlcIDlk/tJrCrANmLENmrDk21Ejq/EKERpDU9G/MsYytoL2Zm7hNmmD7EKCTpTk1jqmouYAskhoPo1Yp4wZewgjpHtTCBf3YVFCgMCSQwYgCJ2o9l8pDAwNrGR0vUJNJOBQMJFStYZkZzM3DKE/QWJnf5ZiKqBrKEGvLWjbL94I6OdFSQ3T6b5nBdZVqcghCV2lXnw5YSJ22IkLCYeO7qECmMe33ltNblCN0mDziuFM9leJfPS8XG+/roHg6rz4mwnJ61McezrebTk5rLJWcsY71YsRh8GMUnjZpl3jk/Sk6URUJK8NxVKR+P0FUJ0z8QBUQVdAF3eY5xvg5ieYrTIy4dfW8PZ66fhKYnwuxkxJp7k5rRQOSzt4pUT/sru8m3YGwyYk0b0lI4oikQNUd6Pv89JnPQPh9/bnrf5fffvkQSJH5f/mOnO6QDMcs7iDc8bAMzOm8m0i/69vswfMc42jttrb6c92s5Ux1Rs8n/3zK5/NYclNL/00kuHXeFpp31yluHPmubmZoaGhpgyZV9iC1VVef/997nnnnuIx+NI0v8HSu7nCE3XicV0Rv0a8YQGgkAypWO3iGQ7RYryZBqrDFQUGZgxzkhpgYz0KW/SM2TIkCFDhgwZvshs2bKFyZMPnuY8adIktmzZ8hn0KMMXlT9t+ytv9qRno27xbeeho+86IPL441HIFRVm7ntgAp2dUerrrZhMEm1t+/xag8EUYMRslrjqqjLy8hTq6qxYLIf5/NR+H4ymhTzMpdBw/T91XIIgUH1Mevr0uI82aimSy35LFl5OH6+zeVcPGzb8Mv0SwFyU/oG0ZYcaTftDQzrKuf5naeFbSgciFRXpHDU+fdySLJCXI0Ji+CChORhM8cq99zA9ewUFrigWItgVK1mWEVpa9iUdNMtmTi5b+InHM7jNx4o/bcdgkph7RQOOAgu4p0HRGRAbgJyj04kMAYrORB9cys/zKujMP52xJSehD+UxPOwhaurGlK1RW7WR+Wc8DzSQ1Hs/9VzaFQmjJBBXE7T62hiNe9nsa+N3M27CbXRB3Y9oHUnwu/c9QIJNwwkqnDLTC/cL2tp6A/g3AZBf833yjzk4+ntuwUwkQWKtY5Dlr47hPV8A3TKKYonhyPUxYXoJ7z2XQERDJMx9u3ayWn+feUVBzm/YJ9ZuHzbydPxYhEQ7z4cWslkfR2JLD1EtyqzjbOSasrlvzm+Yv9TPqJZAFCRsFokcu4kCl4XW/iHaAyPkmLLIqm8lz6FgUgRWDK2h3LYvkWYoGUbX9U+cmv/UrudZNdzMxKxxXFx7PsFkiDs330dfRQ859dkIzmp0/ZIDyi8qOZbmtVYee3cnltgMsgYfI0fUOHdblHiDha3OUoLJEBbZjKBDrauKW/O+xMiKF8nNrcaouNIVJZPw0C2wbQN60zReXTCBQHkfybYpKLFC5kwyoZx4KTzsgWgIzr7sU8fAXjzDaZEZIBaFFW+B2cq46gFKckZQMSJhRPOLUFyJ4XvXIzZOYtKUFxltN6GmNLLow11r/YdNiYJIoaUAAHflvhcJ5kgfRksQgHKxhZh3ELMnQnUkxXp9Ll6pkFRIofwHF2Ja2UFMdjF2hkLklhuxjawnZZAwlJRh6S1BSohIcZnBUYVXjeciRX34hHwQYdgziDuxAtHmRVVNVMVbadw4ka4GG1UrDJhSKmbCjFKEQoI6NvKWfgF5ejth3MQxE0NnhGIaA630lAYRwjohmwS6iMAAW/OqKRrW8BftJrdlDgEtn6AripRUGEn62V7agly8nQXdPnqKNbJGzXjMOiFXBDQw+xwoUYVQnodY3gBupZfebIGtdXGUcDfO0Sl8ME7jfyaJCJoKiQQBarh08ywuvPF8lrzWjuGZ5QQcUczDLiq3WHltXoJQpAsxCdO2QsNmmLpB5rETjIiopJQUeiiLwbIACVsMUqArAsmsBF6C5P+vk9fL/04sL0oza1GKDcy+4gRudK4i5YoRNogctz2PE54RWDZPYfUsBV3QD7j2I+oIKxMrqZQraTI07d3+aP+jqKiousrjA4/vFZqvKLmC2a7ZGAQDY22H8Mf/N1JrqaXW8sXIQ/d547CE5jMO07BbEARU9TDfmH0GLFiwgJaWlgO2XXLJJdTX1/PjH/84IzL/m9F1nWBYJ5bQSaZ0ojEdVdOxmkWsZoHGKiPHzTDjdkgU50pMbjAiyxlROUOGDBkyZMjw/w9Go5HBwUGqqqoO2N7f3/+FsKnL8PlhJDa6d3k07kHXdS67rASjUSQcVvnSlwoOKpObq5Cbu8/Owu028NZboxgMIscdl4UkCUyb5uT447OP3B8z4QUgmdLY0tzFnXdt5uyz8zj11Lx/UPBjJAPpH3Mx7NeHaFQnlUyLGpomsnVr+MBo8+A22Hp9OhFf0ZlQ8fV9n0n7hFNBEDjn2+cTXr0GEyPIWePAfrA351tvjdI/kCJkcxCPj2IwCAyFChkIFnPuSS7e6FnKxqHVzHCUcnTlObC/BaIag1gfmIp4+zctBAfT/r8f3t/GST+vhpYfQqwfrFVpj+Y9/GnFlbw41IIswI9sbaS0hbwReRK1XkRYYUaxRsk9ahfpx1oJl3hW+pS1tpLauRPlqKOQCvZd9wp7GWNcNTyx6zkSagK34sQa2U1ow/dwu5ug8tsEEwe+kAgm9hOOUpG9IjMA3lWQdyw9gymefzuMyy5ywQk23u6O8uz2Sgosldz8Q527Nz7CM0u96ILGLV9aRM+wEaM9QjIIUuVqwta1dEbi3L3tdd4bTXFK+UJOKj2emx/yMZh/Ar1qK9vCuaiShKAZSfWOxSz3M6dwBmbJRNZRT7Fr8WR0TeSKi6388uJyXtz+AVfcMkwyZsKT8HJBQTU7U+nvSJGlAH8iyFBshEJLPt+u/9onju9No608vvNZAHb6O6h1VtHi2Up3uJdwKkI0HOWkkgWHzGv1VMsH9FW+TEzu47uVJp7prqIyIrKgZD798XW4FCcxNc60vElcW3cZpv+9nJJIGFgFsgkWnAnrP4TNaRvQwRUv8K72DtvKc7AvWMMNtbfTVGkDwQU/ueuQ/f9E7M70T9CfXi8sg/pCWP9b3GIIjjkJ9ehfkVy9GqmiAkNj2obGOHUG+W1rSEaSyI3jkAvcR9Ssu8pJMpYiGUky4xgL0nAhdIbIskaorYqh2nJJ7GrHEF1Fh/0oyooSNH3ze4y/Mv1CI3TvvcTRQVNp6asmuXk61rCCqssIKRGNJJpRIiG6UaQU5iIrRqdEu1lHFTSMEQVNN1C+ScDRJUBEQlKTiKQQ0AjhQkMghYEutQkVCSPpyOY2ptA3+X22NiU5en0SUdMJm+H9hR663CKvT9lM3kiMMS8kKW02YPeY0ZFZde6HaGFQhQilXUNk9ySI56SwBO3YR22YhopwDOTQO7ENQ0zGNJhHr8vLQ9/oomtylEsfH+S8TesZ87jGA1+3EdISZI/mMHNVBVqlD0NxAYoikW2uJpE9SLe1m5YmDb8pRV4v5HigcTPIERNN2yR++O48hv3TyM5exYraHF75zusggJ7UkHJFSizllBpKaZqTJP7Kblpr4vS4SmkONLOzdieikkQTkxgH40x530ZjZx5VjwxhHDOOn0z6yd5rHdbCXOO7Bo/mQUDgeuf1TFHSQaDZhmw8Kc/e5Y8QBIFJ9klHNpYzfOYc1t2qpmn/7n78R7Db7Ywde+BbEKvVSnZ29kHbM/zf0HSdVApCEQ1/SCOR1FE1cNpE7FaRghyJqmKZpmqF2RNNlOTL2K0ZC4wMGTJkyJAhw//fHH/88Vx77bW8+OKLOJ3pSC+fz8dPf/pTjj/++M+4d/9/sXt3lMHBOBMnOjAav0D3qVoKht7kEoeLHV4jIS3BRTXnIggCdrvMlVeWHVY1iYSG15ukpsaCwSBQX2/lRz86Ml/MREJDVXXMZgnKLoJtN9PX5eOZ1aczOprgwQd7mT3bffgez/7N6QhaLQ65x0Dt1entoowy7sdEtvyeAY+VD7tP4+ffdB5Ytv/FtMgM0Pd3KLkA5EPbfgimHGxz/ggJHxhz0pHPe1i71s+KFX4SCY0VnQvItgwxFCpi8nHHYSk7iYq6t1ia9xS71m3BFu3kQ12jcPRtaqc9kPakTgag5QdpIdlUgBo7L11xrJ9U5zJYtx1SvrSXdbgdfBsgeya6rvPyyDYAUjo8P7Ce3YFbiKVi6MfoXDR7EQNaD4b8GtqHJhMOFHJWxRQSmzYQvO460HWizzyD6777EB1pAf7VDxbz/u5l1DmraQvuZCg6zC8M3eTEaxjq3saa3vcJll3KzKJ5rOqPMyFXYW7JPlF+d3QEhyGHrGQ60RuO8QD84l4PI760huANq7ytxAilvLzavYrnurqJyX/H0iBjlIyMpMZzwhgzz0wM0RsUGdvkBUuEmGamPRRFltroDvdSZa8gEnMgy0bKyyYjmMN0DYfR1SKm1El8pWISp5XW0hvuxzb2feaUvIMw2EmFrwB67iQsDtJ48hv4eoqx5nj41pQrGYxOQ9U0/rTtrwSTQZIrp9K5bjpvjCtk2s+TuFwHj8stvu2EU2FkQWYgOsxr3UuQRQlJkHAYbOjoHFc8P31JUzHaRrupdBTiNNsYtTYTknvQ0fCZA/w2W+Ty3Hkc//oKHi/Zjl5Wi8lootRajCmRhMi+GQWMDKR/m/aN2agaI25IW3rECZJXGEMQ7Icc0/8QxQjfvQWWvwm5RTDnBNhxB5zw0Xe+G8mpIJ2UtkH42xsh3lwZpaZ0Bt+/qghTeBQmHKY1zH6s/VMLBpOMwSTT1W2ibuIkmLUIYdEFGG64EWlwEEXwkZc3xNS8Hph+LBj3XRfj3LnElyxhbXA27/RMJJKyoOkg6unxl0RhJKRQnT2I1jiZvkn9bJjcStfWIirXlFAAdAqNqLqCLaARFwREVAzEMRPGSJgdTCKGFdBRSCd8FNCIiAohUxkbqtvZWCswsU3ENJzLvN4O3i1uZZdZps9RiPf0DeS1NGKPJchnJ3Ubc2liB5XDYXRJ5YynSnlzlsyuXAtzn5lJcSjAsFCC9YV6egrh3Yvf4i/ubPoKB2nYkaSmI4VuVpnfnUN7u0Sn5uXCx8OMG1lK3G3hjZMcrI3OwpU6keLwu3xwYQ+vzdcgniBigCRgjEgIcQPoAj1ZNqL+Imz6UdTZdmHGgqYnIQE5kSzklEw4OoT5nodYcfYAPZYAnugAZmMFocEQPnzUlNdQu6WP2g/92KQsxlrHclbBvciGfS8e+tQ+PFpaTNbRWbWiheH3RbIqbPzonB/xxPATGAQDXyn4yhGPowyfLzJhERn+aXRdR9MhntCJxdORyh/9NkggywJmo0B+tsSUBiMT6hTGVCiMr1NQDJlI5QwZMmTIkCFDho9zxx13cPTRR1NeXr43Id+GDRvIz8/nscce+4x79/8Pq1f7uemmdjRNZ8wYK7fdVocofkHuX3fdjX/XW9hTOg9XHU2q7ntYPkFQ/STa2kLcd183PT1xiosVBEHAaj2y2Z/NzQFuuaWdRCIdSX3KKeNh2pO8t7Wbjf1pYVIQQDwSDX/w9bTIDOmEeRXfAIODdSMbCQETL/0zO9oS3FpmIj//Y8kZjfn7lg3OAyOMD4WogOnAaOvOzij/+7/pcQEwY0Yh7YnvUXZUFtlTs1i16ffstK9gyDNCb3AXkwwiOjASbKc20pn2ifatS4vMALEB5l6U5Jk/eYipLcxb1A7RYYj1sE23YTHnU2oq3HOuBErdTXSOrgegi2ms6u/GahCoskSoMv6JXzrdvKwKLB5J8V7CSWfIy9VtRWn/XUD3+1F7ehAbG3nppZe49+H76JrUhdlipqauEknXQY2y0dOKqquMyhGe2fk3rp1YxLVHTTsgSvelzsU82PYYRj3FpTkNnFh9PrinkEqlbRE/Ysijkcz3szF0I4HwKN4BO6m+RTinvIbBFGS7fxeFAymcuyXMmkjulq9QfZqBJT0fIg9bCPaOR6xv5jeb7sF6dAGx5aeSa8zn5qtKaN2VpHVXnE1tYZ67v4KSc55kXNMY8s25DO56FyEZYeKABZ64m+Ou+ilv932A0b6d6XmTqXPWUO+qI6Wl+F3rA4T6HbQ9MQtRMxMb8NHQMMill+6z0wD4Y9sjvNSxmHkfbKa+a5SOQhfLLRuZnDeZMlsJgWSQYkshR+VNJpQMcfKT19I20odVcPHsGTdRUyYzNAyqkCQuyCxOzWPdxgXc69jM16UBnjUNUzRuAWdXngpGF0w/Bla/k07MN+fEdCfGHwUnfxna1mOqOoFh+3pIRphTMIPc3iGId0LjlAOi/Q+bglI469J96x0RWNwKTiOMrYKBp6FmPJ05k3ns1RAAg6MqYyqqOfPY8UfeHmAwpSWp7PhOxoZegKxs9IAX3Z2L49e/Jv7MU4jSCCarDmoKxk5nIBbGJhuwyQrbe9ysFS9jVOshZoihq2p6uAsCuq5Tyg6yhX42V5p54eJ3GTUMUCgWMlQ9xIvzxzLp5aOQEwYkQSSlKYBOtjzKhNTbJDBiZ5TtTMbGKCpGVCQEQBCShHP8vHusQP2uLzEg9OFtrudozyrMOaMImoDTJxOWFGRdZ7L+AdkE8ZLHV98JoJhtuMQQbfku7rxQIWFKkkpBIF5MoRDEEpLw2gRaZm/BXzCCZkghRPLwuyKIkoDNbGZMvJBb/iYS3jJATAwgp2AgEKZ71IKmqHikIoakc3jh9PU4vAlEfwwZEVtE5qljzYxbUcOIaMXUMhWrA7Jqirj099/G+qe3eLHkSQoqszi5+jieHnqaLH+Sdab1+BwCTsGJLhhoYzdx4mho4IeUPhlf5whCxM/WM2uZW3bgS80yuYxSqZRutRuj10L8t046tWE6Vw9jdtVz9alXH9HY+TR7mwyfLYctNC9dupQrr7ySlStX4nAcmPDC7/cza9Ys7r//fo4++uh/eSf/nbz77rufdRe+EKhqWkCOxtK/40mdRELHYBAwKQJGRSDPLVFeJFOcJ1FXrlBRJJOfld6W+QOQIUOGDBkyZMjwjykuLmbTpk08/vjjbNy4EbPZzCWXXMKXvvQlDIbDjPrM8H9m5UrfXjFx27Ywo6PJAywlPs90tKxnuCsdCWkYWM+kxiMTmWMxlTPO2IDXmySV0rHZJM44I4+LLy46onqefnqAeDwtOP71r/2cckouCAJnn1NEb1+Knp44Z52Vd8io0U/Esp9woWSDZOG5jpd5ePuTAEzNncj103506LKlF6Yjk+Mjaf9j4chtEwcHE3vHBcDEiXZOPjkXSIsePaE+EmqCLKOL0agFiNJktDDFVgDGgn3HIIigayCItFQO8P6lr4F/I+2SzJ+SIn8Ma7wW86DJSa7w7OQkawVrhtdhdtRjF8z4YhLL+heCYQkedTd5Wpx5eVbCYT+z9WZcRS62RvJYHy5GmXY60eeeg3gcsbgYuTIdodra2oqSNFDZXkhf/gjB0iDDyRHuF41caowxomm8a6oAIJAIIggCr3S9wZO7niffnEsomR5jcUHm0YCXE93pKfCyLHDu8Vb+9mYYs1HgSwttOANrad3QhxoBQY6STDVh7jyB0qkbKbUWs2t7EoMkYJAEPF6Ru+uuJrr8YvrWt9GXDDFiXo/VNISgDDP+LI2bpv0MgJ3dKR59OUQ8bqOiIItHXp/J3fXvcceMO1m76uuU9Xqo9atg9pNnzuUPc+4gmAzhUpx7n09lUeZrtV/iVytb0VUFk2zEE9AYDej0Rwa4ecPvGI17uLjmfN7rX05Nn48TO2IEkzqVPUm87cOkclQem38/W33bmZIzgVxzDq+3r6RtpA+AsO7jDx+s4uszTia4uZedgXZCHicpeyf+8c/z1MZTedS/hTOMC9hadxIvdi6myT2GaRdfDad9Fax7kut9xIkXwIkXUAj8KRnCnwhStGIFwoN7bAqmzYevXnPE4/sAIiF4bR1EcmA0BK1dUPASLH0JvnQzkHtE1eneEd7zvcaO3DjHmY6jUk6Pw1nfncKqBzZQuHstWQYHUV+M0eZWmjc+xsSfnEr5pd+E3rXgT0fC/rVFY8kzL6BXGvifq+fQ/EAbyYhKcDiBnkwh6DpICgarjNO/g4m8j1nwUbHbQ9eSKhK7F2IQZayT2om6w/jz/OiyTo1tOtFuD2HHEMNDJcTEbKREmJ22MrzWAPOCD2OImFnNQiKClTypg1jBGlYEshizcxJZyRIMASvJQAmCZTPjdyTwGWT63IWc+fcQ5YkeZDHOKPkY5Qgg4jda2FZkIWFOkpBFkGJU5b7C9G1BVhuNLFngYduC1Qg6hHI9+Ms8hFwWlpxt4NLeGShdIm19H5Ktp1ASkDIIELQzZC0l7tNwCCPMsm9nxg0zef74VjqcUeJ6gpglhWXjifi76zjBt4Ks2GMExFx26ZfS8tYIl1xxBteUX4QgCCweWYwsyATyZQKlOVijXuJOA1q2m/DoALquYxJNeDUvTe9P5d3ysQj/j73zDo+jOt/2PWV71ar3ZlmW3OTeDQZM7z2hQyC0EAgJPRBCDSUhJBBK6KEX04sBG2zce5eLepdWbfvu7Mx8f4yRcWwTki8JvyR7X9deOjtzzszZmSNp5znveV4EKtsrmfVXY8AiWLjfez+blc24gxks0uqG9kX74wccO5sSm3go9BAA1zivodpUzX1N97GgbwEhNcRM70yuLLySIut3W62T4l/PdxaaH3roIS6++OJ9RGYAj8fDj3/8Y373u9/9xwnNKfZG13UCYZ1QRCMa+4b/loAhKJsEfG6RYUUmqspMjCgxk+GVKCuQ8XlSHtcpUqRIkSJFihT/vzgcDi655DsmcErxL2H0aBeffmr4t+bnW0lL+89ZCLqifjxlchOapvPK55W827aLiy4qoOAblgffRltbnP5+BTBEw/R0E9deW/J39yMjY4+AnJm5p+xwyNx4Y9n+mhhE24yXe9S+1hb5p4JoNfyNc48HUWaNf8PQ7rX+jfuNctM0nWhUwFLwA/ri/WRY0xkKpFZjIJq+k/A8dqyLykoH27eHycuzMnOm17AqiTTwyK532dS/jV2BBjKt6fxywk2c7MnDmehEyJgJpt2WBo4yqPq1EdnsHUd96wojetpegj/eRUJ2MF+JEdDiKPF+Hlh5K9M6nuee5g0o9hKao/2oajaKqoN2CFXeHA6Lb+TGe0MEwwmOOziD6h+uYIS9h6yMg2lOS9Jy3SGkD7ipnnESgs0GwIwZM1i2bBkZfg8jfBX4PVEG+4N8ntSoE4fjtXmxSGaqvcM5OHcGISXEE7XPG8+LieBeUfKVnmF7XadzjnUxZXKIjzs/YANuji+rYeH2PlaLPtAlKtQCNGc/o9JGcEb5SfjNNpZuiKEkYdoYCx6XSHsXVHmHo6NTJ7yNgBFBG1EjQ+f58wdt9CpBhKRIe6+DaSPjiOZJeMxuDj3pdrjxbEOglE1Qux55RA1pFi/BRBCrbMUkGuPy5NJjcR9xMLdu6KSrPoDNZeLUU7J4adefaQw2A/Cnbc8wLn0MfYLx3mdJI6AE2R6sJ9G7gR+NOJuTSo4Z6ltFWiEmUUbRkggIDPMUc/aw0Xgtbr5oX8Ira9cQU02YvBqR4Tt4eqQL27h0Xl99F4qm8Fbj+9w98RZG+fb1BycUAIsVTGacJidOkxM2Lt+zf/3S/3+hWVVB04yVAAkLaINDu4qVRs47rpT5y6KUF5o4ZtbfmMzauILuJ68ht2srXrvMwtlPkHX2ZzjMHtx5Tub+eibsSoM/bqNzVwdhIZ2g7mPNs1sonnEE/Ox+WLOI9qiLL+7rRkYDf5y37luLtC6IGleQEXBm2zHbZQpnlWHx2Qi/XIutNYJTGCARV5j8WRnrimQSNoHKrVVsHrcB3aRii7gISn4+ueY5YmKCzLpCzB+cQiAYJi4lOKn/RZJ2FUmNMy3+EZqsgiqRaFA54v1RBLoTmONpaDlxmk6t5pXxK0g4zSTjViYubWd03yARWzqi7kRK87OWoygfWIuPXhRxIgpfoiXBE01Q2RlE1GGMsp5l7TVE0gbRBR1d0lClJL3hGC+OlFgycTMPLhqN3KsR81oQIlHW1Zj4PGcSBU0mChriuDrqGdHyJoODSY7vUfnd1XY2FidwhAQc4+oZEZZJ721DECQ0XaBrfTdf9Gxk56JuzvjTdBzpVuakzWHxwGK2hLcg/PhC/uQ6gbXm7fyx+U9kmvz0ar2IoojJa2Iwrx+x3kSRWER+zr4Tk7quI3+5krHxOJtn6Syf8RnmhT5GF42g+ujCAw6fP4X+RLfaDcBj4ce4ULqQJYNLqIvWEVJDJEmS0BM8NPyhf2iop/jn852/MW3YsIHf/OY3B9x/+OGH88ADD/xTOpViDwnZykXnrRwq/zPQdR1VhbhiWF3EEzoxRUdNGt7KTptIuleiZrKZwhwZr0skP0umIFsiyyfhdYmpCOUUKVKkSJEiRYp/IVu3bqW5uZlEIrHX9uOPP/576tH/FnPm+EhLk2lvjzNzZhqy/J/j0Wwp/yF/fqOUxvowTX3FDA8F6Otr5Pe/HzFUJ5HQeOWVTnp7FU46KYuSEtvQvrIyGyNGOKitDSPLIqedlr3X8VeuHCQQSDJrVtq3eldffnkhbrdMLKZx5pn7Jh4cItIEumoIsIFtsOUm0JNG5O+Y3xki7G76u3vY+f7L2OjEXean+NCbmeYtZ1Tnqzh0hc7Mo/Z5TunsjHPTTTtp74oQKF9G+jErqPQO4+6Jt2DueBuaXwDZCVW/Alflt19bi8hvfjOc3t4EaWkmTJIGW25CDWxmZM8mPtWLUHWVSDLKW40fMGr8z5lQeNC+B/KONV7AIZqZRZ3LSFgymVRwONa8MeT1XE6nmqBTl6mONtIbEFCSEeNaCW5EqYuCtHV09Q0nqGzhL190EAukU2y28NCXs7nsqA6GZRTw1o5nUYILyJZEdsqZ9Pbnc5BjDgCzZ88mr6CQwf4+cofn8bNVv6TCXUZntJvjio/kpyOOwUYHknksgmQlmowiCzKKbkxCHJI3kyJnAQktwRH5RmK2hKKTTOrYbSIP7rif9nAnjYPrkYjxC7vCyPRSWrdPp2aYk6uuugC7zRD3C0bAE7/MNDzBfWHQdY4/2M6z74YQBYFLq85jhfQcJtHERcPPHrqMXeJWbGl2ogMeZF8/115Qg+zanTzRlwXZBcYLYPlnsHUNS5u/5NHCEEqaj1tqfsZon5HU7tDJDvp/nMOOpnTmTLJRVmTBGjKev+MhB+HWco6a+2N6547DLn5ORVMPj2vriI8tRxYk3mp8n5+Nvnyob+Vp+Twx91aeX7GSkWlVXHPMWCRR4ITio6nyDmf7QCPtPQqaDpHRLcwTYaDhFRKqQpYtA13XaQw17ys0z3saPp8HdgdcdjuU7h6zFaOhfttQOZqM0hntJt+ei1n6RjS0rhvJBE1mGFFz4MHu8sDJP4JPXoXCcoiGDZ9obzqMncapaU5Ones8cPtv8tVHKOF+snYnvUyYmomVvI3jkPP21Bk2Em74A02/fp+6JjeaYMKWttveJj0LDj8VtvZhEj9C0TTQdPQlYTx5dro29ZBMxEhGVRxpdgoL4zS/uYjWYDalghUQUQQrsiNIjpxOtquc3sIexOUSrt40BFUgGuklaUuix3Xsni04k6UE1eGYFRvhZCZpsRCiCgHZi1cPIMoiFtGFtGsYFlnFGQ0gtirU5XURzvQS0cw4HE1M2yVi1TSs1gTdmVY+yK/B25xPR9JMOG89zr5mZj99JuG0ANGaebx+ZjdHLPTiaUinfVQDuqQhJmTQRDRRQzepCJqIsl3jnsxWTphTgLe0H79L4aNRCZRaCfP6HpyxOB65HUWIYI5paLqE1NtPhhPyeiCYW0eELKKeKGFHkN6BHMSwQsXgArzbbPRvKeLp0o9YPLCYkugwfrzwl6TneMj+YTnHmkbwkv4qNXINTbYmfHYfVrMV+ZhOJi3biE/xMvVHh+4zDCJPPUXsnXcA+JPchf+ibDhHQLA14vSdeMDhYxb2jF8zZlyyMWmnYayYMQkmYlrsu43FFP8WvrPQ3NXV9a3L9WRZpqen55/SqRR70AWRbveBZ3f220bXUZIYVhdxnWhMI6GAKBhWTZquI4pGdLLVIpCXJZGXKVNeKJObITO82MTkUZaUmJwiRYoUKVKkSPFvpr6+npNOOolNmzYh7PaYBIa+l6mq+n1273+Kmho3NTXfdy/+Nq2tMZ5/vh2rVeSCC/I56aRsYrEp3HdfAz6fIeSFQnuPmxdf7OCtt7oAWLs2wHPPjRryoBYEgU8+mcDHH/spKbFRU7NnReubb3bx7LNtACxc2Mddd1UcsF9B0Y/lkMUUWjPIzjaWNCcSGj09CbKzzYZ43zYPmp42GhScCbrCYFDkq40l5KaHGT+sBZzlQ8dc9vYrZETbiALxbZ9SMOkMjtNbaRM8tHdHKe7aTmdJjJzcPQE6H37op6cnQV+8n6aVTuyT7WxnF59uWsdXD9ahqDO45PgtDHe/DiNuMRrF/aBGwb7vc5gkCWRl7RbAQg0Q3EZSU9GSAQqVOj6OiXjNHjRdY41/AxMyar71/o32VfPEzN/yYcunLO5czm1tSdy5R9HV8C79ukyPGsEqmznZYeftcJiJGWPIcJWz8UuR+PpOWqs/xi7WECWLrQkNs13g4wEHelhnmtKGW08QSerkiAM0di2EgjmEExq//KqfBa19yKatnGlawYNjr6S7/UNyMqeTnV5EtPcaAmoImykPa8Yj2GQ3Px9zBa83vEO2LYuzhp1qRNLuZsm6KHc8OYAswYUnOulUuwkmOuiO9eM2SSwUJH5ROUDl9EF2ZBSyov8rJqg6Tkseomk4GVKAjL/cAN3tMKKGUy69jZnjrEiiQEZaDjBj32s3dwW7Po8hClGiNpnznp3NBTWVnH2MG1xeGkxR+jt3YpOtFDVmYOnpRPZv5LA6kbemKFzTtZALJt3LWbuTZZ52+N7C6bnDTqc3FOXVecNJp5g766L88uJZjDp/LoqmsPSLy1Bj/ezo305/fIAxvpEclr9nYuHokSMpbnTRvTNA64ZuSiYYkzbDPcO4a9L1bOjbQr49h4e3PAmAy+QkokfQBgZId2UxNWvi3h84FjVEZjASBS58G0qvN94fezbkl0I8St+oMVy75Dr8sV6KXYXcN/m2PRHoLz5siO5gWHAcc9aBB+ec440XgJKArjbIyAGr7cBt9kdeMT68JHSBuEXEK3nxJfcTBZ1TwKhfn0vi2c3oOow/b+Teh6n2ccK5Y1j6ST3eCifuHToDTQHiYgyTpKCJSXBEaHlwOXnqTjqVGXypncwE4VNsRJlQMwJLdCwmqxn7FTp9Vw0g6iJoIKkm9JiOnN5M0B6mecrnjPwwQY+QzyphDmVaBhazlQ7nGLKjO8lwDDKQU0N4u4vyxEpCeiZ6QsOxNYI0RYBeiYwBCV+bg4AnwqC9lDcmjcTz8VSUZIBBXwBFzSAadeBMJDBZPSTc0xmYtppXx6n8Qr+W0IibMSkSnq05hNIGkZImkDREBCoaNQoDAt6tJ1NZ9xfyTTGKPg/x+5Nr2TFWICORi9ndSbRXJRm30u01s3FkgrxODUEVcYghypxdvHSNl7ylMeodbRw7fyHDdD+WoInwm3cz/8IeNFVn/uaFxFocjPxqEqIsMOmsYdxYciPPdjzLFGkK5+acy42hG6l+/l3cWgKTbGPHs9eQN2XRXvdP2bJlqOzoCMLYbDDruMRvT2B5tetqHg89DsClzksplou5ouAK5nXPozZSS4m1hEvzL/37xmSKfynfWWjOz89n06ZNDBs2bL/7N27cSG5u7j+tYykOjK7rJHevZNE0Q0xOJHUSCiQSOjogS2C1CNjMAqNGWsjwSmSnS/jcEk67kaAvM02iMEfGaf/PidBIkSJFihQpUqT4b+anP/0ppaWlfPbZZ5SVlbFy5Up6e3u59tprU6sHU+yXu++up6XFiOaKRDTOPTeXV1/txO2W2bUritstc/HF+Xu16e7eEyk/MKCQSGhYrXusI6xWiRNP3DuSGWD9+uBQedOmEJqm75skse0ttO7P+ax7M2/ruWiCSCQZZa7vaH7xix20tEQJhzXmzPFxweQllPq+7tR8kkVXcP2jfbT5HSCYuKbAxiFz9xw6rHjI2F1OqhK67AJNoWWnSDxuQ5BivP9UK7fcsueZNT3dCJayShZEWUW2K4iCyEd/kWlqzAZd4bev1PDYZIfRwP8V7HzAiLLOPQFKf8SitgUke76kJvcgfNmH7OmQJQtkJ5F4Gw7ZTljIxpOMYpdsCILAuPTR33br9lxvycKbje+jaiodkS5CkYn4I5eSFDcRcm3GaSvggngr53uKEExBApWncO4fu0gLbsWvhEmWrCHbLRIekCie1YFkzkIQBHpEG6puTDL0KWHSPEb062dNUdZ299ER6ULEx8ZdCzi793XGWZww8AX9oVHUJtaT1JLY5WZGurZitU1levZkpmdPZkPvZn619j68Zg+nl57I4vpd3H17GaGgCbtV4Pn3Qpx2xfE8s/0JRAGyLSY6BJldBacx4JzKXet/i5qopdAa44GRpdi81yCtCkB3OzoQ2byWxJZNuEZWUhdoxJQowGPe18LTYk+QN2kFTW06vRE7S4UdrP18I5b845k9vIRbZnkYvauQfreNamWAc/wisijhHdXNj00gCgHe2vBrflB+CqKw9zNxpz/Jik0iE+ULWWUODG3f1qAwebRhu3H7+Ou5dsWtOM1OPBY3yzf+ioPDxyFnzwXPaHYt6uCLRzezfXAX4dfDVNzp5PqDrySqRrHLNk4vOwGrZGVJ10rW+Dfglp3ctsCK1NROdrIPT34rjE3f0ymT2Yg0Du62sUj/xu+oIMD4mQAsb/kUf8yw/mkKtrCpbxtTsgwPbTat2NNm08r9C829XfDRK4agfPQPwe4ESYbG7bB1Dcw80tj2XTnuXOweH6YFb2Ie6CJr2HiEmUcP7dYGBxBbdkJBGf2NCkpMxVvkwp6+t6Ct6zqehMJIi0SO10nx9aV89MvVJG0RMEcRFREGe3EGm/DpdQxHolkYTp+pgB7nJEyBCmxOiUB3Av36THwTBkl2JxFaTUiCzCEfH8XSM54ivTfBpB1RAjL4kj306rlsT87EbJJxyCKB6oMZFGQKxvoYnhfA/Vk3iCIR0ceEhXbaRlbRrnYyc4ELT18nYsJEZ9ZkbAkvUlRGFUHQBIJ5TfjqRpIUNZLRJN3BPrZ6WsjNycU3soiiLSUUPzwNa30a/eWdbPzhp6SJaUxb3M0pHw9Q2GPFMfAIJj1Kc4aOloA5XyXp6MqnV7eywTqNpZfaaZ4VYY2pDp+cx/jVHuzdHUzemoE9UciSnF10XhhHF9qZ2xUiV63C7JAJ9/Yb11zT0VQdWTWiiiO9hpfyaOdoHqx4kLZYGy91vYRLdGGJaIiChIJCOLRvEKpl5kwiu3YBcFXsbF4xGxPpFzkv2qfuNymRS7jHe89e245MP5Ij04/87mMwxb+V7yw0H3300dx6660cddRRWK17WzhEo1Fuu+02jj322H96B/8XUZKGeByL6yiRGFdsvA8Egd9X/QJFMqNrIEnGSxQEzCawW0SGFUgU5cqUFZioLjNRmC1TkC0jy6nI5BQpUqRIkSJFiv8Eli1bxoIFC8jMzEQURURRZObMmdxzzz1cddVVrFu37vvuYor/YwwOJofKJfI8TNt2cXBpNp+rxzF+vIvLLitk6lTvXm1OPDGLdeuChMNJTjklG6tVoq0txptvduHxyJx5Zu5ethjvvNPNG290EYupKIqREHzSJPe+InNoFzQ9g6olqYztokYWWCvn0RRqYWntAJ2dcZqaYvT1Keg6tG2bxFPXbDfaOivoF2poi0XBFgWzl83blL2E5oNOO5P5z/Ri15sonXwssiOHzcGT2dKwBqc1xCvLjmb4dG2vLs2d6yMSUWluTiNtHMTyYFr2RF6d7zCE4lgHipQNxacaDbo+MkRmgM4P+EguIbr+JxRoAZpbnsc14SFMeScY+00uGHUvls5P+Lz+Y/yqlZlumdPLTmRc+mg2deXy5NoehnlNXD3Rg1na+3opmsILO1+jMdhMIBHEIdvZ1W+ixV9IQlOQhWGYvXa2esYzXR1AAJJqjEfX3EZcHAZd6ZSun4Zv9E5u+tnB7Ir08EbDDhwmOzePvYZ5TR/yWr2fSinJLlMuJ5oM0dItrMekBckxBbHHk/xQXYs31A5qPnqsDVtoGcMz43Q6nbQmTOwKw6jdmp+u69yz4SHCSgRVU3mn6SO0nXPojtgxJZxEFAlBN1MfbCLPMYxJaT6UZBvDPSM5suRSHqt9Fl1TINZFS0TDP5hGvm05Urph6VE/oNAThz+tixLoupGk3oPL7OTBKb8m1763BUuuPZtSZxHt5joSER1N11CsXby063mOltM4xNzAp2PKCAtmxlnGIdYvZ3hGKQGXn4SugyBSJUT2EZmDYY2f/7aPwZBm2E6aBukJxMlyeJgy2jdUr9JbwZEFh/JJ6wLGqJ0cmdyF2PM59C2BcU8Q6Izij/USUkPErVGW79zFypFr+dO2Z9gVqCfXls2Tsx7i1vG/oDnUiscfQdv2C8AK6CRWrMA0duyejkkSXHknLJgH3gw48gz2R5GjYGhFjCzK5G/bAQtXwuQ5UDkW1n5FV6yHRWaRyI5XOLfijL1XMz9xJ7Q17r4Yg2gnXUzkZ5eh167HXlmAtHE5/PwB2LkZ1KRxzG+2X70IBnth6mFGIkNJgjknYJpzAt9cI59MqCy8ZSEdby8i19PH1En9fNF4LJpkoXVFB1aPheoT9qyaaF/Xzc6PjX41fdVG/sQcTn54Ottv3sAObSuKrlLcLOPsGWCQDBwECAg+CrVaYsFd1O/Ix+1K0tcUQXZZ8YYqGHZsGlte3YqqQvqWdDJWjIGSReiIJGwJhKSOHIsBCkI0iqJJhLUEnopswh0ByufYeS4vwZztr2GPx/hiUhaxtsmUbhrDLkWmv6iVLSesJFa8nWnWmejvSmgJF93Vn+Kv2oRJjuLecAqt6ZvYevBSzL0xLnqri3DsQo4uKGNxuw/NqeMMeJDMIrHMIHPa3Ph0CY8Wx2yKE0uI5PaGSTPDuLiZ7G4ZXUwSdUTY1Beh1RngD6WPkNAS6D0OxIc6kOIRQjmjcPbci+BpxaLYWTTHw+GrBERdJOesS7gwN8bigcXUuNMpah2DPc3C6BOL9xprdzXeRUu8Bb/sp+5ULz/8cwAt4kGae/4+fvm2U05BHjkSPRbDN3Yst6RW0P/X8p2F5ltuuYW33nqL4cOHc+WVV1JZWYkgCGzbto1HHnkEVVW5+eab/5V9/a9C17+2tdAJRjSUpGFtoWo6siRgMQu4HSLlPoGL5j0BgPWuX2HyOLFZBdLcEi67gNkk4HWJ5GRI2QtMJQABAABJREFUKauLFClSpEiRIkWK/3BUVcXpNCLFMjIyaG9vp7KykuLiYrZv3/499y7Fv4qF7YvZ3F/LtKyJTMwct9c+VdX56CM/4bDK0Udn4HLt/Qj3ox8V8Ic/NDMscyfH13yGwyExt7qWtkAxg9Jkpk/37nO+ykoHzz8/ilhMw+02jnfrrXV0dxvRarGYxo9/bNhG9PUpPPVU25CNy4wZXg4/PJ0JE/aNMEVTiEY1WloT6LITXBpmi5nD8+cgCEawUjJpiA9Wq0hAHw4lFxvCbs5RpLe/y8+O+Zg1u0pZ3Hj0PgJ5VraVs2/YO8lZbZOXZ9ddT3NzDEkSuPwwQwgMhZLcfPMu6usjTJ7s4aabyhhUvDy8ZQV/2fUGBx01msEd7SRMIlcct4qFzQ7qE2FOEF1DUdPYi2gY2M5EzYhoTWgJAj2LSf9aaAawF2Mvu4QrC87ksIGdlLqKyLJl0jio8NwWI6q0tXcbpv5POax6IqOL9rR9s+E95jV+YFwXLYldthFIJDGJJhQtiUmUcchZ2L1jIbQaEn4GRRvrFIFDj/+KaHoOPouP8+eoODJGM8Oaxcklx2CRLJglM/mOPK4arGNpIoBZMjPaV42u+pnu+g3nlY9lbbuJScllVLpULLrdSLJIAlGWUAclFIfIi93DsQdeJ93yOVdWnkdWew/OvkHCLhNxLUFICeNzDWC1d2IVM0iXZSZPeYWlPUZE5KBi4s+z3ibLlglAnj2HgcB2HEqCUpNOblc9QkEV1EwndsqPWfjBarYWT2WLpZ627jWUuJzous6qnnUcX3zUXvf+J9UX86zpZQRklu1qJRqFwmwTmfJKHIFsjrdbyUn2UJtzOidWXwRTr8Tp7yTro4MYtPaAoDFz+MX7DOPWriSDIWPCImjbQWDEkzj1HEzpCtl5t8Pq5TTubORt72QsuUeRYd2EI7CTPHuOIVprCVD6GC5vxByvY+WErxgo6EN2amzo3czizmWElDC7Bht4fuerXDXqEkpcRejmOIM+D3p3B0nRRmJ4FY6/7lx+CZxzzb6/e99glK+Km2t+xpb+WiZ3JSl47SVjx8oFcNMjtJUW8NCOZ6kttkPDuxQ585mTN2vPAfq/EY3a103oD39AWbkawgHUUAyvx2lEPH/wIksDJTQUH8rsK46lMEeG+W/Au8/tOd+NfzhgP5uXtdOxohGUBB1+J431YbTAwFCkdrQ/vld9ySTu8z670stPfnoB8/6Uzc7l7bgavHzGKNz0kZQlFCxERCeDxcU4dAvxvgjoOspgFP9WP4lgAiWho4QTEIWx785mMK8Mb+9XILTjt/uIaiWQBATQNY1oT4hoTxjJJLB9bRR78TBuu2ID/e4ouf0yrvhOnFkWkp0O3jh4IaJVwBsapH5LG+WJMkyaxOwPx5O50Eq6ouFOu4db5vaT0ePliKVeqlZJCAUh5qxbR/fgSHrcNvwlAkXOYrqkVqSakRQ2R+jb2cZAchhWZz8tpQPouoxpcJAsxY9fzsSiKkys72RTp8YL3S9hDdqIjgoy8zdzKHh8Ekp3lInbDiLuCOPMshE/tgDfVQ9jEcyILhcnASdlnQTDIXF8Etki0RCrZ7l/EeNc48i15NKn9GENKlz2aCfuHoUtw2cy0HQi5a8P49O2jRx+ozFRoiY1tn9QR2wgyYjjKjGntKv/ar6z0Jydnc3SpUu57LLLuPHGG/fyizviiCN49NFHyc7ed3nV/yK6rlPfakQWdPiTRGIaigIIOgICqqajaWC3CThtIuUFJsaPMFNWaCLNJeFyCORmyBTnyZgTEdj9t/msY1zg2OdfTYoUKVKkSJEiRYr/EkaNGsXGjRspKytjypQp3HfffZjNZp544gnKysq+7+6l+Bewxr+e3276EwCfty/iD9PupdC5x+rimWfaeOedbgBWrRrkgQf2Tlg3Z46Pgw5KQxhIINQaj3dV1Q5umJWHq6wKs3n/Nnlmszi0T1V1enr22Gl0du4pSxKIInxtD15UZGXKFO/+P4y7ijeXTSXfsozWwUOI2k/n6Z9PMGwP0uGGG0qZP7+XlSsHsdkkLvlxIeTtFtYHNyK2PMdB43Rqyls5q2QmudWev3n9pk3z8tZb3Xi9MhOrupk9ahuok1mwYJD6+ghgJDDctCnIwsT9rGn5DCQbmweXcmxuMe8sm8BtT1Xgir9JsERjocnOn4f9ECtJyDmOWaF2djY9Rl6yl7gW53eta7Bqv+W4osPJsKaT7zDsIz1m9x57gm+gJlq4iNvIDLUTXvcs7RYvedmGj29/fGConsfs5lcTrucXyp1s1/voDnnJdvZzxegpxEUbS/POZ5ojE0n2Iq38FWvQOXPONuaklbA9bQ5iuAtTtI8dg3VMzhxPviMXnzWNh6bdxea+bZS4iihw5KFr3ejoHJq3mpNyFGwtg4hiKegamDzokU1Iejc2mweHJYuk4KMt3EFbqJ2dvzmP3EE79ygD/GFaJpvzXfS1mNn+UiF6KMz4igEe+MEylvmC6JEkgmCEQQsYolJfrJ9X6+dxhFnDJ0gcn5aOWfIhWIywdcvBx7AyMYVNA0vYFn6QhN5FKGmi3F1Chbucv8ZnTeNnoy/nZ6MvZ41/PW82vI8kSFwQ6wCSZFrTOcZVyTGjrzAayED9Vqo3jSLk6UOOm7GOmTN0vFgyxufti5BFG3mZI2jvURm01uLwRPA629GAlvXz8b7wAjemnUEba6nPH8CV1kTSU8D26GYyrOlIvqnEGgZ575UNDGSEIKcdS65ASFN5eMuTdEaMeyDqMi3B9qHzC0078LgGCQcCfJVWxhN9FZy5NchZ1d/uYbs/pmRNMMZj7XN7NsZjEBqkd0wNtQlD+C9p76d8/p3gLoZzfwalI+Dos+DNJ0E2wRGnoz39shFBHRxAGxyE3GJYv4SvBsv4Teuh0GHiA6WXx3+ZiauxFiWWZLA1iNgwgL0ngDVzP5NSgMUKSX8/DEYQ7WYy0hNUTC9j56owefouinduIvjGTlynngRAzuhMxp5VRfPSdnJGZ1AyqwBFU1g9/EscNyTJOSiNqKiR0Oz0YicpiiRssKp0CoV5ExlVk45/o5nm1T1E+hPINhl/QxghKSAnkgiCgCVuxddUxIcVM8kSIiy6aAvpKxwUfTYKpyKjBxUEUSSpJ9EUHQYEYpkJBEUgaVYYdAyQ7y/kCs8VfJL4kk3tGUTSBokGFbwvD0PXAV3HQpJQrJSEkEDuDXPu65tZWa3i6ijAORAnW08SagebruGLicTGy+RWZfBzx085Y9wZvPTC3SS1WvxCDlFLFyuPaeDUTzWS6X2M7FpIp62CgewdrHFKWJp8uD+1U73JhVqVpOG+zRQIExFEgfHd08nsSMNybICANcDL4juc6ziXv/6vYbbJ7Izs5Lpd15HUk/Qkesg2ZyMLMmO+7CC7LU6FfTQsGE1nXj56pJcdj6ynpv150q64mI3LFLa8tROAlhUdnPDoXP5RdF2ndV0vklkkb5TvbzdI8W/nOwvNAMXFxXz44Yf09/eza9cudF2noqKCtLS0f1X//u0kkzqdvSqhiEY0rhOKGIn0EopOPKETSxjbevpVkqpRP6lCUtUZCGq0dScJhIy2JpNAWb6JYYUm8rMkrJY9EcgAlSVmxg4343J8i0dy4sC7UqRIkSJFihQpUvx3ccsttxAOhwG48847OfbYY5k1axbp6em8+uqr33PvUvwraA93DpVVTaUz2rWX0FxXF91v+ZuIogBpkyDrUOhbgegZS3rFoYZC/B2QJIEzzsjhlVc6sFolTjopa2ifyy3xwyssLHw/QXGuh1NP/fbgoo9rT2Rw8BjAiJz+prfujBlpzJhhPDvu4++sRoc+S5rXBJl7W2AciKS7B9+lr1I5uIufOruxNDihp5Jqay6XTVvGjp5RLKg7Aa8thNIyH5RBUPrpHUhn3vIJ6KpI+4CN0MIxDL9gPYNKBH/6QRQ48gAY7fOSe8h85m/8DYv6dtAqetix8xUWtC/CgYfZ/ksZmTmMww9PNxIc7qbEY+KsKidfbKnDp/VikcMI6ET6VsJuofmE4qNY5V9PT9TPCcVHUeUdzlWjLuA99yfk2fKRRYHHtz9FSAmTJwkcbnfyk6pz+N2UO1nTu4EKdxmvdSzlnaaPCNQvYlAJUujI49X6eTw6/X581jQyrOloaFyz/BYkQeK6MVfyaVM6S7uWk2FJ44Gae8lM+ME1EpzDENrfRIt+jsXno8x5KkLTM0AQZzRBVnM7eIaRafLy00Q1F+gNxNaNRI9ZqHK7CTfW0x2eT7/Tzji7nQ61hBPLLyPTZsSIt4bbCSsRGiylzBCCiNjQCy6kJWojXddwmEXunuXjoi/XYo3HsQkOkprK6LRqqtKGf+s4mJBRsyfxYvcCqP8jiGYoOnevILmFySzW4meDFGKSw83lWbl87U5+x7oH2di3BR2YMHcyjq5MBuKLqIttJyxkkm5Jo61zG5VItOsCuq4ST7YyEG5GkuzcY63iyqzTeKF5Ads/+xx71wgc8STdGzPRMx8mYbXiMjlRdR0tnAYxN5994SAwWsPtFGH5pwhAuz2d7EATjuggr9bC6ZVOTNI/EAH6yiOw4G1obzISBY6eDAVljBZFDs2fzaKOZZyz1k++lgXxDnjtMbj+ITj4OJh8CMgymC3Yz5YINjZARyOOinxoqYPi4dTFdk8EOVwEIzrdfSquCQfhf/EDkjGFHkslwae2cdANU/bbPe+mTxhp30xXmpVcZwc5d9xBbtkIxtXupO+aF1jwYjGBP6+gdEGSQx45FSE4wNgjMhl7ZtXQMV7/8m66PniNXreNUPFJZOyUURRQBRNWlxXn2GxGH30wMy+sxuY1s+aZzSRV6GuLI7mcBFb0IIhmEJJYbTpur0QiopDvmECj3MicrW0M73kP94w6urovpWVNN0ktiiok0QUVZJX2kU2Y9CAFvVYSbplpT5/J52076UvXmVB8GM3DtuNpzcLXnouugQ5srwmy+uIvEXWVkx8vYs5KLxVrnbw97DDwbEfXWqkVKzAhkqaHKTNPYeyy8wg3KHQdPojfNZKYpCBqSWI2WFtpYkeuRG6vwNjhcxgd2sFAVzkby9KZ8Wk+5y7YgFftIux3Evp0HCUnlbDsSWOV1Akzj+Be280k9AS1g9vpe1nH0m9n5AmFHFI5c+habw1vpSvZhV/144/6MQkmvCYvE/IPZryrDlEQSHdGaB8YILl9Oy61F/W9TwmG+ugv/tHQcQZbg2iqhij9Y7nCFv1xK7XzjaS0k84ZxvjTU5Pw/9f4u4Tmr0lLS2PSpEn/7L7809B1nfZulZ5+lUhMR9ONLzKaBqoGA0GVwZBGPGH4IYciGu09Kv0BlZZOlWjcsLLQdifd0zWjLAoCuydjUVX9G5mZjc2iCBazgCwJ2KwiXb0qD1+fzhHT95NRNUWKFClSpEiRIkWKv+KII44YKpeVlbF161b6+vpIS0tL2aT9lzIrZxrvNX9CR6SLSk8FWz/O5IO6XRxyiI/Zs33Mnetjy5YQuq5z5JHpe7UNBJLY7aIhcAoCq/ovYPWaUxg/3sUU0XjU0zSdDRuCeDwyZWUHfi4566xcjj02A4tFHEoMqGoqv153P2u1jbhPdHHWpFtxOPZ9hNw+sJPWcAeTMsfxox/l84c/NGM2i5x7bt4Bz7ePv3PaREifCf0rwTPWKH8HHqt9lqZoAzXCThpD/dRYRkHfMobZnThG6AzLX8zMY+dQUpDGOZ3pdChx+tQkk8VJPD04ClVJYHZLOD3rAZiYWUO+fe8k9xn2XDILTqRt8AmSmkJ/KIo3KdDyURX1zZ2UuS2s3NJG34xXiWtxLis9jpqBzzhTjXDUzGPZslZFUHRsJjdF+ccNHTfPkctTs36PoimYJTNhJUyxs4D7J/+KBR2L+dPWZ2gMtiCqIbIljTVxCzQ9R7a9hKMLjYjAezc8DEAoGaY/3k+hI4+wEqE53IrPaoj6z+18laSWJEmSR7c9Q28sgWgeT58OHw/2ck7FHq9fofAsZHYniEtG+GX+OF6ofxunHCKnMht2z4t052Sg6/XYfHFkUUaMdyJZIuimMMWhECMqxnBwdhaWjD1/04Z7yil05tMSauMJ56HcM/4GbtuSzvq1flxmgbtn+SjxmDi5vJq6cBo9sV48VjfHF/+dSb+yDoHMg/jTplf5ct5LHDZ2JWNz3GSKF/Hr3iyaRnqwJSR2+HxUJus4nCK2D+xkQftiJEGkK9ZD7cAOYmqcIkc+Ix2V7Ao24jN7uTnxGWcU6cxtXsw7mQeRNEXRhT56YhGSepL5PZuJqXF6Qk6iLpVSXUeJZuHURJKCiAA4tEzUWD6SIKHFbXy5JspxBzmMSGHAIgkEbWlEzQ58VhH5H9HjOppRFr2HZLYgFlXA9Lnww6tANPpw9ahLuXrUpbDqSkOIBoiE4NM3oWocFOwR78zjx+P7/YNwz08Qvp68Kqti1qgRfPiGm4g9gxElJopzZSicxcqMixFCAwyYisgaiB2wi1pfH8Ny+hi223rbH/YQW9lBpj5AU7eXQNSw22le7af71Y/IXvo4aBqceAEcdjJaIEDBb17F0+1nYDCNjSE/CaEUwaJjcVgRHTJxVUGQweIyIQgCEy8czcQLR9O8xs+G13bSvaYFTRPQrVYKxjlwZtvw7+gj7k8gaSYO2dyOprlIundiV79ClIaj6iqCJNA5uo30tgwirghyawGCoOMSFMQWG0gCjg43laGdnLouSNiWxlYLDNcWkqu28OXwVgIOAUFUWfiDBsbdkke/WeSY5k+Qh8cRLcOxR83oAY3G3AjPTLwboVvj4nd/yZYPmin5uYdNP2snpzvAQdpONm4uZ1V1GHd/BZ05OdSdHcP7ZCXT1lRR7q+neUwbIb9AdXMn3qfWYD/reUp+9yPEtDRCngESfUaEo/Caj5Xv7WBCdz0dz3Sx5twqqsoOwTJzJjaXjUatEUVViOgREiTQdI3Y4dOxa2OJ1+0k68oqJr7eQahtMyXqRojG0EMhhh9ZSueGbrSkzvCjSr9VZNYCAYJ33ona1IT1uOOwn332XvsblnbvVU4Jzf/3+IeE5n8nuq4Tiuj0BzT6BlV6BzXCUY1Y3PA4jid0EknjZzCsEQhr1DYo9PSrxBUdVYXdE5jsXqUAGH7IX2/Tdvsim2Qj4thiFnA7BSRRQJZAEI2ke38vXb3qP+UapEiRIkWKFClSpPjfo6WlBUEQKCgo+L67kuJfiNfi4ZEZ99EfH2DdYvjjay0ArF0bpLzcziGHpFNV5SQSUSkvN4RiXdd58MEmvvyyj4wMM3ffXUEolOSOO+rRdZ333+9hyhQPNptIT0+CbdvCCILAT39axKGHph+wLx6Paa/3TaEW1vo3AhBIBFnQvpjzhp+5V51VPWu5Y92D6LpOniOHP8y6l4MOMnw5/67JEUGCyuu/tcqXC9rR6x9jWMEABZPOhPTpQ/saRS8TVcMXGEs2aAlycwRyc4AqJzhKiMYP4jq+wFdYRPKwm3GpcZYtG2DiRDc/vGAiSUuIQmf+fvt9WP5BBJUQC5a1smGXTJM9QHirg3yHSl2gkZ3LuqgYYwh2v19zK89keAHwJJ5n8qGLCPYuw5M2DtGWv9dxBUHALJnxx3q5dsWt9MX6KbDncJgFCO3EK8mEkho6OpNshn87yeBQ+7G+kXza9gVeswcd42E3155NhXuP+JJuSaMvZlybHFsWQSVEQjWEpezd3sn7oOuw5SZy+9by0+ga+gQbzaPs2Mb9EEvecZSNmUjmknoaahaRqSaoCcSZMuYTJJOGhIBNEhFNht3FG5+GePWTMLmZEjdd9Cv6hEYKHHkE4k7Wdxs+1sGEzsLmGBeMNnFOxem4TU7eafqYWTlTOa3sG57Y/Wsg0gC+GWDbe0IgqSV5ue4t2iOdjPSO4OGXAkzOT/CHh36MSdO4eNaL6OLZhK1uwlY3VquMoils7d/OjavuoCHUzEB8EE3XGOEoRpIleuP9uExOrJKFHYE6FE3h+VIfNx08linRbbhCzWj6GERBxCZZcZuddEV7iBd+RqLjZLZ6BSzli5AtdoocuYzyVXGI73ieXb4CSyKLnMG55KTvjqk+7GSw2sjv6WRF5izm2FycMtwxNB639m/n6QV3IjU2c61nNlln3wRWw57kzc9CvPV5hPwsiZsu8vJ03fNM69+CTZCp8g7Hkl+6/xUO5/7MiGQOB6GtAd55Fj58yfBWztozUSTs2ACxCCgJyM6HSQdTVjSMx2eodPWplOWbkGWjn9WXHsKKR9dhtsrUnF29//EF2E49FWXjRvRAgI5RJ7H2pmUA5I1LJ6u6FFojCHY7UmYG1g2fEhuMMdgSQK17DNeow7Epg3gb7STbXXTFRpHviGC2NNMjlGAqcLGtbDNNtnpeC3Vw/m8u5qc3nTV0Ld3ZVra9thFBiSJpOqWsZXQwwobWUYSjblRFw6o70FUddJCCFrpMA5gcSULOAFGfggULLquPvK0V+PP7QNfIX1+OKdSNyxTFrarM6ltFwhJFcTay4ZCleHZ0k4ibmLpJY9lUlU0jQEuk0WLNw+5qxBSLolk1PF4oPP9Ini//kCX5XxARIiQUhfniB1Qtncarxz7LDYXboAiSsoefLzqItXVHI8VMLDv2PZB1Bi6rZWr2HP70yesE6UdWE1z+mMa0XTqJL7/E6nTiuPpqHGRznO04Xg+/jtoeo7yvlXEt63HGk7h+vZ7GiesYWPQ82q8uYmTeSAYjA4TX1RKPbUXwlHPkqGMQzhO5ZefPaYm/ztiZMS6rjyLVgeDKxHn11aRPzePkPx9JIqzgLdq/lcrXxN55h+S2bQBEX30Vy5w5SPl7/m7mjfHRsKQTrbePrNEpze3/It+r0PzY64NYbUaksZI0bCkiMY3eAY2EYgjJ/QFtd7I8nYSioyiGOPxNofjrgq7viSq2WwW8bondk/vwdTCy8I+JxilSpEiRIkWKFClS/KtJJpPcfvvtPPzww4RCIQCcTic/+clPuO222zCZTH/jCCn+EzGJJrJsmQQDe2w0dF0nEEiSnw+5uRZUdejJh5aWGF9+2QeA35/go4/8lJfbhiwCmpqi9PUlSE83s3FjkLFjXei6zuLF/d8qNP816VYfNtlGNGnYWnxtJ/FN1vVuGjpve7iTzmg3Rc59J0c+/bSXpqYohxzi+9bI6gOxcWOQNe8+xcySL2jfDl65AedBL/HjEefx+y2P06fm4yi4AqxO8E2DxqdgcAP4poB3PO+9180TTxyJSZpDVo6bRx/N5uqrBa6+uvgbZzmwJaQgCJxceiyJTz9D8KusQKHDY6EvNIAoCohlywknIzhkO6K+516hJ5Et6aTlHbvX8R7f9iyLOpcxMm0EPx99BSt71g6JwbmBNcy0qew0qaRrMUoqzuJIsY8pyRbwjtsr2vuK6osY46tGEARGeCpojbQzwlOBw7Qnt88NY3/KCztfwySaOHvYabSG2/ms/UvKXCXMzT94/x84GYBwHeHEADZdxY5CQFTpzNfoLXDS0vI5dYMN+BU/4erX2GK1MdscokWzEc0/hA86EzzWvpPT8r7kufcMX/GGtiTvLVC57PSRAJhEDYdJIKwY16tod2JKAYGFHUvojffxdtOHZNh8HFt4BLGeL3DUPWT0r/1tGPcYyM6hLr/e8A7P7XiF9kgnoiAQCp/LhvUT0VQBFYnPV87mimH1PDTsUEL6ao4trmZu/sG80/QRqq6i6xoO2UbmQISpuxo4vM/BqslVTPNN5k1bA++3zMcimsmwphN1O/nj5F/TGGzm5tV3EUgEmZM3k4sqz6Y+2ESobAtiwV/oDPTidSlEBDOH5MzgwUm3IZqtZMXH8dSijVD5AelFJwMlhnAx62hk4PT93JK7l/+G5dsaCCbNLGnaxmfz/oL1Bxfj71d59l3j/0WgQeOxD5pY4ttK2yFVjN/eSXj4MGbMPnY/R8SIXP7ZffDVx4bVBhhicmv9HqF53RKY9zTYHIbg8uNboWgYAF7/DrxNO8A+aah+xdwSyg8pQhCFb51sksvKSHvhBVAU1t+7mq/D5dvX9XLQGzfB61vxN4YpO7gQz85G2hcvRVVUBhMOtj2xkdFnVNLSXYw3HKXQ0kOBexsIIl1qIZ9ETmNLxSq6C4yJu+eTT/DjwOnYPGY2f9DM+zeuINAUAB0EQaMjmY/QHqO7X0NwKAiyjDUq0s54chM7UBwqEwNLcSQWEx8w85VlDP1Zk+mjl5LVo0lryUYzRxnXBBPNrxFTLag2OyaT8X/dHenhqE0J3EGRFp+OqElY4xay03zk4qRnbg6B1jyyAu/jtXtQbTJjrz2colVb+FAJkLDEwQzbDllGyabRDEgxBpwy5sEBImqYnUdtpmbU+VTmlJO12srWl7cz7Kgsyq1VtGYPYO5NQzL3sGKKyLRmE3o0ih43ki327uqn+OkRnMMlvDnydSxfJIg5wgTz+/DrKm+P30bryCbSP7JQ1jSV+vQXETQFl+RCiXVSW7cIITeblrhxrTeMs7Kp6hQO0WswjR+PYDYDYE+3YU+3HXA8fI1gte55I4qwu/3XHPrz0WzcMR+9bwtFG3uJvODHfs45xD7/nNi77yIVFOD8yU/2Pk6Kfyvfq9D81Lwgkmm3WGxMFCEIGFHEgoAoGLZAFpOAwybicwuY5P0ss0qRIkWKFClSpEiR4r+AK6+8knnz5nHfffcxbdo0AJYtW8avfvUr/H4/jz322PfcwxT/So44IoPFiweor49w8ME+RoxwoOs6Dz3UzMKFfZSW2rjjjmF4PDJms0giYfgYZ2WZmTjRTVGRjebmKFariNcrIwhG0j9d1xEEgZEjnX+jB3vjMbu5a+JNLOz4ihJnEYfmz96nzoSMsXzQ/CmarlHozCfHlrVPnc8/7+Xhh41o388+6+PJJ6txuf6+R9GurgRmyRBG0CERU0BLUOIq4ndT79q3QcU1e72trTW8zxXVQltbnFBIxe0+QB9CO0GNQbQduueDowxKfwzd8zk872HKqiNM663iL55phCuXI5s0hIwgOfYcfJY0fjz6R9A9D9QIlF66z+E39W3l/eb5ACzrWsWC9MWUOosRBAFd1/EKKm6TjRsydgvfoy8CR4kRWfVXwp0kShyct0d4zrbve/2zbJlcO+YK3ul5h4t2XIhH9nDbsNsotZXu//MDyG5wVZIMttKvafTqCRQTPNy5hde2nWNMhCSCWCQzGhqr43GecE/FZXYx2TaetsHlQISn655Hlu4kGI+xK9BAf9M2vHW5vNf0MZv6tzHcOZ2Z2ZczPiuTQ4sNESqqRmkINg11ZWXXWt5t+oRRgRUcJ4fItKbTH2zB3/oxE0tOHarnj/Wxc7COWKQfVJWqqgVs+/AqXHKQTClCSUTntKwYp5163V4fdULGWF6tfxu7bCMZD5MbEyiLmphdN8ip4X6+yv+A3okOXCYnoJNpS2dWzlQASlxFPD37YYJKiAyrMYlz76RbuXn1XbSE2lDNJoa5h1PSG+We11YjPjkG/ZCprMpNUjTDOP9fdqncOv4X+96D3i5oa4TyanC46BhIEEyaQU3SrZhY9toK5hx9CrLkQRINm1AAj9WOWTKzoyiDHUUZXDXyNCOr57dRNR6cbuhuN6KbX/qD4e98+GnQ32PUEQSw2kFNGu93bYHf32iMy49fhZsfAbcxZr+r/65g/JEid0wmbasMoTljeBomi8yYs8fsqTjxSppf70CLxmmyTyVD0dj+QT2brIeRjE5kovMrRNMAahKyrZ1IvQqqVdktJAvILhGLy0TntgHm37WBQHt0KGpR1wV0QWZY+CvMaiH9QiWmjHR8kXay000M9mp4Ar1kaAFMokIYB6XSEv50yVrEXhFvTwYjPhtF8cZC0qSN9Oh5tJhKUeIJrKY0JioL0WWdXi/YopCURHZlFhIs9TLCmoa1wMo5L/2CQCzI6rVOlmyYT1t1hFMH1uO7aww5x5XTWVmHo8+DgEB/WQc1G2cw79g3GbU4QXW3i42zXbQOe4kH2huIZ+kcvuIM6i/UCY2sxXVcOrtKW4mlQ4ZfpLZIYdyoUdjPOQeARfetJNgRpi7SiNAl8uI9y3D8Pkp1k5kN5TG+nKiQGRNpURqYsLYSX4aFgVEaESWKz+4iK2rFai3EIljwK378ip/avBhHFE75uy2/FF1hzZEZZLZUk9OuYj36aNZ7mvlo8HFK5BJ+aP8hkkmkKLQS0g1bFmXDBrRjjiH88MOgaaj19UTz8rCfddbfde4U/zy+V6G5tMCEyfzvi8po3PQcTZueIxowZlqc6ZUMn3QNWSWH/tv68Hdjs8HmzXvKKVKkSJEiRYoUKf5refnll3nllVc46qijhraNGTOGoqIizjzzzJTQ/F+OyyXz+9+PIJnUkGVDSL7nnnpefLGTnBwz9fU6n3zi57TTcrjttnI++cRPcbGNY47JQBAEHnqoku7uBD09Ce69t5FIROWOO4bhcsl4vTIzZ/79SdwrPOVUeMoPuH9CRg2/nXoHbeEOxmeMwSyZqQ80srJnLdXeSsakj6SpaY9PazicpLdX2a/QnFATfNz6OQICRxYeiknc86w4fbqHzz48hsJgPaU53fRnlPPMpj9R5BvNqaXHk9ASPLX9RToiXZxUcjTjM8budezZs9NYsmQAVdUZP96Ny3UA4a39XWh80hCa451gL4HQDrAVwMA6fD4TI6ocCKHtZHotNPZvJN3iY1rGRO6ceBNmyYyiKdzVtZ4tgVpmdG7k8rSJewku3/xcX79Pt6Yx2ldNX6yfQ4ddjq39BYi1Q9ZcQ2SGfUTmb0PVVBRNwSobUX2KpvBU+1Po6PQqvbzS9Qo3ltx4wLaP1z7HtgD4ow4cltnE1DCtySTdoX4SagJ9d78VLYlTdmAWzZglCxdVnsXOwXoifWl0b6/AnRbn/vM9/OLldTh8dbirVnHzqi3E1BgxNU5r+HX6lFp+NOYZwIh0t8t2JmSMZY1/AwclmzC3b2BBsI8NmsYwW4TOaDd9UhrP1L7Oba5KatJHA0ZyxQdW3AeKQnbSxPRALS/cX87rSwVs9Rs4oyYDjrtwn89b5i5h2uDN9G/bQZP0IV7bi2TGdQYknSyTibW2MFLSxOi0KsLJCHdNvJlKbwUhJURLqJ0SV+GQyIyuUuKfz3PpLoLDzqfWXMy2gR0ct3UF1r43QUsizJ/PUT8o5WXZEPod8t4R/otW/QX9k1ep2dqCx1cI6Vlw/cNcOPwKbtj2IFJIoXDnDDLy1kPjdrxjp3H1WR7eXhimILSd8zsWcbjrIN7Ji1LmKuGw/IP+9oBJz4Jr7oNbL4BEHFZ/ATmFhp3GzY/A0vnQ2QLVE6DCuN7Ub9vjTRoOQnsTUdXGuhe2oCU1as6uxpnlOOApv0n1iRW4ch1E++OUHlRgHPfL98HfAdOPgLxiCm7/BSse24DDLjPxotHUflBHxggf3TskuuOFlJvbQYKQNQ+PK4tZ649hwUFv4LDZufuwW0HXGWgNY3HIiGYZzWRC0FSsHjNOPYZH6aPKm8Cf4cJU7mBYtA7bYBtxR5D2hIQeMiGgIAgQ8MqErUG0siT+kg7UZBxnyEF9WCCzLY2wPQhWE7sqClhXlc9hq8J4ggphh8r60V6OHfcYWc56Pn9tCbRZufqM6zht/Al8nF1H5LBcYgGF3737JOMbj2PGU6ey9KI3UU1JVIdC//QmSgr8XP9OJh0JFUVPkL+6nVeKthKxxDHn2JBq3mXmglMQVJGjXjiHZ69qR9BFthVKXP24iXUFdyBmGEk6lWiSiBahOdFMMq6SdMCzP8tEarHS6+4g7o3QpYYhVk//CS8jaglOXeIiYYpxWtUJFI6dgyAI3FRyE5fWXorP5OPz/s8Z4RjBkenf7q/uT/ixiBZcsguAuwJ3sSaxBs6BHzl/xCxzDXf1/whFV1iRWIFbdHO87XjMkyeTWLQIANPkyeiqavh370ZPJL7TuEvxr+H/vEfzPxObM5cR02/G4SkBoLX2NVZ9cAGzz/wUV3rl99u5AyGKMHLk992LFClSpEiRIkWKFP8GrFYrJSUl+2wvKSnB/FfLR1P89yLvzv71xhtdfPVVP4FAkmAwSU2NC4/HeIQbM8bFmDGuvdqZTCL5+Vby86385S+jSCb1ocR+/0rK3aWUuw3RrCvSzXUrbyeuxhEEgXsn3cohhxTx6ae9hEJJamrcFBbuf0nzbzf/iSWdKwDYMVjHtWOuGNrncMjc/cBUBv0VWBquZGvXO0xE4qme8fgsabRFOvio5TMAtg5s54WDH8X+DQFvyhQvjzxSRW+vQnW148CRdr2GeIGuQaLXEJoB1KiRpHBgDW6XzDxVpi/pp8xVgtPk4DeTbxs65i2r7uK1hndwm1wEEyFGeUewPbALs2jm9LITGOGt4NyKM1jcuZzqtOHMyZvJ5Ut+QVu4A4BFfTsYOf5x0BIg/v2/9/WBRm5dcy+DiQCnlZ3AuRVnIAsyTslJUDX8nd3SgX1SP29fNHQtt8QjFDvSaYj60dCJqQEUTcEu2ZmYNZaDcqeTZvZyVOFhZNsyeaL2eT5uXMKmj47DqWfic+TTPVpn1LGfsbhjGf6kE01XialxwskwsiDTGe3m6R0vckX1RbSFOyh05HPLuGvZ0r2M9E1X80KgDTUJvbrIRUEzY2wuXL4akoJEa7h9SGguchbwa9tcnuqZh1VVOLbHjsMzyBXnl2CRDj/g561tSPDFl06SLjttJWuIWtNoLPDTkJPBnT1uJloy+MwjIwoi7vajePRxL/n57WzKu5sBpY9cezYPTvk1LrMLOj+CjncMoWVwK87y6/hB+cnYsvtA2+0nazcxN28yW5JZuM0uLirbY5SxrnkJPHwzef4g2mCEmAbWpAJNOzhrwjQyOx5gzdPvMz67idG5ESgeDsDBk2wcbF4PT94LfZCxXeW4y6+jtGjmd48qlSQwWXZ7jmIIzknFsMy4+REjWaDjG39zRk6ET16FeAwycqCogiX3raF9TRcAgfYQRz8w57udGyic8g1rnoXvwJt/NsprFsHtT1EwKZeCSXt8ucedPZKIP4rZYaK/eRobzPmYEoN0Z01Hb4uStymHH/tvQrKZCazXeWbnW2RV+0grNMRvLeHAk6Zj95qpOcyN5U+LMTtNlMrtbMsYT+cXcTL72tCcaThFN4rFQo9kYXu1lehvTuN05yBv989DCSZI7zK8zuu9mcScAmKbjUTSjd6nM39ymJgVLn5HY9BmZtrGEBu6f836dyeT2VdI3KuifGDizYI3KbYWszW8lR3BHdjTPYyfHiR3dT6zF5xAj7eDhJag9tRlJJdn07JlgAxy6Cxt4OPsOtrjcUSzhMkVJZAIoMsxYj1BvJlOjlpiR4620jRc4Li/xOmPX4hl+nScN9zA1CvG8erv3iYoDbL6mKX06b3EbXHcZW50p4bFZEMalFESGmZZZsA9yOKDqsgocjF6+q+HxpfP5CPbkj10f7oSXUPlplU9rHutAWemlVmXV2Fxmnil8xVe7HoRWZC5rvg6prqnsjaxdqjN6sRqxpnGoejK0LY+zbCMcl57Lcrs2QhWK6axxqSi/bzziL79NlJhIbaTT/7O4y7FP5//KaE5u3Tvfy4jpt1I06bn6e9c839XaE6RIkWKFClSpEjxP8MVV1zBHXfcwTPPPIPFYgEgHo9z1113ceWVV37PvUvx7yYQSGK1SpSV2WhpiTF8uIODD947KjkSUXn66Tb6+hROOy2bqirDHkOWReTv4WmvOdxKXDUsLnRdZ1egnuNLKnnyyWqCravJCd6BsA6ouBY8Y/Zqu2Owbk85UMdfI0kCPtMugvFudHRsJBmmdtPb/BJBJY5TixAXLCTUBHE1sZfQDJCTa8KREUeSBCNiMt4DJg9Ilj2VXNUQ3I4m2XhaL6S2u4056VUck3us4QdsLwJlALlpGfRtRcCISP1abFnr38Ab9e/RHfMzkAjgNDl4dufL+GN9oCXoiXbzi7E/5bSyE4aS3Om6Tme0e6gLbZHdXt37EZmf2fESK7vXMjJtBCZRZn7bQsJKlDG+am4d/3OcJidvNb7PYCIAwOv173BKybE4TA5uK72NV7peIc2Uxvl55x/wHipqAlVX6Y31kWFOZ0LGWPzxXvIdeQQTIdwmJ6eXn8jsnGlDEwwA2/p38EnrAtS4A0FxkO5Iw212sbmll+bsVpK6Sk/Mj9fsIZqMoek6aVYPRc4CAokgl331C+M89lwenPJrxmZMYGWsnwmSSsCk8VbCTJMusjYpMA2BXFsmM7KnDJ0/kAjyurOLYsXKcS0avxubILbpdlwb49xZ/UPKCk8CYV9LB9PuJHZxaycWyUzEJtPhdCGPuJzHN5yBanZw86hemvp6efb9QtYkenltfQPyaJVR45J0RLrY1L+N6dmTDbsU4NNQP1d2NqK2/ZRpOdN5/Lg7sUd2QMsXMK2KzOE/5S5bCfqf7yFx+4nEfNlYHniKQHcjtkSSmEUGHcT2ZvSeHmof+yl/PLqaqtKJ3PDI8Qi7tkB7I/zuesgtgpMugkFDhKszx7gpt5nI5vsZFVjMHRNuRBa/wx+DjByYcih89aEhMOeXwskX7RGXHXtPbJFfAjc9Ah1NUFYFdgeR3ujQ7khvjH+YjuY95eAghAKENBf9zSGyKj1YHCasHguH3jaD1U9vYuu8nUQwAvRGHl7M2hdq6WsME2wbRJGcNHylY3WIBHuTHHH7JHLGZuPOsSOZ9oyHWObPSSxfzqCtkIbFXgodefh7uxGiEnZCiE43IyYNpwpwqsdiHjWDS4IX07yjlWdqnqdP6SbsCdE73krh78Zg0mRs6XaqN49lbG0b7jCYlCTN2THatQ6S/QGs/SLWXpng+CjZ5FItjOYLvkC1Jhm09/PmcY9xi+NhstauI23VAtotDu4vt6DKrXwxPk5Oi42dxaVsL12P3qejepLYAy6GLxoJgwEGTGE6Z7zKUau3EhWinLBUwp6ej+CExNKlqK2tZCebmHFCGx9UbySoD6CbdGLmGCbVRKaYyaA8SLacTdyUoCSrhICexYTKCRydfjTpYsbQ9Su2FjPDM4Mlg0vIMGVwuM/Q35S4ymf3biSZUOmqBZvXzIxLRvB69+sAJPUk7/S8wzTPNGrMNaxLrANgvGk8RXIRh1sPZ35sPrlSLsdad3uNCwJtY7LwmXx4dp/fduqp2E7dY6WT4vvjf0po/ia6ptK+6z1UJUJa7oTvuzsHJpGAu+82yjfdtI8ReooUKVKkSJEiRYr/HtatW8fnn39OQUEBY3dH6WzYsIFEIsGhhx7Kyd+I0nnrrbe+r26m+BcRV+NIgjQkCp10Uhbr1wdpbY2TkWGivj7CAw80cdNNZUNtnn++nU8+8QOwbVuYF18c/U/JabNzsI4F7YspcRVxRMEh37ldtbeSPEcO7eFO3GYXkzLHAeB0yjijz4JiiGE0PA41j+zV9tC8WbxSN293eV8/aADspTgt6fgsafjjA2hqhMOTTQixZmbFuoiKVhq8F3Pfr3oQxR4uvbSQQscGQu0fcFPnThpUgbG+kfzKBXLfckNoHnkP2AsJBpM8886hRP1FFByymnfk9SCLbI/oVEd7KXBYeGegjbAS4QcVp6HufIOoGuXiynMB6Iv1c83ym2mJtCMKInE1waTMcXRHuyG4DZIhOpRWqDoPzF4A3mx4j8/bF+GQ7QwkAlglCycU73+5+eqedbzV8D4AX3WtwCyYaI20Y5bMmESZD1s+4/SyE/fYOAAusxPLbiG90lHJbWW37XPcsBLmnaaPEAWRE9wZzG1/knv71tGmydjNHjb1byPLmklSS5Jly+C6MT9hWvakfY7jMBmCu8UZxlNSR2ujSI/ayriCPuSkTKVnGIFEkIgaZXLWeHrj/ZhEY3tCVfikdQGCIBBwB1nXu4nZudP5wnMw2epX9Cd6qNMkLJKV4e4yCpy5HFN4BG7THvHz91sepzbSRLDEwuJhNjRdYVS4gcF4F+9vaOKqRCsM++lefV7cuYyuZA+nHjuBpeunYvJ9ijXXQom1GHXJD3l/swgkaPGnc+EJJTxLN3WBBhQtSTSWoD3SSbm7lGJLNjxxJ9Svg/ER7kx2MKBLkIyzsnst2+NtjPvRH/a+YLXrib7+BtFd7cAuEj+9nAlPPM5XpY/ga2hiIDcbj+gh4LQT7Kwje6vAJwSoSR9F/pr3uLfzDUKCyqXrcpjVsgtsTvB38mWZSsTjAoebzX3baA23U+Iq2v/v019zztVwwvlGFPN3ST6bnmW8dlNzVjWL71+JrumMO/f/Y2X29CNg/RKIhGH8TPqCVt65bimJSBKrS2b4LB/pZR4qDi9h2Nxi6hc0ERtMkD8pB0EQcGVbifTFUKIqslUkNphETcJAp4Ijw0asP8JXD6zAbDcx7arxuHOdWI84AumgQ+n8ogXtizV0uMaSr2zBgoo/ewzucDPJWJL+5hArn2hktHUY4yeOp7ymnAFvP2ubt5AW9rG5awsuVzoFpkIsdhNjfbvwhs10Zqrk+U30OMxsdpXj8+skTQqSpiGRYPuCHl6d9DphKYBmVTFlmgklBvDM+ozKV19A03RcMT8/WC2Q06kiIBCVNJaNyyeZnkQICUiDEuNfnounw05HVSNJcwJ7uB2TbkISZDxWF7lqDgCCzUZixQqizz1HBTp3pFk579Z0eqVBnLoTQRbIDedytOtopnumY4laiCQjHJl+JB7Zw5p7Pmbhi5dCRhYTX/gF3iIPN5TcQL/Sj0tyDf0f05IaqqKBoqB2dhFZ7kc7v4x8Sz4NsQYA8ixGNPst7ltYFl+GW3Qzzmz87/iJ6ydc4rwEM+YhH/u7Gu9iRWAFVtHKr8t+TZWj6h8fayn+6XyvQnNDq4JkUv52xX8iscFaGhediK7FESUH+ZOfoDtcRnf4n9+PpKKxcuUg6kD4Hz6GFAtzxO23A/DJmPNRrd/N4yhFin83sZhGJKKiqjqGRZKOqupomlHWNHbv04nFNJJJnWRS32efPpSUwSjvlbRbZyirOcC4cW7OPz8vlSA0RYoUKVL81+D1ejnllFP22lZYWPg99SbFv5P3mj7mye0vYJEs3FLzM8amjyI728Jjj1Vz9dXbqKszIgU3bgzt1W5wMDlUDodVkkkds/nv/260eXOQjRtDTJzoIrtE4+bVdxNNGueUBZlD82ezdOkA27eHmTHDy/Dh+38ucZgc/G7qndQHmih05uMxf8OiQfpGhLG0d/6ZZcsG8PYdzBV5I1i5PIgcLkcr0ff9nmfNRhh9P8MG1lFoL2PKzt8gKAOg+BljEtAFhaLmF1jTXURt91g+ePZVLp30K0LxQeYmNP5sHs+Gniibg4PUWB2gDBoJ/0ou4k9/amHx4n7ARyLhw3zInmhHoedLalc9RzTcwwemStb3bdonCeH7LfMJJ6NYZQuKqpDvyOHiynPZ2f4pT3d/iSTAyXYL9C6G3ONoCDbx7I6Xh9qfVX4KxxcfidPkpDHYzB+3/hlN17is6gIqPOWo+h4P0oSawGIyIyCgqQmytBDu3Zfqh+WnoOkaPbFeTi455m9Gsz646VFW9RhRhA1qG1ebvKTHLcixIjY0jyCW1c3YahMg4DV7+Lj1c/oaSlm6SqSsQOb8411IkkCRs4CfVF/Mgo7FeOZupbN3I2ZbnHXJJFXeSrYNbKfCU0ZMjTOYCJBjy+I3k2+lwlPOcZ/8EABN1+iIdFPkLADg3In38OKuNyiP93J158cEZB9fBLtZ0b2W9nAX61paOdp7NuOrLHT3N1MqprFLUpEFExm2LHoHN2JGRVZNMLB7WX7dVti6hg/SwzwWNKxScu0LefTn9wOP41f8ZJgyuOrtAcD4/erqTVJRbOKY2SY2vB/Hl9FL1rh+hvlGc+PYq8nfUgsbDdsXFtlxzKlE0BrQ0ZFEiUJn/r4X3uVF6Q0OvVVa2km3uDnirsUE22pxKQLCb69DVwYhCoNOY8JA0OHZtvdptyqg6/whq5tZ65ZDSSVk5FBakAnFRjSxy+zcS4zfL9EI/PluaNwO0+bCqZd8e/1voWhqHme+ejy6piOb/z9se0qGw6+eguAAZOXR9GYjiUgSTdXZ8WkLPRtbySiyo6s6WSPTceY6sXqTjDunGi2ps+vzZhzpVkS7nXjShJqMYPWYyB/rIz4mzOvnfY4j7MQu2Vn15EYOvXU6iXCCD6/9gr7GAO3bI4QG09iZdgnaYBA1lM7pV7loX7eGj7MG6HFupel2gQtfPY1ftvyS7f4ddFf4mbRzGkd9egL+QQipMfSRCeomDNLXG2PWGhMJs5VlU0bTJQdIqwfFFqNzZAejV8xg7einUCxxQCQZTaDqUcyamVe2P8w4Eph0AVm2MkbOot/cg6qo5AxYEctbEc0iYoZImaWMIybN4dnZj6BpGvZeO2bNwhy/iqc3gWvWYTinH4HW3o7l8MOJf/QR0f4Y0f4YxS4HL9mf4Jfig5gCEZySmyeqX8YreY174gBdUVDWrqX7Nw/g/XAhVmsGCb+XhltdjHv2egDSTHuvurE4TEy7uJJl176GK9xJ6Yfv0jPtQa5/+A4+KGnFLto5NcuIRDYLZg6y7uspbhH2rDrxK35WBIzftZgW47O+z1JC8/8xvleh+ZJTXNjsB/aG+leQTNbQd8JXRMODrF/5LksXXMt5p35AbsGIf/q5fv/7Jp59NMSLova3Kx8AmxbliN3lG27YSVRMJQRMcWC0f3yo7YMggCgKQzlHBMFYrigI7H4JiOKeOpIk/NV+AOEb5T3bv27z9YPD18fbn33YX2/75vvGxiinn56N0/k/uzgjRYoUKVL8l/HMM898311I8R2YN6+Ll14yEvT98pdlZGVZ/najv8Hzu15D13ViyRiv1M9jbPqooX3Tp6cNCc3Tpnn2anfGGTls2xamv1/hvPPyMJv3tQb4Wyxe3M8119TS0hLDZpO4/gE7UdeeJfCt4XbefbebO++sx+2W+PBDP3/6UxUZGftfbWmX7Yzy7f3gr2gKyxxTKY72UeQsRCi7dGjfvHldPP10G5qmU1cXpaLCziraSCZ1Tj89Z98TOErAUYIFjCR9fctBMwRBQRBRVJlJBV+xo2cUNZnP0xrpJIZEFjoOdYCwNYt0kxPYHcBgNXxf+/uTJDTFsMNoHEd1up/tg7uYmzWBkq632BZrpVIL0Z9s5svQvkK7y+Qky5rBQHyQcDLKBRU/pDqtkpFWBwcNfIys67gkCSzGZ1K/9uz9+mOZ7DhNhvXJH7f+me0DuwB4aPPjPDLjPiZnjufIwkNZ1bOOk9JG0BBswipKXCO1M1FqobD7Zciqwewo4cLKs/Z7b/ZHY6hlqNy21ssb80dQGq3mjfRJRB0Kep2FDsd8mmyfE06G0cNezIsqqHAPI3tHBh7bWrb6XmRpbx/Ts6dyz6Rf8ufaF3hH+QgAWZS5ddy1qGi4TE6CSoiNfVsodRUTUsJ80rqAPHsOwz3lBJUQs3OnD0Xg5tizubb6AthwJW02hY7IJlbpaWTbS+jpS/LnFWv4vHUmc4tVzghv5kFfC2NcHi4/+h7ebvqIzlgDEwkwnhB4JxgJ7f5wMySTbM/sgLH5YHPQEekiqIRIs3jJ2X1/zjzSwYMv9KNp8IMjDd3iitOyKJxs4eW65eTYq7i55mdGBLm5ba9renv5j7in521iapxbomPIuPESyMqDS2+DtN12A/klmH9wPskXXgC7C/MxxxtjWJJwF42E538LwQE8SpzwYccRHGHj6PTRTM+ZwiJdNPI5qSo2TYTCPQk75+gFSGOOpDHQjLX9FRbNn0avcwSnz3zB8JH+a5Z+Ats3GOUv3oMJB0Hpvtai2/p3UB9sZFLmOLJsmQccT5L89/8N2i92h/ECskd4EASBgZYgiWCCMBpaTCG4rYHOtxfS2+5CF2QW3b+KuGYnrNiwFTsZOSOH6KAhyPtKXLiP0Llu13XkBMuRwyZGu0ejq8ZDdNeWXjbHN+OPKcgDGagRkVgARNGBNRxl0Yc2en5g5R15KfGQwirbCjKuSqP+snpMDhmrx8L60jWsLFqJI5bG7HdP4bPiT2hLbiM2TWRnEZR2pFPUcQqenhBhOUJvWQuBoiiRVTKe2lxaq+tQ0uIQA0mT0Eny5YQkT58kccm7EqbCXKbc/jTtd99MciBO9wgLfZU7yVbTOeOZCIc1isRnL8KVaycQChJy9XDMAonlB3k4puIn5M44F6vbMmT1E9jZib/uZdBUupQcStrGcuOG4exsW8aUeiuc8Am7jpzAZ32fIXb0cOzDmxFXrEPTdERUbLFuEhYvVi3wrbdy1LGF5D31FcqGDeiRCHpAx/7n17lkP995dE1DEA88hjyyB5/soy9prI4psZb8I6Mrxb+Q71WdufgUD273v1doNvj6j+LBHHbYRrp3PM0d1z7+Tz/Ly3+MkUgTycraf7KL74IlKcBOo1xebicup4Tm/zZ03Yjs/ToKOBrV0HWdRMKI9jWifo26qmp8Gf5axIVvRgB/LfbuLdxKkiEIC4KALBtisMlkvMxmEatVRJKMsvHTqJeba8Ful/YSkm02EZNJQBSFofeyLGAyidjtIna7tPt8Rj++Ln8tSH8tRlssRhtZNvZ9vf3rul/znRNXpEiRIkWKFP8lRKNRdF3HbjciP5uampg3bx7V1dUcfviBk1ml+PcRDCZ55pl2dF2nsTHKq6928ZOffMdl6d9CuiWNtmQHSsiMxby3iHP66TlUVzuIxTQmTNj7+amkxMazz44yHvz/wVVe69cH6epKABCNqix7z8T4q8aw1r8Rj9nNCG0qV91VT1NTFEkSGDkSOjvj+xeam1+GlhfAXgyj7jWsKbQE96+8jWUDu0AwcYJnOD+y7Ynw3LLFWAGqqjr9/QqaZmhobW3xA3daU6DpOehbBq5KUOOQ6AdBwJOdRbQxn0NHrmBRWh0HJXUEEkQlFxNyDmbmsLMotDmh+1OwFUH2UQBkzd7B5mWtaAmJq35Qzo0TbzLOpQzCqk/IsmUSUsKI6BxXdMRQV77qXM5XXSsY5ijHt/NHpDcluXhGDtePM5Z+Yy8krfpX0LeULarEvRufxiG/wk0113B62Yl81v4lw93lHFlw6NAxVV3dpywIAldUXzS0PaklUYM7sGy5fnfFCPi/NIT4v4Pjio7g6e0vIggC5VsPp0XtJCJ68QTzyC200x31QyCXiCmCqqsoCYmEEqEp1EJc6WBJ4+esjXzAYFLkkd4tpFvSOG/4mfjjfXRGujmt9HiczU2GoJlThGfuKczKmcZa/wZ+tfY+dF3HIds5tuhwXCYnZw87be8Oxtog3kO+PYd8ew6X6wW8G+ynpbmVcFM527vX4+9ycGOBi5eCFWgCOE4fy0vqWyxVBOKSnaRjLFPLfwLrlkDSmJSYHXKxOBYnaXMwPmMMXvPekziJ7BX4a27H1N2N86MiyLifjT4Bh+zg6dkPY/vms/nEg6ClDuq2wNjpTKo5mbc4Gfr98MsLCCoh+nc0oM57iNIL7xxqZvvFLcjHnYoeDmMaP373jU0a3ssf/AXd4SKUn8949wjmzLp6qN3FFT9AaZ1H2ATnj78MSqfD648blhcn/4jZuUUUROvxB1YBkBdcxYq6Fzis6vJ9B4B5t14x4DcS+0WC+1TZ0LuZX665B13XeaV+Ho9Ov2//orWuQ2s92F17WWr8/5I3ysdx90zkw1vXoIfDqOEonkQLo2vfpn+nn/RkNuu8ZxHsjBBRdCJ9CVpWB+hrCjN8diahxh4SXXbapoeIhqPUTt5EwcJSeiI9nHbRMQBsTd/EWzNfJjtaTXpbGVntRaiK8dStJAXatobodDZiCoVJaCKB8n4Cn4SYGJzCmrSVpA9Pwx/xkxZx0bHFz6ryLwiYB5D8VgZzLGyukNC8RdTU5ZJpga3erbhzvNiCTrKGpXHER2fSNmwncpZGTIoSsgSRNRFHNMnSGTYubR1B2r33YZk2jZLH/4La1kZrbhdFAw+QvbyWGctgtC2X6LsN1Fxn4ZP8Dgq3+Zm4VsGxzI4WeoOfj+gkesFGDj3sRM5ynk00p5KlU09m+bB3aczv5rKerzj8ww7GKvn4bXGuCN3Jug0qCT3BaV9YeMLVw5gqO9OWR7HkZpLoC+AszaL45gsOeO/U7m5C99+P1tuLnkyCICBlZSH8lRaotrURuPVW+jp3sfhwH+GTD+OivIuwSnvraWbRzD3D7mF+73zyLHnM9c39p42z74uQEuL+jX+kJdzOCcVHckLx0d93l/6/+J8PA9R1nXj8W77ApEjxD/C1YKyqOoqioygaivK1oKzvVfdrgdgQXfcIvTk5Zmw2EYdDwucz7RZoRdLSTJhMAjabhM8nY7NJQ0KuvDuRhdst7xaAjXpmsyHqut0SFos4lMk8RYoUKVKkSPF/ixNOOIGTTz6ZSy+9lIGBASZPnozZbMbv9/Pb3/6Wyy677Pvu4v88X0/YJxLGdzq7/Z/zveqX437O3a9/wFcvZLLCmsdLHR388Ie5Q/ub3Mv4OLCAr7aUcHnVhZilvUXe/YnMg4MKr77ahSgakc8ul4ym6dTXR/H5TPh8hgfr5MluHA6JRELDbpeornJx3fjr6Ih04bN4WfJFBLfbj8kkoigqXnuI4ZnbQR8HwjeWxw9uhK23gBqCgTWACGN/B5tvYFPzB0YAsauKTf3b9urnjBleVq4cxGQSGTfOjSiCwyFz9NEZHJDau6D7MwjvNKKarXlQcQ3E/XhkJ+cdcSJay8ucuMzELj0Lmx5nlVhKbqSPjIGdTMk60xCov8Fa2/uMu34QXRfo8NYBcwDoTibYaR9HpbaWUcUTyS/5MXleI2K7MdjMfRv/gJ4MM2/jGkybTyfLNZyvFro5fbJCaf5un1vfJPBN4tqPTmNj31Y0XWMwEeDlQ57knIrTCSthPmv7kjSLl+nZk7ms6gIe2vw4mq7xk5EX7+mkloSmpyHcwMdk8mlfPT+OtVHpyEUSRLCXHPiaHYCTSo5hatYERESef/9N2ut1BAJI1h7SLeNIc0soRY3oIVB1DdHdgaVsNVLHXMzeBqaM28CSZgV/RGd0c4ydsddwjvwRN4w1/JCTA4MkHzkF2dsMLTYwyTDnRDb1bRuyxQsnI8zJncmS7pX8eftfOKfi9D1e07ZCI+o81gGCxMUjr2B2XQNXtr3G+vYadEFFSa9DFjRkXQJfFnGbFX+0lwJHPu2aSjJtshGNUzkWMnOhp4OJ1hIePfh6es06Vd7h+wS5XLfq17TFasEFt0sxfv7xffx+uCFSf9Aynwen3LGnjSAYifP+GrOFmJ6gdmAnOjqLuhZweO8WxqTv8S82jfir1dVbVkPdFnRRJDzYSbMwwG+7IkzY6uKSEechizIZF93BreuPApsdRk402o3a2zfbKcn4v/HeIx0g39P0w40EgPVbwZsBrzwCtz4Opj31t/TXDt2rgfggreEOqvYnNL/wO1i5EGQZLrwBxkzZt84/SO7INKb/eASL/qCRjCSYVdyMxQLOHDvRbU1oiXYm3HQMy59rJNgVJaJG6dM62fnhNqaWl5NsUfF+7EArEBjI60U7WmDa6umAwMKHNrNkbSOlI8bQfXQTpgEnhWoxLs1O1B8BBCSLCedLAq4TAiSwU95agRYVqXl/LkVZY6mYks+93E5rUw+6qmNV7cxuO4KFxW8zQSxk4op8cracgSliQZAEKtMqiBzaSOxFici2BGa7ieKOMmKWPgSTSH5mLvWhBtzpMMWSj+/X12GZMQMAKS8PKS+PQwHBbidk+5Bx1nXYRTsOHPzEez6rlbs48p1OxKRhMRE3rWVS22pyb3BRd9Jmeu44gpwxmSw9ahtbhDiyVeWt3Nc5pqYGZdUqlub30p9hIq5FCKkh3qrqIy0twrIaCDkdnFB6OrYzz8Q0YgTCt2SejTz/PMnaWkSvF7myEvO0aQgWC44L9hano6+/TqKrg12hHWS/pfHUpBhu2c05uefsc8w8S963JjT9T2Ne44es9W8E4KntLzI9azKZtm/5//d/nP8pofmmm27iqKOOorCwkGAwyCuvvMIXX3zBxx9//H13LcV/AIZobHgLJxI6iYRGPG5s0/U9lg5fRxjbbBKybIi/Xq8Jj0cmK8uM3S5RWGjF7ZbxemXMZkM8djoNETg93ahrMqXE4BQpUqRIkeJ/jbVr1/K73/0OgDfeeIOcnBzWrVvHm2++ya233poSmv8PYLVK3HBDKW+80UV2tpkf/CD3bzf6DuQ7cnFsnU2R3fBgnjeve0hobgt38Hjtc0YUdbCZYmchJ5Uc8zePed99jWzcaEQntrfH+eUvy7jzznpWrRrEYhG5/fZhjBzpZMoUL2+8MZa33uqmvNzGqafmIAoi+Q7j/KNHi2RkmBlT2YcQ3caJx/6RjatNTMwYDcOuhvRpxgkTfaAlhs6vhDvYuWYLFdHtTJF9PPFmDZH+AkafPhqmJCHSAJYs5szxUVxspb8/ydixTvr6FJxOGbv9WzxeB9eDyQvmdEhGIX26EZn8DT9iMfc4jvK9xId9dbQLHmwWHwk1wRsN73JY/kFDn+9rChx5DMQHEdAp2L0vloxx3crb6Y31AS5+UX46s717bEH64v2GABdpQkuMJqHGjc/lGUssbjwY6Lo+JEi2hjuGIpQ39W2D0E7Yfg87ulawmFy2SFlcWHkWJ5Ucw6Mz7t/3c3e8Bx3vURcb4L7WnezAwRqzlRttXo4ZcQlk7utvCrCxdwuftC2gyFHAaWUnIAp7P2vk2g27iNjpYQLiILqmER19L1H7WPpj3fTUxbAqVVh9fVQWZuDMa8UqvcxVw6qY7jDzdIeJY1cGmdSu4ti4jpjrdqyT8/iyeSxPvmniJ0VBKqwKPtcg9M0HTmRCxljebvqQpJYk35HLI9uepi7QiMfkoivaw72TbzU6J1lh9APGPbcVgaOEHF86eksHatKG2dGNe847nOFwc5Y8muMPuhqzxYHPmjb0OUtcu73uHS644WHoaGajKUBtpJYpjglI4r5jLagEQRBB1whJGmttQcCIYt45WE9QCeE2u4glYyzoWIzL5GRm9tQ94rOuw6uPovR14RsMs3hsMUvGFFIZatlLaN4HlwdkE8mCUvrbNnPvdDef+oIs3/o0MTXOz0Zfbgi5Ew+QMHM3WYWnEOleQLhvJQnPBGqGXbj/ipIERRVQVm287/dDcBB8e1ZWTMys4c3G90moCfIcOXuu5zeJxwyRGYyo7OWffiehWU1qBDtCODLtmKzfLlFVHV5AVoWHeEghN2yDv2wk0BpEMbsQM7Po3d7LMXdN4NVffUHrrl50UWUgw09tQYyRLWPINmdzc+xXvP/QakyDNvodsPyxzTSsGcApppHWVIZ2fQjTJSEq3iwgd7iPaCBB/eIurDad/I2FnJNeRYsmkWM/hG0ON81reumuDdHha2TEsMNQpyzDGXBTsWQ6xVW5HPNJjNjOOkytfqzpH1JbdSFVRxQw7UfDWf3URnbSSHh4kqSic0fJr1ncvIx4PED2p7n0n/ECYr5AuzWXROVELECyqYnIn/8MsozjkkuY6Z3NR2us1DaFyHX2kHbCYQx+VcVM6+EsGTdAUZsfSRXpd3jIjnYRt0coX5vA0taLXJzJ1CIXNZ9F8Bc7aTNbcN14I4mvvmKYpR7J8TZ5ioNd0V30+SQyTIWIipmOnx6FZ/Kd33qvhhBFYgEFf0MAXTSR+cBPyK/ZN9pdcLvRdA0NDcUsoZoEliSXsGNwBxNMEzjRfuJ3O99/IH89TfyfvrL7f0po7urq4pxzzqGjowOPx8OYMWP4+OOPmTv3Pz/UPsW3o+tGZPE3E9UZyer2JK37WiD+Ogo5mdT3sqgAhiKDDasIiWHDrJSUWHG5jC/C6emGYOx0yvh8JvLyLLjdEg7H/9SvWooUKVKkSJHiHyQSieByGVFi8+fP5+STT0YURaZOnUpTU9P33LsUXzNpkodJkzx/u+LfSUGBhW3bDKG5sHDPcuGkltwrIbKifbdE5h0de1ZudnbG6elJsGrVIADxuMaCBX2MHGl4Ao8a5WLUqP0nDcvOtvCHP4xg+3uv8lzyDV6x9oNf5bKYn6OTIRh+nSFw+qZBxgzo+QJVcnPfWyeyoSHE1Qfr+HqmkFk/HMFexOa38ugpu4NMea2RIHDkXZSVDRs633fyvE6bCH0r2C7nYS/8AYXD9hdNmsZlh3/MMcFmPmtfzLzGDwCQRAmrtO85bhx7NW81vo8sSJxSehwAPbHe3SKzQe3gTmbnTh96P8Y3kvEZY1gbrOWMyuX0B6uoG6jmkNl2qsrM/HHLn5nftpASZxF3TLyRowoP5a2G95FEiZr0UdD0LGqsC0UZ4GhCbJGy2Ny/7cATCaoxPtojXWh6kqgaZnUyyq3+DsbYhrG/1KGDiQC3r7ufhGpMAoiCSFOohc5oN6eWHs/UrIlDdU+sPppfH/cALaE27EkZl3OAbZ/aUNxBTKIJZ8c4ll7+OI0r5mFN6uQWnUBHdC2afCs1PUuxyzZskoy84nk+8OZyxSun4cNL0izSkkjDZ0tChXGvR/mq+P20u2kJtfF+y3ye3v4Suq6Rbcsk15G994cwuSFjj7D6RYMbm28OVWIbbZKMTa0h4uriz0IDhzptOPQk91aezDtd63DYi/hB+cl80f4VLeF2DsmbxQfRZfxmxR+wyzYqPcN4bOYDeyKod3NyybG8r32AGuwnTfZR61AJRvtx2dIY4a3AtdtP+/Z197O5z4jSbx3Wzg/Kdyd0bdwBa7/C7ssjIobo8NkZJE57pJNAIoj7QNYTZVVwxuVIG5fxruZjUUYruhrDIdvZ3F+7/3GxP0QTJZOe+G51Jx8Cq78EJQHVE/b4SO9muGcYf5x+L82hNkamVe5tG/I1Zgtk50PXbr/qgvJ96/wVSizJJzcsoq9uAHuGjaMfOBh7+rfbhaaXfn3dDqWvM8Hy99+kLlSBMBAma0yc3Oo0Dnq0lLXXrMC2Mgu3x4ct4KVkdgE1Z1Wz/fMOclx5xNQI6kCAbW/vIBpM4huVzyjHKKpzZuJc7aQx0YoQNTHnqnFY7CZCPVGq8+LkBe2UyzKuGw+m9td+ov1hQ19QNDIbCzg6cDYWpwnnQVaO+uUY3jliFcmBbGIRH5XSDgBcOTZMVhlvkWEf4fDKxGOw6+1BHG1FyANRGo/b/P/YO8swOaq0Dd9VXe027q7xiXsIECBIgAR312VhWWwXFneHxRZ3t+ASIESI+0QmyWTcvafdqur7UWGSIRMILCzsfn3nmmtOV52qc8o6U895z/PiawuQlppMR7SDra6N5GyJI/TP+7AEOxBEAW8oxMac01jzVh2qMh2nzYLpGz16SyNF6iRcI4LMnelCX2djuO5rxn0ZQe8wEGcbgS0hE6W7m2OeqqHWHWW9u4nK/Yxc6f0bV0y6kmmmA4h057PNv42xtrF80PUB5d5yLTls3kk/eW2/x3LmmWx+vRxZNNCYdRCVz+7g+MdSqA5U0xnuZJR9FHpRj+WUU1CDQRzVVl6f2IPksFJtqKYp3MT68HpypVxGGUbtc7v/TRyTP4t6XxP13kaOzj1sj++i/zb+X6lfzz333O/dhRi/kN3F4P4CMYDmYayJx5pQHAophMNqn7+wLGvZt3f5Bwu72U2I2O1i3zqTSSQlRU96uhGrVcLhkIiP136nphpwOCQSE/U4HNJ//UhTjBgxYsSIEeOPRVFRER988AFz5szhyy+/5K9//SsA7e3tv1Nukxi/NtGoQnd3hIQE/R52ZhdemE1ysoFAQGH27F0RX7n2bE4smM0XjfMpcOQyK2ff/LpPOCGNJ55oQBTh+OPTiIvT7DK6uzWhuqBg3/O/JCUZME0w0LLeDzIgwEbZwOGCCN7tmtCsM8L4NyHiZvnyIMsrGwF4eumlFGf14HCmgT4ONRpA7t0KiWi+wh0LwFb0Y83vScnfeWz1jXzZU45QPZ9LTYUcnLX/gFVz7DmcVnQ8ITlErbeBI7IPJtGUsEc9h8HOWSUn932u9dSzsn0tSaZEOgNtZIUbOTBUqUVti5qtgCRK3DLm7wTjEzBuvwdhxtPgHAkTDqPaXcuXjfMBqPHU8VnDV9w0+moK7Ll4oz5OKjgGGl9EJ4jEGZzURYIIgsCU1PF7P+70o8C1ljRPPdlGB2sCIQyCRKIxgdZAG9m2zD02cYc9fSIzwGcNX9MZ7ALg3g2P8sr+T2DVa0nXhicM4aXpj7GifQ0PbvwXAEn+InSdY5BMMoOjUxA+fJHcb97nycQ2Nmx7gu78PPSSk+2Z8YxucFNoSUbKlXiptwO9yUtTdy6fdUzh1OJyGDoOSs/YdW1sWSxoWcIbVe8TUSJElQi9EQ+nF52w93MApCTowGonwToIn68BkzVISAlj0hnRqSps/geZngr+JBqg4Ei+alnKI5s10fWDus+o9dTjjXjxRryYdUYavE17iDu3j72Ow7MP4s0d7zP9/S8paF5DTZyejAvvYXzZbARBQFVVNu8m/q7r2ogr1EtvxMPJcVPIlSR0URgaX8pnJTmYdN18Uj+PSnc190+4dVdjW9bCi/dqQvPpV8C0w2gYOYzaLc+S2RolosqkmpOZmjpAhPCmVeDqgtHT+pLnDUgoCE/dpllkjJoKZ1yxa1pu8TDNLsPVBTlFe2ZkR4t6/z7yfUAEAS67E777HBwJMPXQvdfdSdvGDrqrXAD4OwPULW1i8JH7/l2wYqWD1e4pRPwRpKBC0cG5AIxKGkmRupamuHZMvWYsG1MY/3gZRpsBZ4YFW5oVNRzE7wJbqglFCWAwCIw5dghFccl88rH23LZt6mTHg+8yPa8X0xmz0OXcQGTzZnRpaegyMph0XgNf31OOtyOIM9OCIVWkZeQ2dEEDR5x7DMHOEMQnIvR6MFgl/NllDD86lxGztX4OmlWIKIm4m7x0NUWoW92FKAmEAwqpbZmIiAiiSLxPwnnGQzStacDib8GbkknqkERUv58dC9uIhrWkTr21LooTyzELXlrSJlIwOp1QoYVh9iIGXb6MhJQCbBEJy8RDEe12opWVGKMCJZYS7j5iDVHFy7Lta7l01Q2cXHEes+6YwoFZBwIw2jmabb5tJOgT+hJm7gu6xESap11Exw4tYWCKUceinkXcX38/KiojbCO4o/AOBJMJ25/+xBT+xGRVZUl4Cfe47+nbT6/Su89t/rdhkSxcN/Kvv3c3fjX+XwnN/41EdAaumPpyX/mPjqpqYnAgoKAoWjkcVvqE4Gh014+ifJ+07vutvy+o7B5F/L0thU6nicY/FIq/XyYImr+xzaYjPd1IWpqRggIzVqsOs1lHeromEhuNImazDr1ewGLR7Cp0uphgHCNGjBgxYsT4/bnxxhs55ZRT+Otf/8qMGTOYNEmzJJg3bx6jRv1vRvL8f8LjifK3v22noSFIQYGFu+8uxmzeNWXfaBT3asVxWvEJnFb84+LbDzn00CQmT45DEMBu11797r67hK+/7iIjw8iMGT8vaspWcjXDWyrY2LMdIephYlyqJrgmTu1fUe8gr8CAwSASDiu4QmkcddZUgm+3UV8f4MjDE0lL1UF0Z31rwc/qBwCixDe9jSA5UFWV+S2L+wnNncEunqx4kUA0yFklJ1HsLOTiIXuxDhiA9kAHV6+8mWA0CMAdUiul0R0YG6vAvxkmze1X36QEwbHTekCNQsSNVbIgCiKKqolADr0dm97Wvx/5FwFQ5BhG2DmRh51lFDjy+u07qkTRCTotyEXvhBEPkTLIzeBNT7Fs2+t4o15qvHXIikJnsIsFLUvIMKcy2bMEmt4ny1bIzNQxfNm2hiRTIiXOwj6hOapGkXf2DwAljKX9Kw5QFQKlp1HeW8mEswQ2rAuQ5hnOlceVwdtv8Z3Vw+cOF3g97OgOkGxKZPHMyfQ2ejlgwt8h+ARJ1YspGPc2jTvOYYP1AP5yxJ2QuOc77ZrODTj0NnpCLlRgZtYB/aLGB2JSmYmLjnOwpTrMmOFFPNMbZWVHLdnWDDa1fstYT0Xf8dC1mKqgvm/bnpALi2RBEnVEFRmnwcn6ro3csf4hsqwZ3DjqKhJM8ehFPdPTp7B6y+cUNPdo18mtMKayG0ZrEfGCIFDsKOTLxvlYJDNZ1gw+a/gagArXdl4691pY8Q1iThHdzi3oXJpYVuOp33UwXe3wyoPg82ovvu8/izp8PCd/ewFV7hrMkpmDMqbzl2EXMCx+MCE5hPH7iPyFn2hJAAGWfAF/e3iv52zNu0tY/G08gyxFHLpqAUyYAYNG7qoQn7RHJPPPxpkAR5y6z9XtGTZESUCJau/+zuyBZ1XsjYBXRafXoXOK6Aw6HDlxfevGFowg8vUWUEGJj7DxnW2MO28EueOSGX96Id/c2oGgyHRXuXDkxDH2jBJGHJOPp8XXJ0coLS2o7asIVXcTXrGC+BdfxPB90kZgyGHZDJqZRXN5F921Xp7reZzo6wLJri4WtCzm2EtvInVaKe02G06HjoOePgpb8q7BAEEQKD1M+/6rXdFO/ZpubKlWrPEGCovzmThkBL253WQurKS74RVEnZGw3o7sDiPb42kdejxiVwRnpoWwN8oo01pMXbU0uuJpNHzC1yktOHCwrbece81JxGVqz59g1O6fcFI20ugxRNauRqc3EbTG42vxIygCPfVeKr5oZMxJWmS6TtAxxDZkwOtQ7inns67PyDZlc1LqSeiE/lY0+18+lCVPbUMQYPKFg3im93HCgSiuBi/fiN/xZ1sH6am7rFoEQWCCYQJjDGNYG15LmaGMycb+3wmejgDr3qpBZxAZe0ohRpueGH8MYkLzHxwZke3OISgKqLKKomh+wNrMuV12D7DLG1hbP/C6gT6rqhYZLMu77CRUVROCv/8djaqIIjsjivsPcO4e1atlu9a8674XgvV6AZNJS2Rnt2vRwAkJesxmEYNBS3ZnMukwmcSdom9/AVmStChjq1WHXq9ZV9jtWtlk0kRivV7AYBAxGIRYlHGMGDFixIgR47+W4447jqlTp9LS0kJZWVnf8hkzZjBnzpzfsWcxfg2WL++loUETLqur/axZ42bq1PjftE2Ho/8rX3q6kdNPz/hlO5Ms3HLAK6ztLCfRYKNIjIIxFYx7ilOZmSbuvbeEdevcDB9up7TUyvDhu4lI/nugc4HmubsXX+GB2LjRQ2X5VsYW1zHeEs9SbwcAxQ5NrFHa5iO2fcy67irWBs1EBB13b3iE5/b75z63EVEiPLzpKcq7NpNmTsFhsJMfqsH4/XuGexMoERB3EzaS94fOhZqwGTcaDImkCgJXjbiEr5oWUGDP47Dsg/ZszJgIg/6BCAwboC8f1n3G89teJxrN5vzSczgwK5X7Nj5Oo6+ZObmHU5Y4FH80QIngR1x/ERvlEF8LudjVEKOUDZgFAcFXyZ+zkzjzgKewSBZ6wi7agx20+Ns4ufCY/hYOO/5JpH0+23p30Kla6Uo+mq2uSsiDRnEzPbYs5LxUIl2azzSOeLJtmWSY0zBLJo6afQpCwlBYHeWG1ALe8HjQFW8mK6uATaHllPiKSDensr57IyIio5JGMC5pJCvaV6MTROINTlp8bXzR8A2Z1nSGJwwsbAEcsZ+FI/azAPDYV2GGxJUQUsO81jifsYZ4CGvi8BuudtZ6u+kOuUgwxjEldQLZtkw+rZ+HRWdmSto4XtrwPHavnypzPXMTPuXM4pNY37WROIOTE0aeTavjA/Q+HznWTLbZZczeRgLRAG9Wz2Vhy1LiDA4MogF/1N/Xv96wm4qsOKqcoxmbNJJDXWlU9G5HVVUOy5qhVdq4Ep67Cyo3gmSA7EKw2tnhrqbeq80I8Ea8LGj5jnijkxZ/G71hN4dmz+CSIedq231PQxUE/FqCwB/Q1Bbltq/SkF0lfOMqwakLMsn8I9HP/yGcmXZm3DKFhuUtpAxJJGNk6k9vtBsjjiukblUX0ZBMUrGTuKxdxzTtkiFUfr4DVYG4VD263XIgGfQyKflmQikSjZu8GBUTy1/cAaJI2Zw8Jl06mh3zarFa6sj3atY5qs+H4vWiM5n69UEUBbJGJmFPNqKeJxHf6WJ6wyL0dSL+jus46MGHCejHYk0yIxn3LsHlTUjhmIcn0NPsJW9sSp9f9Tr3Op4UH2GWtRXCOpL9mTRM/Quu8aPY/lEz0ZCMM91C9ugkSrq2svD9YmSLjM8lElnayKapmxhqHYoyeya8tQAxMRHj7Dl8efs6ald0YE85kFn3nsM/cpp5xvUSUnMvk5fNBMAcN7CN0Rr3Gp5pfgabzsb5GedzS80thNUw9IJFtDAnpf/fKwm5do68c5dFz/DO4bxT9TFhf5REdypr1tcx67bkftvoBT03O29GUZU9POUBvrpzQ1+UtL8nxMF/K9ujTozfh99VaH7iiXpMJu0/tR8Kn7vKu4TT3Zf9cJvvbRO+j6LdfZtdn/u38b2Aqih7trd7vd2Xfd9ONKoSCsm7Le/fnqJoEbiNjSHcbpnvo3T3RQPV9iP0O2ZB+D6Cd5ew2z8aeODluzyGf1i3f1kUhb4oX7tdwmAQMJm0z5IkoCjaH6kGg7DzR0QUtT7Fxen7ooI1f2IdqakGnE49kiQQHy9hMv1IIo8YMWLEiBEjRowYfaSlpZGW1n9a6vjxPzKVPsYfHrc7yty5bbS3h1GUXX/Tp6Xtgxfxb0B7e4jnn29GVVXOPjvzZ/VDL+qZkDJmn+oWFJgpLNxT9ALAkg05p+9zuwA7dvh54I5lnDfuXtq6IlwyxM7I3NkI1nxKohP58wVLOH3oreRkG8gy1TNJTWCRlEdADgy4v+5gD/dvfJz2QAenFh3HARnTAHi35iPWdZUTkINsd1cxNXUCYvx+0PE1IBB1DENWFYyebSDoNNsP5wgY9RSEO8FW3PfCNS1tEtPSJv2s4/weWZF5fuvrNHam09g7lh0tTYzLrKdX0MTFZ7e/SrwhDkVVOCJUTrzeABEXhwthVkiZKHIYpJ3XNtyDfaegnGRK5KGJdwzcqHcHLYF2Fvu9+IUw3zZ/h9PgwCKZ6Q33ctWKm7A4zYwbXch+cZOpMAWYmDqW80vP2BXwE+kFOUC60cEVRgdXe5r5uOIFKlzbSTOnkGZJQVC1AKE5eUcwJ+8Iqtw1SIKkWYj4GrlnwyPY9FZOKpzDqUXH/+h5WtK6gi2ubfSEe5ClCC1iHe+WnsFxulSW+r28XqNFGNv0Vi4Zch4HpE/hu7YVXDDoTF7d8TafVH3Ktq4tlIRMOHokBFMdN3c+zAbvWgRB4C9DL2TGHfN4Y8G9XONdSlfofdKXLCGsRJAVmQZfIxmWdOKtcQyOK2FD92Z8UT8HpE/l76tuRVEVXje8x7+m3M8zUx8iIAfJs+donV/+tZY4L6sAWhpgyGg47kIceok8ew7V7lq8ER/pljS+alpAIBqkxFnIFzVfcPTX68naWgXuHohL0qKTBxCZATp6ZGRHAqQEwO+hdfzxkFu87zfjL+CpiheZ17SAQnseN46+CttOT+sfkj4ihfQReyaH2xeK9kvn2Ecn09Pgo3BaWr9kgvZUC7Punczm97fjyLAx7LiSvnXxeU4igShySEYRJQw27TnprvWiqipVo7fSOKSBg9xj0N2xBrW3F+PMmeiSdg2qKbLCl3esp6PSzaAD06j8dBsp1enIbSpRwYjTbMBV56LlleUM+tuxSAYd0bDM9vktSAaR4gPSEQSB3hY/9as60OeqPGK8l0Z7IzM7ZnJB8oV8edt6Vq4uxzd4JPNPkxn0qJG27AlIUTPubxsAHZJRhzPdwhG3jaHtKxE+fA9ZDiMYTZiiNqJqlCHWIQw69QrUEy4FSaJ9ey+1K7Sof097kMr1EcYOnshY60Sqh7SxrbmZpEI7g2fuacUDcH/9/Xh3+sU/2/ysJjLvpCuizZZQFJX2bb1Y4g040vrfl4cnHc7qdQ20hzoobhpOKHvveQcGEpkBPG2BAcsxfn9+V6H5gw/akST/T9bbXXDdtWygerv/Vvda74d1d6//Y9vsXn+gPv2QcE+IDJPK0GTtj0lx5/+74m4isLDzt36nLUTEFyHijSDuXKdXIxzU+SEAS9OPBkmPbrftvv+NIGj7FQQkQUuOazTrOPFfU/qEZ+3n+0jhXWVBYGfEcCzAPUaMGDFixIgRI0aMX5s776xm82btpTw/30RpqY1x4xwUFe1FhP2NefDBur7+dHdHuO++0l+9jeeea+SjjzrIzjZx661FJCT8xLRmXw34qiFuFBj29E8GqK0NkGptwKALoyoQCUQ5LD4bUmdwzz01uHoCKGKQyvZOigudJKhWbJKVPw0e2DLj9ar32Ni9BYB/bn6aiSljMUtmXKFeJEFiaPwg/FE/d469HmtcITS8wbqONdzZ0cD0Lw/kNIuOOIMTcs6ArOM1W4twF0S9WvnfoMpdwy1r72NtxwrC7vNADqEPd7GjK5vk77UuVeWO1Hy8TWvIFHqx6uLZLllokgW2SRmEHDas7jVa1HnxFfvWcOrBvFi7kM/9UdqQMJj9lMYV4Q57sErWPhuQT40tOGUvgl8gEA3SE3KRYNoZna93QvrR0PIhvYKZD3sq6Qy7kVUFj+Slo7uTIkcBVsnCe7Wf8GHd50SUCMlm7cBMOiO2nZ7R8xoXYNQZGeQsZljC4AG7/NiWZ8mzZdPl6mJUe4STKz3U178O5y7F27Sgr55B1JNkiueOpS+xqHYzSlwNrkgPuboECkImnLJE2uoJvPv2MNZJ7RQcl0zCkA6Wtq/EkWXjBVsD60K9iD43RtGIO+oh35ZDvDGOiBImwRTPGcUnkmZJJapE+bDucxRVQVZlajz1fNv8HbPzDu/f+awC2LCMbjVAeaaOuSPDXGMVyGzr4dG0s/g4s5YvGueTaIynNdCOT9X0E0N7K7YqL4gSmK1w1tUwcu92I8OKDIwoNlJOFulJOqafPvAz9muxo7eaT+rnAZqFyGcNX3NCwezfpK2cscnkjE0ecF3hATkUHqCJ+nJExtfpx5Joxt8VIBqKEvaFyRxsRzDq0Jt0DDokky+7v+TxxscBmK+z8eS/HiOw1Yu5qP8A8EfXrmblS5UA1CyoJ6PIiCnbgE+JRxRLMUTaaO8wsGWJnvbHtnDgFcP56u5y6la1EzD6GFs9iLHHF/HeX5bRutlFT9BF12UR1P1Vvuj+giFrJtBU3o1TF4d5XTKtmSXoMrIYah2KKIg4Mk10NGgCbf6UVGpXtFO5ViThiOl0tbTSlbyG+INsTDZP5qqcqwAQ9Nr3sCXBiE4SkaPa82xL2eXXXzA5lYLJuyLLVVWlcX0XBrNE6qA4bT/silx0Sk4OTjiYr7q/IlmfzBFJWiLTr+5cT+2KDkSdwCHXjSR3fP9rdNoxs1nw0CZEg8CEs0v4uYw5pZClT29DlARGnfAL7Jdi/Gb8rsriI48Mwmb7301q8urpC1Cb3Ni7Bo4QiASjhLyaMZkoiUgGEYNVQm/SodOLiHoRoxDh6PVaEsOOIUcR3TndY7dA5b2SMdzZL1t1jBgxYsSIESNGjBgxfjuiSpRtvTtINSf3SyxWXx/sK+v1IpdemvOrt62qKis61qCoCpNSxu1pJ9f+NXQsBMdg3O5dU4x7e6P82jQ1Bfngg3bizR0U6pez6tMiZp52yoAJxgDYfj/UPAmSA5zDoewx0O/p1Tp6tIMP3h6EL2IjwebHHu8AxwhAm33ZIet5KQoz7T20BxUmjP8n56ZO3Gs/dz9Hws5/ALPzDmd15wY6gp2cWXwSxXGaR6mccRL3Vs4niI7B0Waa/Xri9A6ofhx6VkOgXhOZJSsMvRuseQO2+3LlW8yt/ZRMazo3j75mjyR0AG9WzaUn5KLE5GSLt5pE8snRwbjECIbk0ezw1DJDLxPX9iFZoVrCyGz3dbBSSMJScjmP5c2hJdjNvK6NFDtLMCsS22o/Jd2cSqY1nUp3Fd80LabQkcdZJSfvihrMPI5N1nfZ5llOSFVIlP08MukuVFRqPfXcuu5+FEWhJdBGVI3Q6GuhxlPPpp4KnpzyADpx50zW/PMg+2Q+q/kMuf5u/NEAESVKhiWNRGMChp22I96ID4fehk7Q4TDYuXr4n7lqxY00+JpINiWyqaeC7lAPETXKpOSxZNsyObFgdl/yQlVVafa30uxvJSOk529L2kmV/Ri2hWDQl0yfdACLW5ezsWcLk1LGIbcN4uUnW7H2JJCZkIE0631IsJBhSeHurXbOrRhPrwOMsoWWxXkkDOlgWPxgXKFedrhr8EZ9CICiKhyadSDbXDsYlzSKi4ecTbIpiRRzMqIgYtAZGJNUxpvV77O2swJZVXh660skmRKYmrbbPXnoiah2J68svYflxaV4PXWsfOlq5mzpZRQw6pDjOXjCrTy+5TnSzCmUxhUTkkMc1lVInLxe24fVDsPGgbR3eUeSBG7/czzdvQpOm2ZH+Vtilsx9yRIBrNLvM6j2Pd52H1/+fRG+jgAZY1KJBqOY40yY40wIOoHD/zkJS5wRs9PAx027/LO9YS9v37GUTy3vExL9zNp+OAnhBEacWEpbhauvXjQq0KF20BxpRCmSee1yA4c+ejZuORlZMtFdow3sNVd08vHEl2lIqeKjUDKnXHsxdYtdO2fOCzhfKMI/vRVJlBD9enoafBgseobFD6Nk6kT8dSF8dQEMNj0HXjsGvytKT6OPumXtLHxkM440M4IoMOPqg5gxbgobvRsps5WRadIikwPuMCte2E7YLzPuzCI2f9JAXJaF5Klm/M11yG++h2AyYT71VJS6OgSnk8VzPWz/phmAieeUUDYnjytzruTZ5mex6Wycm3Eu6cZ0zss4D7OoXfegJ0ztCs3WSJFVtn/bvIfQXDA5lfxJWiT7L7E/HTYrh+L90xEloV8ke4zfn9/1agwaZMPhGHj6xP8CKRaQc619o0OqqhL2Rgn0hgl5IhitehzpFpIKHGSMSMCRZiaxwE58thWTw4DJoUfw+2HnKTrv/Rlg/f19lGLEiBEjRowYMWLEiNEfWZG5Yc1dbOquwKAzcNuYaxkSr0UKH310Cq++2owoCsyapb1sr1rVS29vlGnT4jEaB54a/HN4ZtvLfFz3JcAu/9bv8dXAjkcAFXrXc9nJDm58NBtVhXPPHXhq9L+D2azDZJA5c+yj2A1usixLoMUGGUfvWblnDTS8AVEPYb+b5kaRVRtWMPuMA/B4lL7cLAAJCXrueWgCTbVPkRNfjyGxtM8f+swzM6iTtzFXTWWbPRebQcfpvlaGKVEINoMxBXT9g3BOLTyOtkA77YFOTik8FpOkrU+3pPHcfv8kqkSRRIkFVWu587mlKFVFKDOMWHN9NAkOckUZQq0gB6FnJXgqwFmmJTnsWjyg0Nwe6OCdam3Gap2ngQ9qP+O8QXtaiMQZtYhoizmDAxO/41ShE1cowJBoHdnSUfxFiVLXs4XtkSpG6KLUR6O4BRM9UjyftKzCYi3kvO8uxx3xoBNErJKVFFMSbcFOihx5+KJ+gnKIrmA3b1S9z1NT76fAkQ9Aij0Hfcd69ECCMY5tvTuYnDqeJFMid4z9B9WeWl6tfIfNPVsBkESJBl8z79R8SJEjn7HJOxOXSlb0khEBEbPOhCiE6Q71cHTu4czM2p9kUxJL2laytG2l1q4pmVvW3YdO0GHWmci2ZmEUtaCtHb3VdAW7STOn0Bbo4Nphf4bXH2Fhw0I8mfWEjFDg1zG2Q4cUChFW23j9i5sZMSSX28Ze23de73vRRU5XBNUbwO/O4E+1WaROPpMJ00Yzr/JTdlS1EWhpxSpZOKB0KBeOmsbElLEsbF6KXtTj0NvQi3pOLT6OS4eejz/qxxXs5e+rb6Mn5KI0rog7x16PQWegwJHHLaP/zkXfXYl9p5i+trO8v9AsCAhTD+Mr38tUu+sw+gzkVgSBnaLc6gVMOuoMJqWO63+DFPWC6yHobodDTwKTmZ9CEAQS4/bB0jIUhJ4OSEr/UfH6x8i0pnPZ0Av4qmkBRY58Dv3ek/p3omp+Pb4OzV6heU0bOVM0n3qlsxOnvw798+sxXnEFYOCghIP4tudbvLKXkTWTWdy0hLpxO8hcmcXG7ZuZmDKeNS9sYujhpbRucRHyRsgam0rkeg/l5U0Ei3zICRHiTyij551uBEFg8GFZAIgzvDSoVagqtNHGKmkZcYFiUMFkMWF0JJFuHcOBxoOo/rATQQRvR4BJR5dy8KQyoqOjdFf34siwYXIasacrPPrCy6xxLsNQaGfm5lFYsjNwtwUYHMkiPym/n4i75MmtNHy9leyGeTR6IoSGHMGSOjev3voiwZIvuWZ9JsU9NgJvvQWShGi14uqdDo7hANQsaaNsTh5jHGMY4+hvoWTR7RpMMNr0xGVacTX5AEgpGXiGhyAI9Cq9rAutI0/KI0/K+1nXNZYA8I9JTPb/jVGBoCeCrzNIxB/F5DBgjjMw7MgcSg7MIGdsUuzhiBEjRowYMWLEiBHjv5zWQDubujXPy7AcZlHr0j6h+cQT05g+PR69XiAx0cDcuW08/3wTAN98081dd/37XqlrOjf0lVd3rO+/Muphd6vAQYUKb72lRQL/Fom0ExL0XHNFEvbtfsxmI2lpBvDXDFxZDoDegeIX8PujdLqMvPWtkbnfbMbjiZKUZODuu4tJTTWCrxZrqJ2SwSNBzO63G4tFx00XTcG1/HOafC2YJTMTEobAxis1Sw5DEgy/H4yJLGpZyuaerUxOHc+tY64duF9oAuqGrk38dcEdNFuCMAySy8dyYFEyQvpYMh1J4N4Anq2gyppfs7ozSZ61cMB9GnVGJFEiqmiR5N9bRIAmPIuCSLYtk7OKT0JVVXrCLo7NupnGZSdSJPkJy9DY+CG9upGs16UyVG4nV5LxE6YWG9+KaWzvqeCqlTcSlINElAhhVUUUdDT4m3EIAgdGqvCEXHwk2/FFQ6zsWMvJ317I45PvYWzyKC4bcgGbureiqArJ5iSq3bV82/wd45NHc3DW/jT7WukJ9RKQQ9j1NrKtmXQGuni18h3NDzZ+EGUJQzku/0iOyjmUO9Y9SLO/lagqI6syLf5W1ndt5rax1zI2eSRZ1gwiSoQDM6Zx6dK/IwoiSaZEhsaXIok6WvxtRFVZsykBmv2tsOIbWPktL+RU0hBw4VN0dIZFIpIeIRgkKgq4hQjPb3+NByfe3neOS3L1OFU9Eb2VDmcrH9iqELe9gsNg5+22rwkdupXw8tFYrRYevPZu4h2agJtpTaM0rqgvQnf/9CnafSdZ+LT9K3pCLgC2uXawrXcHwxOG4I14afa1UBw00uluR4hPZkzSngnLwnKYqCoTkINE1CiBnEK6KxsJy2GcOeMZUEK2O+FPN+/13v3FdLXDQ9eAqwvyB8Fld4De8It2dVDmdA7K3PdEn78lttRdz5moFxlzznAyhsbRfdu9ZKV241oqIqa/ge2iiygwF/Ds4Gep3NTAihfr6ajcRFHtRPy5jdojjoqoExh3ejFF+2cSCUbJHpXEu6+K1BveQ/SqzMiZxozTRzP2AD+iJOJM10TYg08bx1urEogqUdq3u3GG4skYkUB3nRdboomZf51MWXEet669k7kHfMbw3AlMqZjZ53EsGSVSBu+aAdHobuKzQW+BqnDisnoG9ywg0Z9D7TvnserlJDJHJHDYzaP7EiH6e0IUVL+P3VNL0B3BWuVnSdZI9DV2uot8fF7QSsFndiKbNyPabOjS08mJr6QdTWhOG7pvyWsFQWDWnWPZ9nUTtmQTJQcMnIDWr/i5wnUF7XI7OkHH7Y7bGWYYKC1qjP8mYkLzb4Qia1437uYA1iQj8dlW0obEM+qEfLJHJ/XLeBojRowYMWLEiBEjxve88sorPPnkk9TU1LBs2TJyc3N5+OGHyc/P5+ijB4gIjfGHINEYT4Ipnu5gDwDFjv5C4+4J9zZs8PSVN23yEI0qSNK/934wNmkkH/m+0MrJI/uvdAyHpP2gczHYSyBlxm8iMO/OuMl5kHgQdC8D0QjJBw1cMXESpB5KKGxk+SYzL6+5hG63iZ46H1lZRjo7w8yb18Xph9drorEqQ+JkTTT+QZIos2TmwYm3sb23iixrBkn+ak1kBi1JX/dSXt2RwA0r70EnCXxcOJ9nDriPTGt63z4qerbz8o63aA90EFVkPBEvSFEUMYLHXkvU4KfU62WOZMccSIKiv0LdS9D1HdgHQ+ph2jElDuyX6zQ4+FvZZXxc9yVZ1nSOyZsFwFtVc3l1xzsAnFN6KnPyjuDPQ88DNEuWefp0JoerAOgxFzAn0o493Mx6Qy4jJj1Bst7KS+WPU9/yHfGGOLpD3RD1YkFFFiXMOhOSqOMisY3pog7FpJIT7ua6iFmLNkZgQcsSxiaPoiSuiH9NuZ/Nrq2YRCNPbX0JgOXtq9nQvYkHN/6LoBwky5qJQ2/HH/XTGewiyZRAlbuWBl8zlb1VNPtbuXbk5QxLGExPuJe2nec0IAeJqprQbpEsnF58Qt/5mZN3BHNrPyXJlMiJhXOQFZlNPRUsbFnKR/WfE2+I55i8WXyw+jMmBtvp1EURAVlV6LSb2JSmIzFgIkiEHdmJ/YT8Jl8Ln0j3kDLSj65FpW34MtSkNFRVZWHLUmRVRucIYDl4MWm2bOZ3fc1QuZRB8SUUOQv4e9lfWNWxjrKEoSiqwtvVHzAheQy5tl2DHgadgTRzClElyt9X3UbasmWcvXoHvelplMSnUnro2D3uCX80QKAtg0JTImZnL6+OSyHF0IKgmmkr7uTRnZH1/xHWLNJEZoCardpPyYjfvNnuGhfLH1+HqqhMuHgUScX7JmjuK4UH5BDxR+ja4aJg/2zsKVasB2az7Z+tfFCeTjhqJFPs4rjzFHSSiFVnJbJJO+clWQVsdgVpHL+OYVnFJIcTGX5sCQarnrTBcQTcYT65YQ1Vn3g4PufP+G0eTr70EMRCkfjs/jP4s0xZ3FZ2C4tdixG77Oha02kRW7GNMCO0Qd1j79NRsZHPsj6iOkehImctlYXruW3wX+i99nmU1lbEw2azyVWKKInEHaViTzejr3AxqDVIfEEKcWERqXwZHsdB1K7soHF9F0kjjGysWUDOnBxC7/gQBAGHPYKrrZ40uYTKQ1rYnq3QpW+jMKuXg5viIBpF7uig9G8HYEkYgt6so3Ba2gBnd2CsCUZG/4R3coPcQLvcDoCsyqyLrIsJzf8DxITmXxk5olC9tI2lT21FEAUyRsRz+K1jyByREBOXY8SIESNGjBgxYvwo//rXv7jxxhu5/PLLueOOO5BlLToyLi6Ohx9+OCY0/4ExSSbuGXcjC1uWkmXNYErahL3WnTDByZo1bgDGjnX+2yIzwHmlpzNipwA2MeUHYpYgQMnVUHzV3n2SfwVqPfV9IuTFg89mVOm1WiSzPh4MewpHqqryRtVctnvhwKE30libQ0DupLhYT0tLuC96NC3NCDseAt8ObcNIL5Re12ebsTsWycLIxOE7GwiCIMFOUVM1ZfHU28vxp2rPVU2dl7ZAez+h+c4ND9EaaGdZ22oMokSBPQ/BrhKXIhKJGhiRa2ecuh1fJBubFNhpkZEPQS1CHfcmKLlyZwZ5GWqfAV8VpBwMqTMBmJgydo9r9EXj/L7yl43zmZN3RN9nSZQYP/p+vq14hETJwonZBzKl4SU8+kRm4OeV7S8hmLO4ZczfMK03Ud69mTg1QL7RwFEWE92ijeTCC8lwFFBUfT+2aDep5hRyZYWXu0KoKiQaEyh27hKFBseXMDi+hPnNiwDoDHYTlIO8XfUhnoiXsBKm2lOLQ29ndOIIWsQ2WgPtBJUQqRbNd7XZ3wpAjjWTkBwiqkSJyBHWdZZz1fBLBryHzik9ldOKjkcv6lnZsZa7N/yT7mAPXaFu8uy5RJQIr+54B1u8kc6UCCVRK60mK6oUJMmWxctHxnFol4XP5B2Ei3L555Dz+vb9Ts2HJHg2s2N0NRWBKH6jk7DeTwEwOK4Em95KVI7SG/bQHGjlT0uuxiyZeWDCLRybfxSTU8czOXU85V2buX7Nnaiqyrs1H/OvKfdx9dCL2e6tZUrqBJLNSbQHOqjzNDC604NJEcjulskP+wn3eqhxW8hIlrBbtef+6ddVXItPoy3QxvAD15MwEtYO2hkBGuzAHfbsSrQ4AItalrK+axPjU0bv+ez/XNJ384/XGyAxde91f0WWPbqWrkoXAEsfWcNRj+5lYGonHVVu1r1dgzXByLgzijCYf1raGnRE/8E/0Wrlg8IshM0SEYvIWn+YA6tcJJdqiRIzyxJY93YNBqMeMsMkj7exxbyOIb5iPvpTPUF3mPEXluFx66hc2EJvsx9r0EhSUdr3XzkDMs4xjnGOcbSktnBZ8WVUb2gm9fNBHLwsjSTf5/g6uvhTvI/rr5Botcn4hney/pObGL4xDUmQaP7HA2wt/CtRvZX8tlROPf14vkr4GPNXHmydTsLhKE1tVrp7vOj0ImHZw2WvHUSj3IpBZ+KBB24g/um5RNfWYigezvGOzXwitVBpTyclIZU3rQ3sF03H0uJCGjwY28knMnAazp+PGgrhvvceNlZ8xPJpeiKnHkWSmESn0olO0DFKP+pXainG70lMaP6ViIRkKuc3s+jxClyNPoK9YXQGkeMemUTOmD3/AIoRI0aMGDFixIgR44c8+uijPPPMM8yePZu77767b/nYsWO56qqrfseexdgX0iypnFg45yfrHXZYMnl5ZlyuKOPG/TrJ0Xt7o1R8lobZrGPMHBWDYaegrKrQ/AEE6iBlJjh+HcmgtzfCO++0IYoCJ5yQis0m8czWV6jx1AHw8OaneGn642AdOKLNFerl4iVX813bcjIsaaztKudfJ9/PeeeNBKC83MP8+d3k55s56KAEWB7ZtbEaBX3cT3fSnAlDbtWiqh3DIG4kCd0ejHHfETK6SIzmMDR+UL9NuoM9rOsoJxgNoOgMNPiaKHUWkZXtpECJJw4Ve1gmXg1q59aUqVlnfE/UDRW3QM8aasM+XnF1UGq0coJnO52GTB7c8QE9IRdnlZzMhJRdHqeFjjw6g1195R+iiZyvah8a3wFRIsEYx7qujWwJrqVZ3IGKytklJ3Nv+aP4Ix1cklrIJIud9UEftzXNJ9y0iKMSxnJ+dDOoKpnFF/D1+Cl83byQFFMS+2dM3bPdlPE8LDxFtacWm96GosiYdFp0vk1vw2lwIAgCpc4i9kufRKIxgY/qv0BAYHbu4QDk2XOxSha66UEVtMSLr1e9x6HZA/v2GnSaVcO8pm+JKFH80QAdwS5y7dm4o0Ga/S3Y9Xbem1bEKUXHMtOUxPzmxehEHZmWdF5tnA/kQ8RHZ7CbFLPmd5yu+pkUqeC2SJhEHeTYSkHv5OoRf2a/9MnIisyoxOF81bSQF7e/AUAgGuCjunkcm38UVFfAa49Qrq+iIasb1WKllATU2y9mv94A+5VNgjNPBCDBGE++PZfyom4G13XiNDgIDp7I1U9HqW3uxmEVuf+KBJLjdSxeFyTHlkWGJY3x0YnMyqtjs2srsiKTYUnn88ZvKEsYyrCEPZ/djd1buK/8MQC+bl7IgxNuo2jngMGK9jWE5BCTU8fve0T08PFw1lVQuw3KJv9HhOb2QAdPpD5He1w745vGcYh8wI/WV1WVz29aS6A33Pd56kW/7Hutc1oCoZ2Pr9koYEnc5eOeMSyBOQ9MYMvWHXzlKEc1awNUmx+twtmi3VNL/rkGY04Ggd4oJrseRVEpmZFB/uQfP28hb4R5b65E9MRjK+7B0GnFJLSiM+hw9CTS6+gmqUvB7TSTYU4nKrSgqCoIEAkpqDsHDN3Nfi7Oupijek7gG75AUdbiDyi4M8qwqnos8UbqK1fTKGuDPmE5yBJxE6c//TSuiy5CM+GQKXOOZLlJS/gn5RdiP/dUzCEwHXHEHn0Pr1+P7+GHQRSxXXkl+qFDkTs6UH0+pLy8Hz3u4Bdf0L78SzzRBoZ+AO+M/oqTRvwNSZDIl/IpkH48AjrGfwcxoflXYPNnDSx+bAs9DT7C/ijODDNxWRY6Kt2/d9dixIgRI0aMGDFi/BdRU1PDqFF7RvQYjUZ8Pt/v0KMYvxWDB/+6SdFvvbWaykrtHmlvD3PppTsjE1s/g7rntXLXEhj9HOj/fXH7rnt2sHmjllyrpSXEP/5RgLiblYXIrrKsyLxe9R4NviYOzz6IkYnDebvmA7b37iAsh6nzNJBgjMMd9vRFF48YYWfECPuuBrNP1OwvlCBknQT7Kpw5h2s/gABcd9kInn7+KnRxPm44exRGnbFfdYtkIaJG0Yk6BEFEUVVMOiMqKkadkQecIinBUgyRbjCnQ9aJmj3HtnqIeiFxGnR8gz8aoL17A4GIkef8vRBxsXbzs2z2adPE7yt/jLdnPKeds87vuCoxm0VyK6mecoaYQqCEQdQE18Wty/i47kty7dmcX3o6YvJBVNe+jj5QzzISaBa169kbdlPkLODpaQ9BsBU2/wNC7XysxBPe+er/UXctZ+3/HHpBB4Z4EoATCmb3P2feKmh6FwyJmHJOY2LKWKJKFJ2gwxPxYtQZafG3UeTI55i8I6hwVZJmTuGskpOwG+wckzcLURD7Ehrm2bIpsOfS4Gsiqsh4Iz56Q3u+K6uKwqMbH+HbtjWUxBVRaM9jW28lvSE3sirjCvXiCXsxCAbaAx0YRQMzsw7EF/UzOmkEKeZk5jV+y5eN8+kNuwnIQdoC7buScqaNo6U5kYxAN+sCEUzeBv4x5gz2S9dsTnSijgMypmHTW3m35iN6w270op6RiUO1Dr75OLQ1kurbjl0Msy3DwXHVvcR3p0N9FWxcARVr4LrHkRJTuWvc9azJ30DKDB0JqpP1wVxq/9ULgNunsHRDkGMPslGYJVHVqNljDM43Mi55NI9NvodN3RU8WfEib1a9z9vVH3D/hFsodvaPym31t+86f6pKa6CdImcBr1S+zdvVHwAwNW0ifyu7bF+eFo2x07Wf/xDv1nxMtDgMNQIri1fxl0PO+9H6SlQl6N418OTvDv3iti859gIeDz0NdSLHHnkE1iRLv/XJRQ6mF42mvOEA5rV9RdGzw7AvTCTsDWOw6omGQBdSCPSEEASB/S4bQtkxeYhi/5kjQU+Yb+7bSG+TnxFzcqle0kZvuUictwDdZBPqoWEU71TU+noS4qIUTjqflCNm8VbPe7RH2ik+4xSs+nqU5mbkcXPYuLCWUDjE1IO0e7unzkfAlIwx7MLmrqPN7URXXIKjJIWh40twzDfilkIIqsDQlHFImZlYL7yQ0GefocvLY//Tz2Vzx7O0hds4LuU4EkcObP0D4PvXv1C6tEEx31NPYT7pJLz33guyjPHww7FdfPHeT7go9vu/QZEEEnWJjDX8m5H4Mf5QxITmf4PeFj+LHtvCls8aiARknBkWDNZf+ZSaTPDtt7vKMWLEiBEjRowYMf5nyc/PZ/369eTm5vZb/vnnnzNkyJDfqVcx/htoaAgOWCbU2lf0e3ysX1TH0LGDcDp/WULysBzm8uX/4K2U77CWFTK8/FKamrT2Lhp8Fo9sfpqgHOKCQWf0bfNR/Rd9oteazg28sN+jiIikmJLoDrkIyAGmpU5kUNyPJEXMOhEcIzQB1vnLPWMnTIhjwoQ9B3OiShRREMmwpjExeQw7PLXoRYn906fQ5GsBwCDqSYx20xHxIQlWUiQngijhMaazIetiHJINZ7CObPUrLdmfaKALA1UhL4+qOrpCK8m2ZWIQ9aiomjVI6ydQ8xSNgV4SXOsJSXaqg/WUWHIRso6nO9jDAxufQFZkKlzbSTYl4o34mOszA6WEpQhmUYdNsnJy4THawTTVwievgCkPDjiBTG8DNGjWHCnmZPQDWI6Ud23mue2v4cTA9W1fYpD9fdGsMzL2Y2XHWmRF5tDsGfy97C80+VoQBYHHNj/H0vaVuMMevm35jqtGXMLk1PH99n1Q5nSa/a1s6tlKR7ALVYBKdzVNvhYUVaHF38aI+EFUbbiWTys/RkZgka+JxbrldAd7iDfGAeCPBukJ95BvyyXfkcuwhMG8V/MxnzV8jSiIXDn8T+yfPoV3aj5ibdcG4g3xvFz5NpNSxmGSTJgSJ5KRPpN211xKLXYEayHuiHePczEueTSv7f8k79d9yoj4IbuEeFGHCsQFolzYYOXpwcVkpznQ1TWDtxf0MoTaYfk3cMQpWPXWPhEbILNbxmQQCIY1S5iCLO0ZvO2SBL5eESDOLrL/WO2dP8uaQa2nHnlncklFVajx1O8hNE9MGcPcukwavE0UOfMZmzQSgLVdu5KDrusq3+MY/0hYJYvmdzwsCYPOQObgH48G1ulFxp1exKpXdmC06xl5fP4vbjtLyeJM21mIZQKDyor6reuu97L+nRpMTgMXnXYxh9UdydKmtYSHRGjd0IHRYSRldBaBgA5LvIm2rS52LGqlflUns+8fT1LBrgG9De/V0rhOE2eXPr0NUSdgFI0MtQ2F3iJOvHka+mOthF2HkZwQRUxPZz+djv1SD9zVoeu1X8sbHqfmwIUgwtvWJcyRDyZvYgrr39pBQvdmRAfsl7uUaL7A4IeOw+w08FD4VZZsfJvirPGMnnAqAOZZszDPmtW3+6tD5+N94glU9wdEznCgHzawV7Kwmy4lmEyEvvgCdtp8hT7/HOuFFyKIA9tBmQ49lNSqKjo2f8zqaSZmDDopJjL/DxITmn8hFV828u1Dm+isdGNJNBKXZf3pjX4JOh3sv/9vs+8YMWLEiBEjRowYfyiuvvpqLrnkEoLBIKqqsnLlSt544w3uuusunn322d+7ezH+wBx9dDJvvdWKTicwa9ZuQmLqodC5EHdXB3MXlfBueZiUlO08+uggLBbdz27n04Z5zK39FNkh0yZ1kNgznCuO0SIQM63p3DP+pj226Qp295XDchhvxMuJBbNpCbSRbcnhyMzDOLJoYBuF1tYQL7zQhCgKnH12ASkpxgHr/Tt81biAJyqeRy/qObnwGEJyiFx7NpcNvYA0SwoPbXySnrCLM4tP4r3y6ynxtaAiUJ5gZj85xNUrb6ayt5ptvTvIs2dziOjlWGcqGxwJvFK3krAs0B5RsNPLROtYJEHHWSUnoxN14KkAYKm/l0GqDKpKb9hNb7CNOCCkhJAVua+vgWiQBl9T32ejzsBbBzyLQWfYleDx6dvBXQ/FW2DZ65xRMBZb/uH0yFGOzj1swHPwl2XXscNdzSlbPITSOzHoreDugbQOJuSP4ckp9+MKuyl1amJcuiWVq1bcyNdNC+kIdqGoCvHGON6oen8PoVkQBI7IOZjb1t2/c4mKrMrMa/yWD+s/R1ZkCkwO/O0LWR3wYEQlHKwg0ZqDQWfAE/GiqipplhRUktjSu50EYzznl57BKzveAjQhdl7TAvZLn8y45JG0+tsA6Ax28VLlWyxuXUaWNYMrh12NrrUJ607/b0nYUxJZ2b6WlR1rOSL7YKamTdy14rS/ILz5OMHEKC8XeTHrzZTNvhpsiyG6EQoVSN0OcZ499gngdMqkHPg2K8rDTBmUwsjS0wCwW0XmxK2Dt56ATyxw3rWQXciIhKGkmpNp7PZgF5MYk1S2xz7tBjuPTLqLnpCLhKiEbmeE/rikUezorQFgfPLoAfvzR+HEgtn0ht20BNo4Ju8IrPr+2oq/K4DOoMNoN/QtG3V8PsOPzkGUxD2ih38Oi+5dSfNaLSrcVedm6hXj+tZ9ftNavJ3aIFo0JDNohiaAG8x6ciZmcNCtU6hd08PCR7agKiq2ZBM6SUSOKDSXd/cTmn/ojV9yUAYVXzRi0pnYb85oUo2pkAPk/PRMF0mQUO3RvrKIiDnJxPFPTqPpz0OoavqSqBClYlKIQvvlmDGQNXw/Thy+34/u1/fcc0RWrADAc+edJLz++oD1bH/9K76nn0YQRawXXUTwq6+IrFsHgC43d68iM4Cg12O7/HImcjkT91orxn87MaH5Z9Ja4WLBQ5uoW9VB2B8lsdCOZPz5f6DFiBEjRowYMWLEiPFDzj77bKLRKNdccw1+v59TTjmFzMxM/vnPf3LSSSf93t2L8QfmtNMymDEjEaNRJCFht2hlcyaMfpbPX6vk3XJtinl7e4iGhiClpT8/WMYXCaCoCkaDgEEvcdLZDmaMTfzRbWblHMKy9tW0Bzo4NHsGGTvtMQ70n8v9D9fxjKyiu6iDww9P3mPbBx6oZetWzRLE5Ypy151Fv3pCwxcqXyeqRIkqUZa2reTJqQ/0W3/HuH8AWtTz7XI8yYaxRASRQsVGga+ZJl8L3aEeIkqEyt5qqlCxBJspltspVA1sBnxRPyoqJxbMZmbWblGKSftB1xKSDXYWhVMYLyj0SgmMyNK8ftMtaZxQMJsP6z4nx5bJ0bmHUeWpobx7C2E5zJE5M/mmZRHvVH9EmiWFv5f9BafPDTY3YUFFH4kiRVyckJCjtTUAnrCH7e4qokqU+G4f7SE99mJYGozQEnWyf7CbNEsqaZZdkabv1nzEotZltAU68EcDWCQzbYEOOgKd3LD6Lv5edlk/wbDWU4834kNFRVZVvBE/m7oriMgRREFkjauaroCHoKISBOL1egw6PSWWQrwRHymmZCRRR6u/nTxbNmnmFOY1zSfPnkO1uxaAAnsu5V2bWdOxgTpvA1nWDLJtmby8/U08US913kZKnIVcVXY5r1e9h1FnoMiRT0/I1Rc1Xe2u5fb1D6CqKl82zifO4NzljZxVQPefr+eJN49B7GhB6u3FPFKEY0+G5HfB1QVmK6TuNqNgN75t+Y563TLSR0E1sLZrOGN2RiDXvXs/baqLsm4rxg9egEtvx2Gwc4bjFm59uxMvJt4LS1xw3J7Xrra3loJ33kS3pRzSsuEvd3FK0XEMjishKIf6eYHvMws+hm3rYeg4mHroz9/+Z2CSTFw27IIB161/fQvlb2xF1ItM//sEssfvStwpGf59Haa7undXuWZXWVFUfLtZcvg6g6QMSmTSZaNpXNlC+sgUFEFi44f1xGdbiYZk9Capr18ZIxL6tTPyuDxcDV5cjZp1xuCZWQyblY3OoMOZ3t+u46c4Je0UuqJdtIXaODH1RMw6MwBGq54d9x3Nos82EnBIbJ9sZ3xkI1ONe3qvD4QaCOwqh0Koqrpr8Go3pLw8nHfe2ffZcsYZiElJqL29A3o6x/j/R0xo3kdUVaVyQQtf3LoOV6Mfe6rpt4ti3p1IBJ5+WitfcAHof9kUtxgxYsSIESNGjBh/bKLRKK+99hpHHnkk559/Pp2dnSiKQkpKyu/dtRj/JaSn7yXaVzQwZGQO4rs7UBSV5GQD2dk/bcvX3BykujrA8OE2olGVN99sRRZGMSyjjIZwDRmWNM4acuxP7ifNksqz0x4mJIcwSbvaffvtNqJRBYA33mgdUGju7dUi94j66K1cCiv+DvkXQuohe29QDkLHfPBs1/yZk/cHYTdRKtAEohF2WkjEG+LwhL34on5CcnjvAosocVDmdL5uWohO1HFw5v7Mb1pEraeWiKogIBCUQ6QQpFTxoyfKcSao8BtAEMiz51Devbm/0JwwAUY+zmHhLvTuTmoC7Zh1Rs5Z9g/sehvXll3O6cUncHrxCX2bjDGO5IX9HsUX9WGRLJy+4GJUVaUz2MVb1XO54NjzefHx73hvYzGJSSq3J35LlnWX5YIr1Msn9V9iN9g4IvsQREGk2FFAtaeORaWJzNlg4gu9hQcKQgj13/B59zb+NfV+9KL2LlrvbeTdmo8REIgzOAlENYGqPdDBkPhSPqj7lG+aFzE5ZRzHFxzNhJQx1HobcBocKCj4IwF6wj28UPkGkigxOnEEcaZEVnfJyAiarYjkYFraJOx6G6cXnUCGJY2vmxfyfs0n+KJ+7TKrCreO+Tuf1s/DrrdxUMZ0zlh0CcFokBRTMiMTh3No1oEcX3sOobAffVSmxTyMc0pPJcOSxtmLLuXjui9JMiXy8SGvkWCKp8Xfplma7KTZ39ovCV/N1oV422uRAl5QXWx59kpKr/0MEkvA0gKKCvaBE9NZJcsPPmt6wqqOtdyeVokSCVMaMnGvcWKfi+38ZQpmUYty/WSxn3Pn2NHptHuzM9jFFctvoKe7nmRPFQ+JeThbG2DlfJgxh1FJv9BipmIdvLtTg9i4EtJz8GUM4om33LR3y5xwiJVxw378+6M37Ob+8sdpDbRxYsEcDsr8ZZ7Pm97ZBoASUdjyQWU/ofnXoPTwAja8XgEClB62KxGdKAqMPbVQs+ewSow8TrPnKD44j+KD8wDY/q2WPE8QBfRmiSkXDsJo05NU5MBpixBetQqpqAgxPh6jVc/M6/tb9iTk2vm5fNv9LfWhes5IO4MsU9Ye6wvjhvHE4ZnIqoxBMJCv23dbEcuZZ+JpbkZ1u7FecMGA34EDIeh0mI88cp/bifG/T0xo3gc87QGWPLWV8g/qCLjCpJQ6EHV7nw7wqxIOw5//rJXPOismNMeIESNGjBgxYvyPIkkSF198MRUV2lT6pKQ9fVRjxPilDB9u56GHSqmpCTBmjOMnbTOqq/1cffV2wmGFpCQDTqdEVZUm8E0ddwvH/1kl25aJ07BviQUFQegnMgOkpBiortb2mZim8lTFi3SHXByffxRFTk30OfvsTB58sA7B08DZh63TPJprnoKUg/ce2VxxM7R8BOEuMGdB7jm4s8/AF/WR3vk1NL4FgghFl0PyAVw38q/csOYuatrXsF1n4KFVN3CFTQJzBuSepSXl89fDjof5ixxk1rAzsCeMYWv3Jj7a/CAZES+96Dmu5GRerZ7LoGgQvRoBBOJVGR0CZslKW6CdtZ3lPLzpSc4pORWHYafQZM4EcyYHObUAp+O/OYeQHMIT9vJy5VvcOPrqPQ7RYbDjMNjxhD2IgoisygTlEAualxCNP5hP4y5AdATpiPRy9WY7Q9Pe5OjcwxieMIQb19xNjacOgM5gN2cVn8zQ+EG0BNoQSgeTdup9/G3RJZT7tyP0VBCQQ/SG3SSZEglGg1y36nY6gp3UeRqQVRkVAUVV8EZ8bO7Zhi/iQ0GhyddMlaeWF6c/xpTU8QxPGMKmngpCchiTaEQn6JBEiWlpE5mcOo6lbasIKxEEtAR2T0y5r98xn1AwmzFJZTy86SnCSphLBp+L0+DglCItzNcf9ROStShUs2QiyZSgtYVENBhARWBF+fsw7M8s8ixli2sbqqriCvfywvbXuXLEJYxJKiPTks6qznVkWTOYlDJW87wOByF/ECXxxST5InQKKiYZRjV0g7sXHBfAS1dBSIFjPXDwnrfllNQJnFgwm409FUxOHdfnSb6sbTVKThG0NrDVLlJ3+JF8Lw9mp0msqQgDkJGs6xOZAdZ2ltMTcoFkoEMfpdzsZ5rPAfF7DtgAfQkdf1JAdPfs8fm1dV4WrdUite9+wcVrd6ZgMu5dE3mz6n3Wd20E4NHNzzAheTR2w88XVh2Zdlx17p1lTXDf20DQL6Hs5MHkTs1E1Ik4MvrbVow+oYBhs3LQ6UV0+j2PtWBKKlvnNdGyqYfEPAs5YxJwpNuQu7pwXXo5qsuF4HDgfPhhdMkDX5Ofw7yueTza+CgAX3V/xTODnumLZv6eQqmQu5x3sSmyiVH6UWRKmfu8fyk3l/gnn/y3+/lThFeswPvgg6DTYbvmGgwjR/7mbcb4zxITmn+CVa/tYPlz2+mq8WBLNpE62PmrfanFiBEjRowYMWLEiLE7EyZMYN26dXskA4wRY59Q1R+1lSgosFBQsG/TtNeudRMOa9HGnZ1hOjvDfeu6O9R+UZ6/lMsuyyE52UB3pBNX2ed8XLceQRDY1FPBq/s/iSAITJoUx9tvO2H7VwgdTRD2gCkDBIEmXwtvVc/FprdyauFxWPVWGjwNdLWvZETErUWFRjx0tC/koppVhOUws+Q6LoxLAFUh3PwR+qT9ybSmk2pOJt+eC6rMopp3uCK7BFxrQGeBnNMI73ic5W1riNfpGK4EIfNQNnZ+x1SljW5RYosqMlgSGB4/hGA0n+WBDeQLIeYpNpxGKHTmUetpoMZTT2/YTUSJcPWISwc8L01fFdNRYyRheCumo4zQuxGCrZA4CaT+Ytg3zYvxRfx0h3pQVAVJ0PFJ08e0RbLJMObREuqlObINb/sGNnRv5qX9HqPOVQ1eF14JVravo8RZSL23kRJHIb6on3m9a+jWK6iqiqJGMYp6Eo2aFYA74qE37EYvSIiCSEAOEpADhOUQoqgjJId2is8qHcEuAtEAgWgAs87MyMRhpFtS6Qh0sqBlCSoqRp2RZe2rKO/ezMjEYVS5a7EbbPxj5F+142taRL2vkYMyppNty6TQkc+jk+8e8LxZJAtnFZ/MKzveJtmUyAkFs3Ho7cRjIihImBURgwzUVJCVmwkIgIokSlh2RhvrRT1RVSbRmICsynz29T2sqXuDekuQWRsO4bTZL/Bw8ilsWf42+YqNtLwhYHPAO/NAdmgKy0cvwQFHg9RfbhEEgdN2i0z/nuEJg/nKvABvdjYN3ib+vOluTgkey6lFx3PmkXbi7CK9XoWjpvefUV3oyEMn6pCNJvQ5g8h3lkHBOBi9p1XCp/XzeGbbK1gkMzeMvIrB8SUDnkMARk6G7z6Hld9CXCLEJfYlMASIREFW9r7598e6e/mXaigH3jSZze9vx2gzMOioQuZdv5jW8g6yxqUx/dqJ6KR/PwAwLnvvg2UGy94lM8mg46i7xrHk4dVUfVPPR3/6iunXTiTFvw3V5QJAdbuJlJejmzGwB/3PoSZQ01fujfbSHekmU7enkDxYP5hSqRSvrHmbb3i/ltWvVmFLNnHoTaOIy/wPzMz/EXzPPIPq1wYY/c89h+HRR3/X/sT49YkJzT/C6termH//RiJBmeQSx6/iARQjRowYMWLEiBEjxt7405/+xJVXXkljYyNjxozBau3/QjhixC+cCh3jfxt3BWy7Q7OMKPyzZhXxbzJ8uDZFX5ZVHA6JY45J5aWXmtHpBE48Me3f7zNgt0uMmN3K3Rv+ybaWHYiCQIE9D0/ES0SJYAh3ASCY0yHnFGh+B8IuTWz1VnLL6vtpcVeBZMUfDTAxZSx3rX8YxePhXBGO1oNgiOe7qJ6wHCYcVnjf4+VMu5OPvD282taFvfsibh59DaXOIha3LEMSYJJhNwuSiObbelPjGja5tanyf5JVDltzPvu3fUmW5MWjQIPexKz82WyRP6a8ezNfGQfh0NuQFRmjq5J4fTwbv8pk/Y4CDNltZF9YP+A5mT+/G+OGqeBrxt2ay0EzjLD5Om1ly4cw+BYtUttaQHfYw/PbX8OkM5JhSaPR14wkSiBGGXf4WrLbS9kSbsGVtwmAYDRIsLeDwza08q6uGlkO0eQL8YVJE5GrPbV0Brt5bMtzeKM+FFRUVWVK2sQ+oTDZlMSUtAl8WjePgBxEJ4goqoqKjFNnJdmUSKO/WTtunZH906eSZknl3g2PML95MbIqk2VN55Kh59LgbaIj2ElUkfFHAxQ68nliyn2kmJJIMMUzr/FbHt38DABvV3/AIZkHMDppBNPTp+z1njomfxZz8o7oJ2w+P+l+bv74YoRohAu9OVA4lANSMrh48Fl83vA1g+KKObFgNgCeiJe2QDtGnZZ47oPOD/HavQC8FfiSA4JNZF5yD5PK9oeOFpg8E/QGcMTv6oTNAbp91w4OyJhGnMHJQ5uexCgaEAWRt6o/4Pj8ozFIBo49aM8EcaqqsnltCmVdfyW5qIaZE0eS5SzsVyckhzCI2nE8t+01ZEXGE/byetV73Db22r13yGiC4ROgaguIItxxCSeac9nRdCjtWWM59ZhUrOYfF3hPLJhDk6+F1kA7J+TPxqb/6SR3A2FLtjDhwpEA7PimjtYNHQA0rmylaVULOZP2PWJ3IL63SfmlQrgckan6pp7OSAdqGLZ/Xk3GecVgMGiz0/V6pOLiX7Tv7kg3i1yLyDBkMN45ngMSDuCbnm8IKAFG2kaSbhzYRsQT9fC3HX+jIdTACHEkOS9OBQR6W/yse7uGA/467Bf159dCsNuhrW1XOcb/HDGheQCiYZkFD29m3dvVKFGF5KJ9mw4WI0aMGDFixIgRI8a/w4knagnALrvssr5lgiD0TRWWZfn36lqMPzL1L/UJotQ89ZNCs6qqvPtuG1u3+th//wSmTYvfo05pqZUHHiilstLP6NF2UlKMHHpoIqIoYDZrIlqLv5UtPdsZFFdMpvWXead+3bQQWZFJt6SyvbcKFZXTi07A0Pop1D2vVco7D6wFYEzRfgA6FtHZvgiUKCDQ6S5msRJBURWwFfFcJJmDRpyJLW447tZyfJvmsnWrD1NwMG/VlfHu4HlgScUd9vBm1Vx6Qi5kVSGsyEzKPgzCFVpbGccQjAbZhB0kK6gyq8MRDgvUo1NDlBrMYExmbPKBED+C28cOpzfs5rltr/LstleJMzh5dNJd+LbpWLq5iogcIrytgN7NEJwapN7XSJY1oy+i1u+XsettDI7TIk4NrhWoThW3IuPo3Yyw9lxQZbAPRlf8d4SdnsYAE1PG0uhrxqgzctHUaYxMjKfJN5rrV39BZ7CLY/OPZOOGD5m0sYF4XQCLLLBKF6Axt40jc2Zy14aHybCk4TDY6Qh1kWvLxqgz4Il4+q6XIAj8bcRlHJVzKAd9dgydoe6dXs0O8u25+KN+nHoHsipzcuExXDXiEra5Knm75kOqemvQ6/TUeOqYkTGdvwy9kNvXPUCFazsAToO9z04CoNarifGBaJBNrgp6Qr28tP1Nrh15OScWztnrPSVsWgWLP4P0HDjyDEYX7s+Hpy9Ert6MVDAEErWkhjeNvobrR16JTtwlCjsNDsYklbGmcwOSKFFmK2WJv13br9mmCbeCANMO79/o0Wdpy9099Ox/CNVdGyi05xPnj8B7z0A4BLPPhoyBZ6uMShrBtLSJfFT3BQBxBmefJ/ZAfDi3nufebAejGUfWNM67eafVUlsTLPiIed5yHk/vIdGWwh1jryPO6KQj0AlAvNEJPo8mlGfmaUL5D+lq1URmVYXqLaQWSzyS8QoMroDpN+21X7ufx1vG/P0n6/0cTI7+/TQ69uJJ/wNUVSX4/vtEa2owHXww+rIyQPNYXvToFiSjjoOvLSPzBwn89gWdXke5dT2d21ygCtQbdzAj8z6c999PpLwc/fDhSDk5e90+5Isg6oS+RILfE1EiXLPjGtrCmiB7efblzEiYwTODn6Ez3EmeOQ9REHcd37vvEq2vxzRzJgtSa2gINQBQHtpAgq4Mm6xpWkbbvkuAC3sW8q/Gf2HVWbk271qKLEU/59TsFftVV+F7/nkEUcRy/vm/yj5j/LGICc0/IBKMMveKFWz/tgWdJBKf+8tG3mLEiBEjRowYMWLE+LnU1NT8dKUYMX6IZB+wXFcXoLMzQlmZDWm3KeYLFvTw8stadO6qVW7y8sy7kgOqKkS9INkoLLRQWLjLasNq3fX62B7o4K/Lr8cX8WOSTNw25loWtS4lokQ5sWA2SabEfep6gT2XFe1rsEoWZuXM5JFJd2LQGWDNebsqtX4Kw+8HfRxEXJq/smTjdEc8L7g6MApwQkIeDZYSFrUsAwSybVlYor0QauPUouNY+V2QrqYmUtsm8k4oDt2wKhQ0T99P6udR663HrrdRGlfMWiGBoybN7UsgaAKGJo1ic4/mhzrGpge6QHKCEgRbKeSdi6IqLG1byZK2lTxY/gQqKvFRF92bbuCpjeCLnIhdsqLXmch3Orls2bW0+NtIMiXywIRbSTDFc/DBiSxf3ktFhY/p0+MpGFPKSQseZm3QR75ez/vZg7DpJPBU4JRdXD7sQubWfkamNZ1Lh55HRIliEPWYJa2vmdZ0nt/vEaJqlEUtSzmn+U6GDwowe2sQZ1BmhamRIeIULhh8Jmu7yqnzagJVkSO/L9ozz5ZDWA5T7akj3ZJKWA7z/LbXCcthUMGsM2GWzGRZMwkpQXJVCCsRTiyYzWnfXsTituXIikJQDhGUQ0R0UebWfkqtt56/Dr+I57a9horKuSWn9rs3bJKVOm8DUUXGJJqo8dQDKg9tepLxKaM1q5Mf4u6B5+6CaBS2rAGbEw4+Fjk+AdfwESQaE9g9dnV3kRk0If2GUVdR4dpOoimeRL0Ty9Ir6OmqZv+h55Bs2IvXrtkCJ17Mc1tf5ebV54AKY5NG8urWNKzbNd99utvh+if6bRaWw7xZrQ10HJF9MDpBR3eoh+Pyj6LCtZ2ekIvxKaP7i84BP03vfAAdmpOzW1Vx+xIx6RV49B8Eu5qJ697M9LIcvh0j8nH9l9w46ireqHofm97KWXHT4dYLNbE5qwCuuBcMPxBtpx0O65dqdZIzdonRxv6ewP9JssalM+rMobRu6CBrfBqpQ/ctj0Hoyy/xv/giAOFly4h/5hnEhASWPbsdOaIgRxRWvbKDzPvG/6J+rc+uIHtNKbJOpbxXu9ZSfj5kZCMZ9y65lX9Yx/LntqPTixx87Qhyxu66t7oj3X0iM8DqT7dh8GZQOiODwpL+kevBTz7B//LLfceX+uDFfesEPex37SDaPg5iTzEz9tR9F4ufaHwCv+LHp/h4qeUlbiu8bZ+3/TF0mZk4brih73NYDaNHH7Oo/R8iJjTvRleNh8X/qmDrV83YU01Y4vdthCxGjBgxYsSIESNGjF+DmDdzjF9EwcUg6kEOQM6ZACxd6uLuu2tQVZWyMju33VbU9yLvckX6NlVVld7eiCY0K2HYchO4N2kRxEPv1KJ4B2CrqxJfRPPZDEaD3LPhETqDmtVFjaeO+yfcuk9dP7nwWBKM8fSEXRyaNUMTmQGseRDaKbRY8kDvgBEPQs8asBWCMZU5bZ9zqC0OSTKjzzmKEZYc4o1xdHjq2L/9dcTWj6EVJEHi1EGzqZ9bDYDDIXH12Gv4vO0zdrhrkHytNPZ20uzthZ4uzsgf0icyf88tY/7GsrZVJBjjGWFNhKrHwT5Iix6PHwemVB4qf4JvmhdS3rWZrnAPFkFkts5Hhj/EzYUCf56whM7KMmZNGschB8bz4Ebt+DqDXazp3MDBWftjMum4445dUb1zazayMKKiikY2RFUe6W7luuQsbUDBkMwBGQUckDHtR8+xIAjoBT3PbHsFnxBlRY6VbmeY000yx8eHOKr7NZpWeXD5fbQFOhiXPIr7xt3CJw1fYtKZODhzOlevvJlqt2atIYk6drhrMEpGnIJAojGBU4qO5bKhF3DT2nuo8dQxK3cmd294hCVtK/BEvMiKAmge4pIaxS8HaPK1km5J4/pRV+7R52p3LW9WzyXTmk5QDgECW3q2YtQZkQQdK9vX9hOag9Eg23uroK2JIZEgkrBT6vD28kHtZ9y09m4UVeXw7IO4fex1fcJtvbeRnpCL4QlD+iJEd7irWdW5DptkocCRx587RyN+2wiL3oSzc6Bs0oDn2Rfx8dy2VzUBHtjWu4OO7hB9T5Dfu8c2L1W+2RfFvL5rEy9M1/xqv2ycz2ObnwWgLHEYt4+9jmZfC1ZvAOfG9czUr2SxLhOfbGBaSjPJ8cMgFARXF5KoQxREEnsDACQY48mz53DtyMu1Rue9ownIAI3VULsNSn5gy5RVALc+r/W5p0PznbbY4djz+D0Zflwpw48r/VnbKB0duz6EwyguF2JCAmannqBbu1Zm596jx3+KrOpS3MlaosTciqH4uwPM+8di3I1e8vfPZuoVYwcUUde8XoWqqkTDMuveruknNCcbkhlsGUyFvwLr8jSED5LZIjVQ+W0LJz87FfNu0d39ji8UYrRQwkWZF7HFt4UpzimMixuGPFoBgZ/laW3WmfEr2ne8Rbdv3v4/lxd9L/Ke/z2SxCRuc95GlpT1m7QT4z9LTGjeSd2qDj64aiVdNR7ic6wxkTlGjBgxYsSIESPGf5yXd0Yl7Y0zzjjjP9STGP9VGBKg5Jp+i5Ys6emLSN2wwYPHI+NwaK9/M2YkMn9+N7W1ASZPjmPIkJ2zOHvWaCIzgK8aur6D1JkDNjk4rgSb3oo34sMsmftEOoBWf3uf3ctPIQgCh2YPkCir+Epo/lATz9OP0pYZkyHt0F11yv6J2b1FE8VNmh3C5NTxhI1mumqb8KGSak5G569n8uRp3HBDIbW1AaZOjSMj3cTI9BKWtq3k1tUPEW1MwyTZSdp2PFH7WPhBrjSjzsj+GVqSte5gD48EbXSFIpyRnsE4Uyqf1H/Jp1v+SRE+NsoSAgJmQWGlrGeULoyMypDx3/FVXj3NGybRuDIJwSJQ5a4hEA2yxbUNq2RhYetSMq3pTLMmod9xL2MibqaKARYrVk0oSj4AskZD0nTQa9HrgWiA9kAnmdZ0zaP5B6iqijfixa63kWlNZ1tvFb0OCJvgOJ2POMy83rYGd1Aggpn5zYv5rm0FpxQdB8Cm7gqq3bWANoiQbklFJ+gw6AzEGRzsnz6Vvwy7kA9qPwPguLyjOKPkRF7d8Q66nYK9goIkSOhFCZPORHewhyuGXdyvj62BNuINcZgkE12hblRVRRIkbJLEqUXH83H9F6zr2kiDr4mXKt8k3hjHIVkH0Bt2c8mSa1jQsgSdoOOmjDhOb7agT8uhdfx4rl92ES2BNiRBx7fNi9nYvYXRSWUsalnK/RsfR1VVJqSM4fpRV9Ie6OC61XfQ5GuhxlNHiaOQZz+uo9SWr0VJL/6sn9Csqio9IRd2gw3D0q/J3F4FipvGJBtGiwH9nPPhzRchGoHjL+x/YUJB2lZ+AsFqSEqjSxCIKBH0op6VHWv7qm3o2sSjm55mXu08DJVb+EdzKqM9HTyX24vbmkbaZX/TnjWTGabPQlr4CUXJg1k3bSTHF4xhdu4PbD6yCna7sU1axPJAGE3aT3wSXD5wAsb/BowzZxJasAClvR3D1Kno8rVI8IOvLWPlS5VIJomJ5/xIcsSfYFbxoSxuX4Ok13HQpIls/6IGd6M2qFCzoIHBRxWRVBxP3dImLZHh+HQyR6diSzbRXafVs6X0jxQXBZHbC29nk3cTbSsi1EuaNVIkEMXfHeonNJsOO4zwokUoXV0Ypk9Hl5XFEUI2RyQdAUDFvEa+e6ICnV7kkH+MJGukNtskpISY2z6XkBpidvJsnJKT0Pz5+N9+G116OtdecCkv+d7DqrNyYeYP7t1fgR6lh/f87wHQqXQyNzCXS+0DJ0iN8d9FTGgGWitcfHj1SrrrvKQPjUP8FTKX/moYjfDJJ7vKMWLEiBEjRowYMf5n+ctf/tLvcyQSwe/3YzAYsFgsMaE5xj4zdKiNRYt6AMjJMWOz7YrQdTgkHn10MKGQgtG427uPMQkQYKfnL3uzCQCSzUn8c9KdbOnZRmlcETWeeu4rf4yIEkVVVWZ/dTpjksq4buRfBxQ/fxKdGXQWaHgdWj6CkqshcXL/OnonJO4ZXfp4/QKyAl5ylV46ZZkROz2rx49zMH68s1/dyanjubDgfG76/DsSukZg9+YQDP64F/pLlW+ypnMDAPdseJS3DnyWr7e/wPX6TqJKiG7BwFZ7Pla9k+GSnyHGIEt7trPBnYhVTqEpYwGrvy1g0tnjqPc04iPAnesfQhIlShyFCIJAOFzOCDGETtBxrcNMRTCR0rgiLhxzExh3HUN7oIOrV95Md7CHYmcBd4+7cVdUONATcnHtqtto8rWQZ8/BKBoQgHbRyiv+EFsqB/GXTIn81F4Sw91UKCZCgomntr7I9PRJWPVWMixpmCUzgWgAo86ATW8lyZSIUTSg+t2Mmb+M7zZezruZvWAwUu2uZWhCKZcOOY9rVt6CSWcixWxHVqJ4o34Mop6jcw/jiJxDAJAVmVvX3cfaznLijE7uHncjoxJHMDJxOOu7NpJvz2VWzsEcnXMoR847FYNNj07Q8dJ3q7n3m3L80jY8oxYRsShEiPDscDODzr6ByRmTeHbdAzT7W/BF/Zh0JlRU2gOdfFz3BcvaV/cNxqxoX0NIDtHibyMsh+kJuQAIyEEqTWGKURARCSVk8vJ7bvxBleMPtvBS8+MsbVtJVJUp3bCVoSEz8UEPBYEghqIykoftB3cdBEBUiTK3+kN6w26Oyj2UlC8+ZnZ5F+WpHgI+D8cfdlNfpPXIhGEsbV1JRnsv0z02lrZ/BIYwYSXCZw4XozPzsB52Mtb9ZoF9t3v6+AthxjHEmSycb9kZS93VBp+9rtlfzDodhoyBC66Huu2aaB6/bxYU/w6qqhJWwhh1/3lNQ5eSQtzTT6N6vYjOXecqPtvGzOtH7XW77novCx7eRDQoM+WiwQN6OC97bhudG33kRPIZdEAmh1w5iqqv6/rWi5KAyWmgdVMHC+9aAcD2z2uY9c8DmXnDKNa9VY3erGPMKYV77NsgGhjtGE3PYV46Fq0m0BsmZ2wS8Tn97V116enEPfssqs/X7/i+Z+WLlSiyiiLLrH51B8YhCnfU3sFi12J06Eg1prLJu4l70m6k++H7ERUVqamJrIwM7jz/zp8+wb8Qs2DGJJgIqlo0eLy4Z66AGP+d/L8Xmps3dfPJP9bQVeslbbDzjyUyA0gSHHHE792LGDFixIgRI0aMGP8Benp69lhWWVnJxRdfzNVXX/079CjGfyuHH55MYqKe9vYw+++fgCjuGV3cT2QGsBVDyVXQvRwcIyB+9I+2kWJOJsWsidHpljReP+ApFrQs4YktWhK/VR3rWN6+mqlpE3/ZQTS+CaigRqHp3T2F5r2ww9PAAv0IEtUAOmMqz+jMsP4S8DdA+izIv6Bf/TmDDyQ6fQjvv99O1iAjxxyTuudOA800broZX7gXQcrvWyyrMioqJZKATTIRUSQui7OyIeUgDI7BnJI7E2uohS/XPIyxrZcQUfQRG3kFZuymRFLMSbQE2lBUhbAcoTPYhVky4VFUELX958eVsnrC2yxtX0WNp45RRs3mYHHrMq5ffSd1ngYKHflU9lazxbWNkYnD+/r3TfMimnwtACxvX42AQFSV6VFUPB+eSn1rEQ1GA5cf+S66HDehoAdZL9LgayIkh7HqrSSY4rln/I0sa13OJSUnUxVox6G380ndPIas30BelYum1kaQ7VA0DICQHOaUouOYlXMIHcEu3q/9hNd3vEePqxK/EOCVHe9wcuExlMYVU+OpY21nOQCuUC/zmxdzevEJ3Db2WnwRHxbJ0hcdPya5jC0924gEjXw7twDZG0IWklBsXRiGrgFJj0NvIz9Ou0YVru1k27Jo9DZhkcycWXwyf191K76IH6veSqYlDVEQybfnYtQZGRRXTKEjn5ZAW584/eassUwMTybJlsa/mqfzzXLNTmBVfQ29o1cSViJs6N5Miy1IihDloHZIcKbyYbCDDd2bGJesPUcvV77F3NpPAVjZsZanvbkMC1p4ub6IkKDgzDmq77pl2zJJ6HJxxmcbyDWnM1z28ujBRXSIItlhg+aVPO6A/iLz9yT0HyAKP3Uz7ZUrEQSRVHcX0gU3wogJfB7v4YO6J8juyuSvwy7Cqh/YJuffpcnXwvWr76Qz2MVRuYdy/qD//ICpoNMhDCDC/hhLn9pKR6UbgAUPbeLUF/bbo872+S0IooAt2UTAFUYniRTPzCPQE6SrykXxwbnYUqw0r23v20ZVVNzNXnInZzL9sqE/2Y/4bBsnPzsVf08YR5p5wJkigiTt9fgsCUaCHs0uyZJo4s22N6kKVOGKuPDJPhL1iTQEG3io7iFK3KswqBLFlmJMirJP5+mXYhJM3OS4iQ8CH5CuS+cEywm/aXsx/nP8vxaa27a5+OCqlXTucJNS6vjjicwxYsSIESNGjBgx/t9TXFzM3XffzWmnncbWrVt/7+7E+C9iwoS4n79R0n7azy/ALJlJMfePjrTr/43k6qY08Hp2lfeRmVkH8MzWV+gQrJycdQi0fAz+em1ly8es0WVQIyvsnz6lL2nh8cencfzxP2hDVdF8hUWaV56Dt2cVHowMljZRlzgbV9jNWSUnIYkSx4+6ic6VZ2NRA2TED2O/smvBEKftx5LO1WNvIM32Po3b9BxUMocTZmfjVWaxqaeC7e5qkkwJJMtuLhZqSBYNfKPPZqPcQ7xOYtCQW7hp7T1UuLYDcNHgszgi5xAe2fwMiqoSkIM0eJtIsSSxrG0VOdYsEkxadGCScVcUZkgOkWpOIcOSSpuvG6knk0RLJqrByPO9iWwIK7QpCoRciKKeLa5tfYME+aJKvutjiPRCxhzaUw/g9nUPUO10sbI0yj9qbEx3W1lrsDE2aSQTU8YC4DA4cBgcFDkKaPa3IaMQUSJ4I17qvI2UxhUzv+U7lrStQCfoGBE/hEzrruvwQ/HzsqHn83XzIszBLK7Fj5cQOlUgzZvMiZnHYErN5pi8WaRbtH0Mix+MO+whx5rJrJxD2OqqpM7TQFAJISJyetEJFDnzODBd87k26oz8ddiFHJw5nXdrPmJu7WdsUGWWmLby8ojHaduqA7SId3ePFaPOSEAOoqoKxrhkxGAHjfE6Vo0rRBREUky7RN8GX1NfuTXQTvSgvyDt2IjJ1YXpsJPBsutZ+bj+S/JcUcxItAc6GJ4whGMtowgNP4mjvMlQXAYpe7G8+AFbapcR9ms+vq1VCxmD5gv+r4oXUFWVZl8r79d+yunFv43Q91Hd533+7R/VfcHs3MNJNv/2UdS/KntxAUod5KRupXZuU0o1oVcQBMpOHtyvXs6kDDa/vx1Pi4+4PAfpI1N+VvN6k4Qz/ZfJd4dcV8bq16qQjDrGn1VMnWel1l9DCnXBOkRBxCSauK/7CSYeGeWYhQKRbMg76aSf3VZkwwYC772HmJyM9fzzEUymH60/zDCMYYZhv+i4Yvxx+X8rNLdtc/HR31fRUekmucTxs0zR/6NEIvDaa1r51FNB/8tN6mPEiBEjRowYMWL8d6LT6Whubv69uxEjxk8yJmkkhyUezbMvV5NrySFr7N69T79rXc7z21/HobdzzYg/k2FNB6DF38o71R9h05VySlIuJoMNsk7CFerltap3UVWVUwqP7RNTf8hRuYcxOqkMWZHJtWdD09y+de0hF/dveQGvYOSzhq95csr9/awm+vBsg623QtQP9kFYe1djVnw4hDA9iplrR17eF83ti/j4V9XHtOvLOC51BLlFp4Peznety/ms4WtybJmcW3oat0/8G+wW3J1APA9PupMrh1/CV00L2K/nS7LCcYSUMClhL2fKWcRJcSQEA30iM8C6ro0ckXMIRlHzSC5y5BNVouiQeHrrK7yy421emf4vCp357J8xlZ5wL9t7qzjddgLv1X6ML5qMoiiEE2TiAg7QWzBlueiQI4gICKJEMBri1cq32d5bxfCEwYx1LUSIaD6xNM9lI0lk2zLpSArgl7sJJqdw1dTrYFp/P+CNXVu4Z8OjfN70NeFoGEWRCQODrJlMT5uMO+zhvvLHEBAIyiG8sp8DM7SBjgZvEzvc1YxIGEqiKYGHNv5L82Y2xHFu6akcd/BQXv88gF7fyd37lzDr4Mv2uIxXjbiE+c0jEAWBjkA323p34Iv6EQQBQRDoCfdwdO6f+uqv6VzP7esepCfUy9rODQTkAAIC3aEeHtrwBDdNupfb6gTCUTjn0AyKRl7D180LKTGk01D+FblhM39ut7FSKKZo5DHa/beTWTmHUN69hbAc5sicmUjpeXDLc9qAxg+iVDMt6XyVGY/HYiAxBObETI44+Gpw7mnf8FPMG5nBfos6UUSBxSOzGTNAHfV7u5zdiURg+VeAAJMO1mZb/0yCUW0QpCfkIt6o+W9bJPNPb/gHYMpFg1jw8GYiQZmpFw0asM6Ma0awdV4TOr3IoIP3LvybnEaOfOwgfB1+bKnW/6j+5MywMuPqXckeT7GeQk+0h7ZwG7ck3MII2wj+tO1PGAUjy8apbJpk52+5pw9ow/FjqKEQ7ttvh6BmhSFYrVjPOedXPZYY/x38vxSaq75r5ZN/rKan3kdy8R9YZAYIh+Hss7Xy8cfHhOYYMWLEiBEjRoz/YT766KN+n1VVpaWlhccee4wpU6b8Tr2K8UfDF/GxoXsz2dZMsm2Zv9p+Kyt9eL0yZWX2Aa029oWIEuG5xztpqkihiSCX+b7jtUcP3KOeqqo8vOkpQnKIjt7tvLjmBq6b9BDo7dy89l6afa0A+LIO4NKScwF4cMNdrOvcCECzv5U7x12/135kWXeJPnW2kXQbC8gVZBYZh+PtrAWgI9BJd6iHNMtuVhn+Bs0XunMhshJFFXRIzXMRLbmE3BVIaoTF5pF8u/FJEk3xXDjoTD6q/4JVHeu0PjYsYUje8ejkCPdvfBxZkdnYvYUkUyKzcw/n0c3PsKlnK1PTJnB2ySmAZpNwTump9G7ayubqBciqTFMkgN1WhIDApw3zGJEwlPLuzQBMSNakwmtHXs6L29/ArrcRUSJ8Uv8V1Z4aIkqUOV+fyZIjP8VusDM793CeqHied2o/otiRT0SNEqd34jljKdYmL7ftdxXLpKN5d/VmVMGPqiooKCxuW8EHdZ8zOK6Em5LS2f/7cyRZKYgfjF1vw5w2DEO6xKBxt0J8Xr9rsKZjPXO+PhNvxEtYjqCg4NDbKYkr5tvD52KUjEQjUbwRH76oHxUVT8SLqqq8VPkmj25+hnhDHBnWNE4pPJbHtjyLN+Kjyd/K31bdyujsEdxw65GcP+ScvSae1It6ZmYdyOs73uXhTU/1LTPqjKRZUsi2ZvWrv7h1OVElSmewi6AcQlFVVBQkVSB50ybKai7gzeGTCJ3+N6wWHTCYYQmDQVyD990KukMuLJLEabYJsDOq+3vGJI3khf0exR/1k+YOQ/kKKB4OZsse/T69+AQskpmanAMZIQ2GonFgtQ94jD9F7szzuTfnTRAFLhpxJgBJpkTOLz2dD+o+J9uawTF5/e06w3IY3SsPoVv7nbagdiuc/tef3fbNa+9lU08F3qifbFsW1428/Dez6Pi1ic+2MeeBCT9aR2/UMfzInH3an2TQ4cz8Zdfw18Sqs3JNbv/ksUXmIjyyh9ZQKxOdEzkz/cyfvV81EukTmQFUt/vf7muM/07+3wnNVYtb+fi61bhb/KQOjkPU/bI/oGLEiBEjRowYMWLE+LWZPXt2v8+CIJCcnMyBBx7IAw888Pt06v8Z27b5WL3azbBhNsrKfn9R4IeE5TBXr7yZBm8Tkihx65i/MzxhyL+93y++6OTxxzV7iWnT4rnmmvyf2GJguoLddHXuSqZX0+zaa11J1BHytUCgEUlth83XoZY9Qnugs69OW6Cjr7z78vbdlu+BqkC4G/RxtAQ7uWr1bQSjQSRR4vzSo9F3vUhEVRmWMLgvKrmPrbdBsAW/eyudwS5aRRv5lhQMko1qMY6N2Hm9u5ZBsh5REDFLZuIMjj26EJRDyMqu8+CL+FnYspT5zYsBeL/mE8Ymjex37b4zD6dDSMAiRHgq6iQc8RFncJBhSePPQ89jZftaEozxpFlS+Lzha7Ktmdw34RYAVrav5fWq9wjIIRRVYVtvJQd+NoeLBp/NsPhSvmj4BoCN3RUIiOzw1NAbdhOf3ko4YzZ0SoxJHsWWnq0EokGGJwyhztuAikpQDvFW2MD+ucdBqA3SjybfXsyVw//E+zWfMCl1HBk/EJmjSpQLv7uSzmA3shpFUVXsehulzkKemvoAZr0W1WrVWylLHMLiluWIgohdb+Ojus95bMuzNPqaafW30+hrotZT37fvQDSIyaAllfu48WNOL52NeWeUbHugg0c2P4Mn4uWcklMoSxyGqqo8s+0V6rwNgCbsj08eQ5Ejj5MLj+nX78FxJXzTtAhREIk3OpEEHb5ogGOEUv7WFAVA2rgMqacBLLuOuTc7m2ViKwn+XrxmA+Y0iT3TVILDYMdRVweP3wDRKGTkwtUPaon6dkMv6jnpB337pZxYOIf90iehE3T97vcjcw/lyNxD96j/ddNCHtvyLJctWcaEXgPWiKpFM/9MoVlRFTb3bEVAINuaQbEz/1f5rorx63Nj/o183vU5Vp2VmYkz0Qm6n97oB4g2G+bTTyfwxhuISUmYjz/+N+hpjP8G/l8JzVXftfLhNSvxdYdILnX+4lH6GDFixIgRI0aMGDF+C5TfOPlOjB+nqSnItddWEokoCILAvfeWMGjQHyv6rtHXTINX83qNKlFWdaz7VcSbxYt3JaL87jsXV1+t7jVK9MdINiUx4YgQC18xI6gip5+aNWA9QRC4ZsSlvLjiSpwmC+fEpYC/FkEJc0rB0bxZ+Rai3sZx+Uf2bXNK4bE8tOlJVFROLTpu4A7IQdh8HXgrwZJDTfKxBKNalF1UiSDWv8oTpk7apWQGj7gEUeg/u7XRtQlvsAdfJIQomNkmJvKimg+BMC0hB/X6NLqC9fSYXCSaEvCEvYxJLKPAnktADnJkzsw+MW9O3hF8XP8lObYsjso9tC/hXd85+IHxa0HCSJ4yDkVVVaxGgZmpE0g1p3BCwdHoRT1T0ibgC/u4bPl1tAc6EASBf4y8ggkpYxifMporh/2Jv6++jZAcAgSq3DW8XvUuqeZk1naVo6gKefYcLiw9g9vWVyAKIlbJwqLWpRyefTA3r72XrlAPOkH8P/buOkqOKu3j+LfaddzdJTNx9xAsSIJrcGcFdnEWzeLuzouz6OIOQSLEPZOMu0uPtGu9f3TSyTAzMZINcj/ncKjuvlV1u6YTmF/dfh4qe2uI0UdhcfdQb2/E7XfzXfZJHJYeXOno8Dl4dusr9Hr6qNhWY/qQpOmh99LiaMPms2NU6en1WlFKClKMSUxNmMSI6CJorIEfPobIGE7ImBO6Ggn6eBrszZhVJiRJgdVnwxPwolcZ8Pi9JBkS8MsB4rdd4whtOBrFjpD2/8reZEPXZgDu2/g4/znkeew+O0qUaBRqPAEvsboYiiLzyQ7L6F9DvKaUKdUdtEZMpS9Fw2bLVrrc3ZySOY/TmnWw8ungOK0OwnaUbfm8/hu+aPiONbPjGe7OpjtMz3Eq+6BBMwCbVgRDZoDmOmhvhuSMoUbvF9trVu+JV8rfwh/w02XSECitA7UJWhuhqw2iB2mUOQSFpGBi3FhWtK8BYHLc+L2et/C/YVKZOCX+1wfDhlNPRX/KKfv03w7hj+NPEzQ3bbTwxa1rsba7iC8MFx98QRAEQRAE4Tfn3//+N9dccw0GQ/+vUjudTh544AFuvfXWgzSzP4f6ehdebzDsl2WZ6mrHby5oTjIkEKuPocPZiSRJDI8q3P1Oe6C42MTGjcHGe0VFpn3+fUmpUPLaxVew6pjNxOljyYtJwxfw8X7NJ3S4upiXNidUt3ZMzEjGTLwVyh8EZIiaDK5mTrF8yAkmK3LS4aijh4eOPSNxChNixyAjh1awDtCzFmwVyIDXVsWwqC6idJFYXN2Y8TIqYCFBpSGBXrAshcS5uHwuNEoNqzvW86VTzZE+K91eF+9qhtOpScLq6sLvd7DOYcfp34JaoaLSWkOaKYWAHOCu9Q8DwXIHO68QvSB/Phfkzw89npU4lc3dWynpLmVq/MRgyYWdFEbmcfe4myntrWBczCgyzDu+kl/dV8uCdQ/QbG+l291DvD4Wl8/NC6WvISExIW4MlxSeyzrLJj6t+xq3341BZUCr0LK+czNahQan34XTY0Pbs4Y0XyfL3F663T1U9dWQE5aJy+9GgURAlnH4nXx6+H+4fe19VPTVEKkJ55mtL3PotvrJD218mi8bF2JQ6imOLKCyr4ap8RNZ0rYcs9rEiKgixsWMYm3nRjwBL7lhWSQa4un19AZD1keug6ZaAhoN42ZPpbKgkCprLXqVjqVtKynrrUSjUBOuj8fi7qbZ0YJBpeft2S+QbkrlvZpP6HJbOD79aJSKHasvvQFvaHv7inKT2sSUhPFolRpcLhve7k6WOL9gSXgUkZoIDk2eAZUlWJ+8jn8kVtOuldEXjOehaffuKE2TJYPXTU/NRjpHjybbFIYElHSX8uzWVwjIATr9NkrDDKSaIpiZOGXgZ9NhD662zykOhuyyDJExELPnIfBgLK7gTaKhapYD0NcNX70DCiUcdfouy3BE66Lo9fRRnRRJV7IHszkN9EbotexV0AxwY/hRlH29jsXOcl7zv4JSUnJEyiGDjvUH/Lj8rt9NaQ1hcCJrE/4UQXNbWQ+f3bQaS52NuLww8cEXBEEQBEEQfpMWLFjAZZddNiBodjgcLFiwQATNB1hxsYnERC0tLW4iI9WMH793zZD+F3QqHQ9OWMCKjjWkmVIoihy8SdXeOv30BFJSdFitPmbP3vuGYzvTKrVMS93Rcuytqg94t/ojAFZ2rOWVGU/uCAdjZoAhE7zdEFYMlY+Cqx2VvRJKbwdNBKTsWGmnU+l2c/I4ZCQqe6vo9vTwmedDbhl7J92eHrKVSqJKb4Htjc+0sbxW8Q7vVX9MuCaMOSmHslqVzHplAl5NgBExI5mkj6Kp5jWWuzpQBjwoJQmz2oxaoabGWs86yyYyzemoJRVLWldwatbxQ05NqVByZfGlu5x+cVThgAAa4J3qj7C4uvHJPkp7K6izNeAL+On19HHbmns5LHkma7s2kmiI5+3ZL/B9y2JWtq9FKSnwyl7sPgd+2c+pvjIyWiq5RtXDW7KJzwPhbLRspdNlIV4fR7W1loAcQCEpeKfmI4qiCuhyB4PMSJUWqfRO1ndu4MPGElw+FzavjfYeH+PkqZz47dnU25rxBLxMjh/PneP+RUl3KSXdZSxuXQbA4cmzwGELrur1uKnUutiwvoPvwpKQkelyWyjvraIoIh8ZmVhdDCs61mDz2pGQ6PNa0al0nJ17Kn0e64DGchfkz6eqr4blHWvINKWxrG0Vk+PH86+R/+SutQ9Rs+w9auQe8HeB30eHa1s5luqtlKsdtKt84Jdx2C2s7ly/I2iWJJYMS+AB3/sEOkqZsqGKG0f9gz5P8OaMQlKQH57Nmdknc1zGHEw7r5QGWP8zvPIA+P1w0sVwxd3QWg8jJgVXSA+luxM+fAl8Hph3HiT0/4bAVw0LeXrrSwBcUnAOx6YdOfhxXr4fKoIrvelqhUtvGfKUN468kjcq38McPp4kxwbo6grOM3Mv/64JBFA+dyfK5nWM9vThR+Y5zascnjxrQCbTaG/mptV3YXF1Myf1UP467MK9O5cgCL8Zf/iguW5VB5/euIquGhvRWWYUv+XGf4IgCIIgCMKfmiwPXq5gw4YNREX9uvBP2D2zWcVjjxVQW+skJUWH2fzb/HUpShfJUamH7ddjSpLE9Om7WBH5K7Q4WkPbPe7e4KpFxU6rFg2pQHCVM5oYcDWD3w6SCupfhYSjQbWHqxxNOTQln82PlnuoURewyQt57as5K/dUAPoy/0Zdyzdkxk4CczHvrXocgF5PH82OFkZEFbGpewuTYsdww8grUVm3UN/1Ee3uPsqUTiQU2Lw28EGeOZtebx/tzg6SDYkURw0dxK3uWMfrle8RoQnjyqJLd736dBDb60C3Otoxq01EasKpstZRZ2ugxdFGvb0Jg1JPTV8d2eYM/j32RiyubqxeG5csuYoGexN2r4Nxqk6UkgalpGSs0suHXg81fXVcu/I2zs87gydKXsAT8DAyqpiNlhKenvoAAFavjct1GuhciMLrwuS1EKUOw+X3kIiLJzY/y2qHlb4AqBQqlrSt4K2qD7hx1D84Ju0ITsmaB4BWoeHZra8TnavjhC0uOrQyK1IN+GU/Np+DaF0UsiyjlJRolBomxY+j2dFKWW8lMnDv+sd5dtqDvF75Lj80LyFCG869424h2ZSEzWvD7rUHV9KHZQPw1Jb/Y3L8eL5sXMj6jvXIPhvdWh+mgJIMp8QRydtW1xaNI+O7cGQaWG904bSXMaxtJSfs1CTvx5alBOTgNx5+bluJy+difOxoxseOZnXnes6oVXJafSmqcQk0JE2iu89PcY4mWLLz2/d3lMv46m24903ILQanAz56GdwuOOKU4Arnnb31JGwJlp6gqw1ufIKXyt5kUesyJliUNNWsxp1qRDJH8GTJ/5ETlkVBRG5wvN0KOgMoldC5488gHS27/KwlGOK5ZsTfgg8mBMBp37dGhH4fOGyoFMG/R40uDya1cdD/xn1a91VoZfZXDQs5JXPewPrpwn7h7PPQXRfMx7RG9cGejvAH9Nv8P6f9QJZllr9UzoqXK+hrdRCbF4ZShMyCIAiCIAjCb1BkZCSSJCFJEnl5ef1+Eff7/dhsNi677LKDOMM/D71eSWGhafcDhT02N20Oa7s2Yvc6mJt+5K6/Gp96OnR8D5YVoEsEhRb2sjGVPv5Qvqr4HI/fA0C8Pg6ATlcXV5V9RLe7hxjrTzwQewgmtRGb1x4ad93IK/rf8DGkk2aI5dkkLetcDs7q7MErK+l29yB5O7hZZyddr0OdeSwTs84YdD4BOcB9G58I1Yp+peItrhr+l716T+fmnU4AmQ9rP8fi7qbW1oA34KXPa8OsNtLh6gzVfN5o2QKAy+/ijnUP0mhvRqfUkhuWRa9PSYS3lVhdNEv8keDqxhPw8lPz0mCYXHg+yzvWoEBiSvwEwjVhXDvi78EVuR/9A2LrGZGUzknmCJ52qZECHlq9Pta6nOgUEj2yREAOEKkJo9vdE5p/pjkdWZa5YNEVdLq6YLgJV3g4vRqZ5ox4EvR6FAoFXr+X8bGjidPF4PS7cPs9HJY8E2/AS4QmHE/Aw7qujfzQvIQmewurOtZR2VvNE1Pu4/GS5+l299DibCNWG41KoUKrDDYNtHntoFIjmcLJtkk82JZF3pF3IW0P/JMziL7+eYqX38b6nkXgd/NaxbuMiC7mrJzgivq88OxQveE0U0podf2tY64lsGYRik8eAFbQtWQZt+kX0KFNYdJwLTddHBksOVFXETzXzqUy3nsWVv4Q3K4tg+sf7f+Dt/ft2Lb1UdJdyoe1n1NY3Uret6vJlaHAqOCGw+Mx6sO5buXt3DzqKiZ8thDWLoboOLjiHjjyNHjnaVAo4MhT9/yDp1DsU8hs89pod3aSPu9s0j5+BZdRj2XWTG4eNfh/x2L1OwJ2nUqHUWUYdJzw61g7nHx41QqcPR7McXpOeGQi+jDN7ncUhL3whwyafR4/n920mtKvm5BliMsPR/q9Nv7TauHdd3dsC4IgCIIgCH84jz76aDCEueACFixYQHj4jpINGo2GjIwMJk8esrWUIPymFUbm8cK0R1jdsYGc8MxdD1ZoYOQTUP00uNsg5TRQ6rB6rGiUmlBw+Et9Hiv/qXofX8DPGdknctvoa/mu+SeywzI4LHkmAGs7N4bCz05XF981/USyIZEaWz1HJM/ijOwTgV/UGFWHw/CHoXs1qeoYstc+jizLWNzdXCg1MV2rIkVvJND9NZJ05qBzk2U5VC8YwBvw7dF18/g93LvhMTZ3lzIlfjxXFl2KL+Cj1dGO1RtcKWpU6QlXhxEggNVrI1IbQawuGoD3az6lzdlBpikNh9/Jo5PuItUQh6X5c8INiTy48VXCHcGA2eF30OnqYnP3Vu4a+y/8+BkTPXLHZL5+F9piQGOFgIUr5z3IcebRXP79eaicDbi9YEVFliEBo9pAhjl9QMNGt98dDJkBMvJpzE7lhuFXMFVlQafU0e3u4cwfL8Xpc+KX/YyOHsGS1uVkhaWTaEig3t5IXlg2o6KGo5JUNDmCK3P9sp+ntvxf6GcbpY0k2ZhIjC6aC/LPxOLqxqDUE6kNpzs9jwnKVBKKLkJKyut/waPjSMscj2vNwu3FVfik7isOT5rJz+2r+Lz+G8I1YRyZcgjz0o/qt6ui1xLa7urxY1L20KFNYfkmN67aWnR1FfgtbXiLx6I7/3pW1S5iua2UY6uXkxzwBBsadg6y0njeufB/9wRXQ590McptN11Smy0E5AB6pZ5Up594t0R8XAayLLO+6kcmrF28bTLtsPQrmHcOjJ4KkgSGA3sjrdHezPUrF9DnsVIQkcvdj/yXIrWOol3sc3z60bj9bprsLRyTdoSo03yANKzpwtkTvAFnbXfSsqmbrKl7V3dbEHbnDxc0O/s8fHT1CqoWt6IL12COG6JJxO+FSgWn/Prun4IgCIIgCMJv17nnngtAZmYmU6ZMQa0WX2cV/jhkWebuDY+y2bIVhaTg5tFXMT52zNA7qM2Qf33o4TtVH/JG5XvoVDpuGXU1I6IHRlaPlTzHyva1ANTbGrl/4u0DxuWEZaJUKPEH/KgkFe9Uf4RvW+i7vVTDoHTxkHgMMcCF+fP5qPZLRkUP52SNhUDvejZYSugLQJnpVS4pOHfA7kqFkn8UX8rL5W8RqQ3n3OwTofULQAFxh4Gi/6/lPzQv5vXK97B6rPR6rGiVGhY2LWJGwmTSTClkmtOwem24/C4SDQlkmFLZ3L0Vf8CP3esIBevh28ptyECTvYVLlwSv+61jrkGr1DI6eg1tzna29pSjU+qI1kbh9LsYFpnf71qU9lQQYZAwAh0tKaRJw1ElHUcGkBY9iuY+MxpHG5qATJopmRMzjmFN10bu3fAYF+WfHWy2R3ClaoIhni8bvsOsNnHL1L8g2T9ktLsTkk/h2rrPcfqcANh9DizubpIMCTh8TiQJzCoTfV4rL5a/Tq+3D78cIMmQQJw+jixzOl1uC7IsY1IZuXXMtVT11dBga+Lu9Y/SYGtCgYJ0cwornY1cvPU+7jbeRE54Vr9rb1DpUUlK+nwOPAEPVX01XLb0GhxeR+iayDtdW7weeO4O5JLV+HraUUUl4M0bS507WGc7I0mF7qvX6GmpoDLQgm3jhyx8YTVLNJ3Iej3fGlxcY3GQpI0l+/gFDFgelz8S7nsruC1JFABn5pxETaeEqbwNFQpaYsMYGT+a4etqcGvVjD3uIlD/HJwbQFRwRf8+lb/YB4tafg7Vri7tqaDK3rCjnMcQVAoV83NE7nGgBPwBqpe24eh2gwTIoNIoicoQ394R9r8/VNDs6HHz+c1rKP++hfAkA/oI8RUAQRAEQRAE4fdj5syZoW2n04nX6+33elhY2P96SoKwSx6/hzpbA4mG+IEN0Lb5qnEhn9Z/jVllJFoXzdK2lRhUBtqc7UyMHbvL1YuyLPNW9QcAuHwu/lv76aBBc7uzc8e2q3PA6wBZYRncM+4WNnVvoSginxtW3RF6rdNtGXSfXzou/WiOSz8afA6w/ExJ+zJ6A/C5OpfSuq85MeNYYratKAao7K3mwU1P4Ql4+VvRhYyNGQVl90DXz8H3ZysnkPXXUHNEj9/D4yUv4Av46HJ30+vpI8ucjsXdzYe1X3Bs2hFckD+fsp5KfLKPjZYS1nVuot3ZgVqhxhVw833zErpc3ZyWdTx2r52Xyv9Dp8tCn9eK2+/hx5alHJkym6uG/4VR0cOxuLpZ2LIYi7ub83JP7xcyv1f9Ma9VvEMguQ+XuhGD1kRRtpY7Az5UChW3jb6Wd2s+5r+ffUbGT/EEwgK8PO9tYmKCNeUf2fwssxKnolQoaXW00epoY5gyHqXbQ6DyBVB1IwPe3k2MjTmDtxQfhMpkxOpi0Kv0HJo0gzcr38ekNuLxe/hvzWckGRIYEVVImDqMGYmT+UvhBWztKaeku5TxsaN5reIdVrQHmwhWW2ux+xw4fE7WWTYyPnYMTp+Tn1p/7hc0b7Zs5emtL2FWGzGq9PT57KGg227rRKMygTEMpbRTSc51S/GXrqXMWoXNb+PnMdlcePYNXL1JRVOXg4zCVpxfyrQ623D53XTJDh4Lq8GrBAV29LFGbj5xGImaKB6ZPJmkwT50v6hpfEb2SZB8NJ7pDdTWrSJDE8Gxj92Oy9oFiWkY15QFm/0t+xaSM2DqEA0CD5AMc1poW6fSEaeL2cVo4X9h0ZNbKPuuGYCUMdEkFkWSMjqaiGSxclzY//4wQXPloha+f2gzbVt6CE82oA//g4TMPh98+GFw+4QTgiucBUEQBEEQhD8kh8PBddddx7vvvktXV9eA1/1+/yB7CcLB4fF7eGHJ+Sis5TRo0/nblCdIMib2G7O0dQV3rH2Qit4qArJMkiGBeH0Mn9V9g16lIyssg0cm3YlCGryfjiRJxGijaHN2AAzZIOy49Dk8uvk5lJKS+dknDzoGgmU8CiODJRPOyD6Rt6o+wKwxcVLGsXvxxi2w8WrwdLKJMN7UTgBJhV6lx6Dq/43aF8pep8keLInwRMmLvDLzSbCWArDeZeeeDS/jrVnDFUUXMytpGpIkha5FtDaSDHMaaklJi7ON9V2b2Ggp4ZFJd3JCxjF80/gDK9rXEKYx02BvQimpkOUAT2x5AZWk5NSs47ll9NU8ufX/8AQ8SFIwUDerTeCzo/JZOSIl2Azv9JwTCcgBVnesZ13nRir6qml1tLO6cz0ATVjpDJMZHZ1BibOOelsjWWEZJBkTOTP9ZFZ+sAnZI6NoVRD/QwKek5xs7inF7Xfzl5+v497xt1Bvb6KmfQuK7i70sgK/owlPQRYV1jpsPgffuxO4fsTfqeyr4fiMY5iVOBUI1pr+qeVnGu3NGNQGYrcFrxqFhj5vHz9sC9YXjL2e0TEjANhgKQFAr9LR67Hi9rvxywEcPicNtkYyzelkmdOBYMD8VtUHfNH4Ld2uYI1nlaQiWhcMy6MtfVy0xc1Ppg5SU0dx4qE7fVaMZvo8fcEa0JJEhcrG0raVTBsxkTeW30nLljYSklSclZ1JVauNR/KVuJVeJMAjBdAQwGCORtKG71glvSuyDK8/Ait/QBOTQN7lt8P9/4DWRoyBAGi7oaUOTrscCkbt8Ud6AIcd1vwEYZEwcu/KNk2Jn8B1I4M/x2nxE/e68aWw/zWt33EjzdbmYsyCrF2MFoRf53efWsqyzMaP6vjh4c30tTiIyjSj1u1ds4jfNLcbTt1WrN9mE0GzIAiCIAjCH9i1117LDz/8wNNPP80555zDU089RVNTE8899xz33nvvwZ6esJ8taV3Olw0LSTencEHefFSK39f/69c3fMj4nh8BGOVoZXXjl8zLv6DfmGprHVXWWmRZRpZl2pzt/Ny2il5PH8WRBVT31dLt7gmFeoNZMPYGXqt4hx9blvJ982LC1GbOzt3R0GxVx1qe2foKsixzctY8Dk+ZtUfzPzPnZE7MOBa1Qh1aUbxHulfhcbfzQnc7tR4XI2KmYtYnMtddgmH12ZB+PiQGw0i1YkcZHPX2n2/MLGj+gNd6OnCooiHg5f/K32RW0jTUCjXXjvgbb1S+R4w2iiuLL2VVxzqeKHkBCDYWbHG0kRWWEWqYFqeLoU0XTbIxga09FaFf8n9oXszIqCJsXhtKSYnT52JYRB6FygCsuQD8Dog9BHKvAuDBjU/yTvVHdLm7iVCHkWpKptXZTpwuBoNSj0ltxOV34Ql4sfnsoff1QfWn4A+GvzIyI8OK+MT1BV0uCzqVjs2WrXzZ8B2fNXyDzuunVOsmwq/kAYeb+a1rMODmW0UqLe4eZuoieaz4kn6XW6/S8/CkOyjvrSLFmERVXy0f131Jh6szFOJvtJSwpbsstNo9vmc2H3+uR6nxMHJGBJukhSgkBdHaCPLDc7iy+FJmhI/Et3UNd9Y/jhU3LfY2vAEvRpURs9rEhLgx/G3YhRS9/DIxvW2c0hsDVgXsfDOhaByeY8+k5senKE+Joj4hggRDHFt7ymlxtAHQqvbRcc7l1HeX0lf2H9T2VlQBUKv1nJJ7MgURuRySNJU1nRuI1kVRFFkw6MfO45V58tkaqr6I5siIYuaxGRZ/Dm4XRMUHazwHAjDtqEH33ytP3bKjeeEJF8ChJ+zV7tMTJjM9YVtA7fNBxSaIjIGE1F8/N2GvpU+MpeTzhtC2IBxIv6//kxnE0udKWfpcKT53gNj8cBS/16Z/giAIgiAIwp/ep59+ymuvvcasWbO44IILmD59Ojk5OaSnp/Pmm28yf/78gz1FYT/pcll4cNNT+AN+NlpKiNXFcELGMQd7WnslDg89kpKA7EdJgGzNwP440xMmoZSUSJKEUlKgkBREaiPodvdg9zkpiiogUhuxy/MkGxPp2ZDK5ldnozZ66D3tG2YnTUchSbxT/RFfN36PhIRSUvJR3RfBENpeC03vBZv5pZ0NysF79+hUugHPeQNePq//FpffxbFpR+woCeJogPZvQZb5qK+br2w9gITS0clLUQlEeZ0QAGpfgPgjQaHmL4Xn89SWl3AH3Fycf3bwOBnnQ9QkIhSvQm89ABGaHQ1AJ8WNY1LcuH6P367+kLWdG4nXx1K4rd7tlPgJnJ59Apu7S5mbNofVneuxuHrpcHWgUChJM6XQYGvCrDKjREGfz06f18anq/7J6eawYAO6jh8g/TzQRPFW1Qc0O1px+Jz0uHtJNSUTr4/jovyz0Cm1WL027t/4BGFqE7evuZ+HJ91BhjmNgFqm49g2IhdG4Q/3cdiF06ms/Z4TDG76Al6+91gwqgxYPTZ0pih0lg6UMqxQBfjBGY7b78Kk9jPRFCBOFwzB2p0dtDraKYjIRaPUoFfpGRldDEC0LooJnkqaqhax0F3PJ9rh+JU6Yna6WdGx4jBSVF3U9zXStHocBTPr8Ml+csOzWDDmenJUsXDflfgtLTiyq1BkDyPNlEK9vQmtQk1uWBbDA9HM/GEtyDs1oMwpDm36tpUPiZ93Oerhqfy09SVi1EYiNOEYVHp0Kh0unwtJkiiKLODkrHmckX0iN6++i0prDZPjxvPklPtQSAquW3E7W3vKAbiy+NJQne2dfb7YwQ9bVOCJ4oXWyYwxNZASlwxzz4Yv34LsYXDRvyC3eMC+e8Xr2REyA1Ru3uugOUSW4enboHwjKBTB+Y2Y+Ovm9wdU5aiix9fDKPOoUMPH/WnqpQWkjYtBUkikjhGlTIQD63cdNJctbGbFKxX4vQFisv83he0FQRAEQRAE4UCxWCxkZmYCwXrMFkvw667Tpk3j8ssvP5hTE/Yzp9+FP7CjFIrVazuIs9k3YYlHk9vyCX22apTmQpLSTxowJsOcxmOT7ubuDY/i9fvQqbREayOJi4vm4oJztgXGg5fN2M7vl/nhTQM+hwafQ0Pz9zloT9Zw65p7abA1UW9rAmSyzBkk6Lc1Ptt6O3i2lZ8JeCH7r7t+M7ZKcLdDxBieL3uTrxoWAsESDPeMv4UtXRv5fPllpChkTg2LxmkuBLcK1OH4JQ1uxU6BtVIP28KiJGMid42/aZCLV8jfR13Pyxvuwx3wcs7wK4acWpjGTKwumlhddHDV9sILSDOlcGrWcaEGajeuuoMOVycgo5CUROkiOCljLp/Uf0WvN1jaIVIbjkahpsmnxOa1E6XVBIN4VTBIN6iDK6S1O9VonpMym2PSDufV8rdZ2rYSv+zH7nOiVWop7akgw5xGrC6a8oIKPHkeLso/iymF41HXN+LXgCfgZlZUHMdmHE2jo4XXXe/i0CjxosQlg1mhQiUZg4F2wdkcljyTrd3l3Lzmbjx+D/kROdw7/tb+q/2dTVgqnqC5r4ZMv5vpdDBt9CP9yrboNAr8cgCf7EelklFICsbFDOewpJnBusybVkJXG1oUXNgezSvxNoYnD+P1WU+zqXsrAXsfc196HzylgAxjZ0LeCJgwG4/fw4K1D7DRUsKo6OHcOuYalratQK/UYffaeWTzszw2+W7uHPsv7tv4OHKvhfbln1A48Vzyo3J477CXcfqc/Kfqvzxe8jzHpB4eCpkBVneuHzRo9vlkUGsgLRe6O/DPOiG4elmhgCNOAUmi0d5Mb3cpwyLykaR9XISn1kDROChZHawPPXLKvh0HwNoTDJkhuNp6/VIRNP/Cd5bveLzhcWRkJoZN5ObMm/f7ObwrVxLX1YVm5sDPlSDsb7/LoFmWZda+U82SZ0tx9niIyREhsyAIgiAIgvD7l5WVRW1tLenp6QwbNox3332XCRMm8OmnnxIREXGwpyfsRynGJI7POJrP6r8hzZTC3LT/TcMuWZbpdvcQpjH/+lId2mjCJ75JuLsLdHGhcPWXTsk+jmmJE/EGfOiUWqr6aimIyKXX08dPLT8zPGoYyb+o7bwzhQIyIhNweNw4fS5mpWYSo4sONQBMN6UgSQrmpB7KKZnzqO6txtW+AqfPjkapwaSKJTN7F++j62couxeQwZxPtW3HCtYaax12r53b1tyDyxqsE62RJI7LnM0GVSL1tibmpc8hMfMYqNEE6zenngG7Cc8BIpvf5Sp/sJYw7Z+A6bIhxzY7WtEptdTZGun19NHt7mGTZQtjo0cSb4jD4XPiC/jo81oxqY3khmVR0VdNQA4wKroYm9ceupmxUZePImM6yE5IOAYUwWD59tHXcvva+wGJSwvO5di0I4jSRfJe9cd8XPclrc52tvaUY1IZsWgjGB41DIDPGr4hRhuLwwmNvV0oJYlxYelYNCZaHK0022q4dsVt/HvMDWzu3orT50Sr1NDiaCdKG0miIY4Xpz9GiinYCm9J23I8fg8AZT2VNDtaSTOl7PyJoM3ZiYyMVqnBHfAzJnpkv+t13XkR3P12Jz3dzcSPW0KZtRatSkuDrYlIbTiHJOWDVgduF8dZo5k4/Gpu7Hqfa1fezimZx3G2eSJ43tl2NAliE0NN9ZY2L2bjthrQ67s2saJ9DZ7Ajsat2+e+0VJCR0cV1JbzMCso+nkNMTe+CAYjL5S+zrdNP9Lu6uSVsrdIMSUhEQyGx0SPGPQzcOwMA1trvFQ1RHHkKSmkH71T801JYnHrMh7Y+CSyLDMtYRLXjxz65sVuXXwTlK0HcwSk5ez7cYxhEJ8MbU3Bx5mF+36sP6glPUuQkQFY0bcitFJ+f3F++imO558HwPX114Q/+ui+34QQhD3wuwuae5rsfHf/Rip/aMHj8BGbGyb+kAiCIAiCIAh/COeffz4bNmxg5syZ3HjjjRxzzDE88cQT+Hw+Hn744YM9PWE/uzD/LC7Im/8/+33GH/Bz5/qHWN2xnnh9LPdOuJUYXfSvO6hCA/qhQ+LtEg0Joe04fSy11nquXnErHr8Hg0rPE1PuHbLRnyRJ3HxTDq+9ZiAiQs3f/has83p27in8X9mbGFVG/jXyH6FGcLevvZ9wj4ap7hqcKHjBtpxHckopihq89i2WFbAt6MFaxjFJF1Gxra70nJRDsXntuGQpuPrX20tHQCIieS4P5+f2P862Wsd7rGf1ju3uVcBlLGldTpuzg9lJ0/uVFDk+/WheKX8LhSThk300O1qRJInny17jltHXcGHefB7c9BQRmvDQdZwUNw61Qs36rk0kGOK4Y9iNuHxuiqMKiNj28+j19FHavgaP38PLFW8RqY3kvNzTODnruNC5ez19ADh8DkwqE5mmVCK0EbQ521FIErW9zWyp9hLwquiscFKd7ycr4zyU5Y/RGwiwRJNGY08Ft6+9n82WrbQ5OzBpTBybdgS3jr6GeENcv1Xt+eE7gk2j2ohe+YvyJvpE6mLnEGj5jFbJREv4hAF/hopyNLx58zA+r29kYXM6vvYODNvKp3S5u7HG6HFdfh2x1XWQPYx3nUvodAVXwL9b/RFzZxxOxLCxsGUNhEfBxENDx/5lqZcITTiXF57PI5ufISDL/GVYsE650+8CuxUIVlRx27qgoxnSc+lwdWHz2am11iNJChIN8RyddjizEqeGAvxf0usU3Hrp0I31fmhegiwHP8dLWpfzz+LL0Oy0On2vqFTBVc2/llIJ/7gPVv8I0QliNfMgio3FrLGuASDPkLffa/X7Nm8Obfurq5EdDiSjcb+eQxB29rsKmu1dLt79y8+0lnRjitcTmW7a/U6CIAiCIAiC8Dvxz3/+M7R9yCGHUFpayurVq8nOzmbkyJG72FP4vfpfLpp57uOVvNu6jOhoNdDBwqZFnJa9j7VXf6XSnorQyk+Hz0lFb/WQQTPAiBFmHnwwv99zx6UfzeHJs1BJqn6Bmsvv5lu3hqfsESCp0KsDrOncMHTQHD4SOr4PbhvSmZ1+LIVxE3H7PWSY0wA4PHkW3zZBlFLNseP+BaZc+jzB1cPbQ9LK3mq+LFlNUWQhswuHI8sy3zX9RKuznSOSZwHwaf3XROuimJc2h+VuH4auTZjVJjJzj+TL+q95buurAHzT9ANPT3kg1KTwpMy5TE+YhMPr5LjvzqbX00eiPp4OZzAcHRFdxGuznsbqsfJjy1JidNFMjh/PoUnTWdi8mGER+eRF9F/W3ePu5crl/8Li6qayr4YUYyI6pY4P6j7vFzQfl34UqzvXU2WtQQK8sg+/7Oe2NfchSRKyLQpVewqgQN06k1UlbrKOPJl2bR4Prb6bwLbr0+HuIkITzrDIfDwBLw9OXIBRPTDwmpE4BZ1Sx9vVH7DZspVLl1zNdSP/3q9u9aFj7+fjukNQeO3ckjZn0B+ry+fi0MTpHNUXwT02D8v9DaQYk4jXxXLeor/j8XsojipA21NFs6MVGRkJCZ1Kh06th8tvY2XlQh6tfxtVyR1cN+LvFEcVkmlOJyssnQZbM+fknkpxVHCV7gvTH+13/uPSj2Jj9WLqOtqZ1xNBclQ2fPdfKF3HX9ISWZEBygBcWiFTaC0h/cjJDC8aPGTeEwURuazqWAcES9bsc8i8v5nD4ZDjdj/uT+rk+JNJ1CbS6+tlVuSs/X58zdSpeJYtA1lGPWoUChEyCwfY7yZoLv22iaXPl9JS0k10hgm1/nczdUEQBEEQBEHYay6Xi7S0NNLS0g72VIQ/gEWLLHz0hoOuUX66LF5GjDARv4tg90AbHjUMg0qPw+ckXBNGYUTePh3HoDIMeO6vwy6gyd5Cq7MdrVJDhCacQ5OmD32QuNmgjQFXK0RPAUnZbwU2wBXFl3B+3hnoVXokJP699gFWdawj2ZjIveNvxe5zcNp7N9LYakOSFdw5fAGxo1t5sfQNABY2LUKSpNCq2dKecn7udZGvzIMAHKYuoLSnFIAAAZrtrdh8dsI1YTumqY8FPdwy+mpeLX8bSZIGlFwxa8zMTQ8Gr26/mxtW3UG9rRG1Qs1d426iMDKPRnszn9d/Q5e7my6nJRgWI9PrsaLT6whT9y9NGauP4Z/Fl9FoayZeF4fb78Hpd2Ho7kbu6SKHcGrb/oHbYyDeEE9BhhqAwpgR/K34MlZ1rmN09HAkJJ7Y/AJqScUx6YeHQmanz8lzpa/S5uzg5My5jI0ZxYS4Mdy/8Qm0Si3egJcPaz/vFzSrFWpOzpw35I/0++ZFPF7yAlJDNVeVqbjJHob92NMxTD2Tu9Y/jMfvCa7iLn+bsTEjQIYMcyoJhniOTz861CTyuZZPsfoc4HPwYtkbPDr5Lu7d8BhVvbXU2hqCq7S7S7luxN8HBLvhmjAePPJJGN0MbY3gsMHrjwCQWFbFpxOu5L/tb5JT/g1mjZm8z74DTyToTTDjGNAN3sByKKdkHkesLppudy+HD1LjWfjtmhox9YAdWztjBsqUFAJdXahHjz5g5xGE7X7zaa3b5mXFqxWseKUCZ7eb6Ewzat3+78L5m6XRwMsv79gWBEEQBEEQ/rD8fj933303zz77LG1tbZSXl5OVlcUtt9xCRkYGF1544cGeovA71drqQeuJJK/sLLpi1nNc5ARmJU3b7+f54QcL1dUOZs6MIidnYAi8XbIxkSem3EtFbzWFEXlE6YYuCfBLn9Z9RXlvFbOSpjI2ZtSA18fGjOLro95jccsyNlq2cGjSdJK31f8dUviI4D+7YNYEA9jNlq2hlaNN9ha+a/6JeH0srR12AGQpwBerNzMjxxHat93VQUAOoFYEQ9h2ZydIEmXKGACOVKiYmTiF/1R9QJO9mQR9HN2unn5BsyzLSJLEyZnzmB4/CaVC2a/0icfvoc3ZQZwuhnVdG/mg9nOWt68mQR+HN+BlZcdacsOzuGn1XVhc3XS7e+jx9pJhSiM7LJPhkYUYVHrOzT19wHt3+l20uTposDehllQM16SE6u5O6zVw/Twn36hHMrMwlRG5O2pcH54yi8NTZuH0Opnz1ams7FyHVqEhJzwLp8+JXqXnraoPWNi0CIDy3irenPUsOpWOJEMCNdY6ABIN8cF5+JwsbF6ESWVkZuLUIb8R8Gblf4PNNvs6+U+kiun2MIyb1sCc+aQYk1jBGvyyH41CjQIFSDAhdizn5vV/7wZVMOy1em2saF/DHesepLynkl5PHx2uTgwqAyva1/Bjy1KOSDlk8A9OXFLwn63r+j2t1Zs5M/EI5NjOYHXmpmr45DXQG6GqBC6/bfDjDUGSJA7Z1Q0V4U9LlZUFWVkHexrCn8RvNmj2unyseauaFa9UYG13olQriCsI//PVY1ar4bzzDvYsBEEQBEEQhP+Bu+66i1dffZX777+fiy++OPT88OHDeeSRR0TQLOyzQw+N4ptvuqAth9k5Y7hs8q664+2bRYssPPxwLQBff93FCy8MIzxcPeT4OH3sLstlDObH5iU8X/oaAEvaVvDs1AeJN8QNOnZ64mSmJ07eq+P/UlVfDU32FsbGjAytwI3SRuANePHLfnRKHXG6GEZEFRGjj6bV1klA8lGf+g2rOoz4ZD8qScmU+AlEaML5uvF7NEoN5+adTmlPBYtalzEsIp/ZSdOx+xxoFCoMKgMSCj6o+4yrhv8FgC8avuWF0tcxqgxcUnAuna4uUoxJoaDZ6rFy7crbabK3UGOtp9HejF/2o1aocfic5IZnMYlO/JuuZ7R1DW/7wqix1ROmNhOmNnPnuH+RFZYx5HUoiijA6XMhIaFX6RkVls+I7h7MASVz+iJYSTXf6r5iaYOe22KuozCy/wr1/yt/k42WEgKyH6ffyU8tP7OqYx0zEqdg89pD47wBL96AFx06bh1zDZ9teINIu48jc84C4N/rHmRz7c/QUk+jN4OzzngaktIHzDdOH0O7swOMYcT1usBhhewiAM7KOQWT2ojF3Y3F1c3P7atIMSZxbNoRA45zdfFfuHvDI2xpLkOn1PFi6Rs4/S5kWSZAgAR98LOn3ZMyFYWj4Zj5sHklFIwO1ivOLEDatAKaaiAiJhgyAzRU7f54e+HH5iVY3D0cljyTMI159zsIgiDso99k0Nzb4uDja1dSv7oThUoiMtWISvsnWsUsCIIgCIIg/Cm99tprPP/88xx66KFcdtlloedHjBhBaWnpQZyZ8HsXHa3h2WcL6evzExmpOiALeOrqXKFtp9NPe7tnl0HzUKweKw9tegZJgquKLw+tJJZlmXZXZ2icL+DD4u4JBc2yLOP0Owctp7Ev1nSuZ8HaB5BlmVRTMo9OuguNUsOqznXYfQ663N0clz6HGYlTsLi6eeX0G/hhUQfvuZ8iOjZAn8fKyMhhnJN3OoUReUiSxAkZx/BTy1LeqvqA4shCnppyf+hn4fF7aLK34Al4cfgc1NkaQ+/rhdLXsXltrOpYx6f1X5NuSiHdlMplhedRHFlIRW81TfYWHD4HlX01yAQA0Kt0ZJrTWJB/Kmn1T6FRajlO7WCDs4d6SUmyMRGr10ayIRHX55/j7+xEd9RRKOP6h/cqhYqR0UX0eYLN7ZKSizl9/ChY9SPyqHweNmxGlmXsXgdvV3/AgrE39Ns/RhfVr+GfWqHi7eoPeXTzc4yIGkaKMZl2VwdnZp8U+nnHNLRw3tuLwOuBzRbkv/6bH5uX0tleghmJDa4GDn/rPnou/Cf5Ef0bM147/G+8WfU+Cn0R81d8CT4vVG8Bnw+VStWv7IYv4BuyAdsn9V/RYGui2dEKMngCHjTbVmSnGVPIi8iiKKKAGQlT9uxDddTpwX+ABlsTj295Hs8MA5fm38ewjRXw/vPBcVOP3MVB9s5/az7llfK3APi+ZTFPTrnvVx/T4/fgDXgHrbH9azXam3lmy8vIyFxScE6oTvrOvGVluD79FGVCAvrTT0dS/SajLUH4U/pN/Wn0efxs+rieRU9uwVJrJSrDhC5s/5WL+Krybda1LKXV1oBGqSErchgnFF5Igil1v51jv/P54Ouvg9tHHhns/ioIgiAIgiD8ITU1NZGTkzPg+UAggNfrPQgzEv4IrB4rT2x5kU5XF6dnncgEacwBOc+sWVF8+WUnVquP4mIzmZl7V2N2uzN/vJSV7WsBWNe1iY8Of52nt7zEV40LSdTHE6WNwOLuYXzsaPIjgn9eOpyd3LjqDtqcHcxOms4/h1+O1erDYFCiVO5bqL6mcwOyLAPBULDN2UGqKZnP678lQhNOhCacTpeFVR1ruXv9o/gCPuYUH0pmWzhWjw2r18YXjQvZ0lvOBXnzOT7jaKxeG29VfQDAlu4yMs1pTEuYBIA74CEnLCtUW7pwW3gqSRJhGjNVfTW4/W4CcoA2ZwdmtYlb19xLkiGBTHNwVa834EMlKVFIKtwBDwaVgePSj+a1slc5w1lClDaSnLBM5kflUtlSRp2tkShtBC2vv4D5g+DvnZ5Fi4h48cV+NyMkSeK2MdfydtWHRGjCOT/vDCgywnHnIQGmn/6Oa1v96UhtxIBreXr2iazt3MgXDd8Rp4/h6NTD+allafA6t69jwahrGJM4rv9Oa37C5XNRrnOSXLGSd9Y8TmVfNX1qF1qVRE5fD9+0LuHdFT1cmH8Wx2ccHdrVpDYSp4vB3ryOgNEEOjXUlkNLHaT2X82/c8gsyzIOnyMUoC5tW4En4EWv1NHntSFJEkqFErvXzqykKVw74u97/oH6hRtX3cGazg2EaczYvXZenPVYcKWz3wfJGft83F8q7akIbddZG3D5XKEa1Ptia3c5C9bdj93r4IzsEzkz5+T9Mc2QxzY/F5rzI5uf5bHJd/d7XXa7sd52G7J920p4lQrD6QPLvQiCcHAodj/kf6OlpJu3L13Kl7evxd7pImFYxH4NmQHKuzYyM2Mu1097lCsn3UNA9vP4in/h9rl2v/PB4nbDsccG/3G7D/ZsBEEQBEEQhAOoqKiIxYsXD3j+vffeY/QBauJTW1vLhRdeSGZmJnq9nuzsbG677TY8Hs8BOZ/wv/dG5Xssa1tFRW819218HI//wPxsU1N1vPDCMJ54opA778xBpdq3XzfLe3aUDSjrqaTGWseXDd8hyzLNjlYOT57F67Oe4ZbR14RWyX7R8B1tzg4Avm9ezPUPLOXMMzdyySVb6Ojo/35XtK/htjX38lLZm3j9Q9/AGRU1PBS2JhkTQs0Td15hmWFK46vG7/EFfAB81bCQq4ovJyssA78cIMEQhyzLvFrxdnDFr8/e7xx23446zsnGRE7MPJacsEzGxIzkuPSjQq/dMupqCiJyidPHEKOLRikp6fPaMG0LRGusdZyQcSwuv5t4QywxumiOST2CH4/+GKffSWVAy3plAh3uXpyGLA4bfQcJhjji9bEk6ONYtvqD0LkC7e3Ijh3z2i4vPIdbx1zLFcWXDFjJetuYa5maMJE5qYdycf7ZoefdfneoAeL9E29n88lL+P6Yj5gYt+1mh6UDtq7B+OgtsG5pMAzu6wHAlZLOtUl13BRRyuWRG1m0/FVUkhK92oBJ0mDTSHw9KXijYXHrsn7zebHsDd6ofI8PFdUsSAiuDMdohqjBy6xA8IbMFctu5PTvL+bWNffgC/goiixAr9QRrY0iThdDtDaaBH0c0xMmc1nBeUMe65e6XJbQdQCo6K1iRccaLO5uaq31O1bqJ6Ts15AZYFbi1NCfk0lx435VyAzw39pPsXuDn4+3qz8Mffb3F/dOfz+5/AOzGtnh2BEyE/y8CoLw23HQl8f6vQF+fqGU1f+poqfRTnSmGa1p779etSeumNj/Ttg5I6/m2m9Po763gtzo4QfknIIgCIIgCIKwp2677TbOPvtsmpqaCAQCfPDBB5SVlfHaa6/x2WefHdq67YIAAJLVSURBVJBzlpaWEggEeO6558jJyWHz5s1cfPHF2O12HnzwwQNyTuF/yx3YEdz4Aj4CcuCAnctoVGE0/rpfM2ckTuHTuq8AmJ00HaPKgEJShOYdrgkjQhveb5/onZoJepwK1i/zokFPe7ubr7/u5Kyzgs0ALa5u7t3wGF6/l3eqP+LBTU9REJ7L41PuIcXYv2HghLgx3D/hdhrtzUyIHYNmWx3eq4ov52NzBgDz0ufwbvXHrCS4AjvREM+42NGMix3N45uf59umH/EGvFi9Nr5u/J4jkg9hZuIUfm5bRXFUAYckBhsyyrLMkrblFEcWcF7u6ZjUpn4rilOMSVxZdBlvV3/I0rblZJjSSDIk8En9l+iUOkZHj8DmtRKvjw0F4k9PvZ8EQzxpxhSQJD5V57PENJEXhz8ASg2x+hhc/uBiptoJmdDaAx4PmkMOQWHcu5IIGeY0bhh5Zb/naqx13LT6LqweW2iV+XbT4idRm9XAhg33MarDQHKfG+7/B0QngE4PV95DTVEetdVR0NSL06xD6bHjdLtwSj50hgiicmfS6+kDYFhkfr9zN9iDjQoJj6IhVw0jz4Qx04Nh807WdK7n3eqPidPFkGZKodZaD8C6zk1ssGzmhpFX8n3zYtQKFWnGFGpsdURqIxgfu+ffCviy4Tue2foyAJcUnMOxaUdicfeQZkymOlBPQA4wJ3n2jh16ukCWITJmj8+xK1MTJvK0OY1ud8+A67Qv4vQ75hWpjUAp7d8yp5cUnMPDm58hIAe4vPD8Aa8rIiPRHXssrs8+QwoPRzdv3iBHEQThYDmoQXPFD82sf72J1q09SApILIpEUvzvmv05t91NNqhFMXxBEARBEATh4Js7dy7vvPMOd999N5IkceuttzJmzBg+/fRTDj/88ANyzjlz5jBnzpzQ46ysLMrKynjmmWdE0PwHcWb2SdTZGuhwdnFWzim/ekXjgfbM1Ac4NvUIlJKCY9KOQJIkrhnxV75p/JGssHSOTh34Z+Ho1MOxem3UWhuYYJrGU6jwbqtTHBsbDIgtrm5eLHudWms9epWeNmcHATlAl8vCBYuu4NMj3kSr1PY7bkFELlnmdL5t+hGlpOSw5Jksal3GuzUfY1IbGRMzgrNyTiFCG0a3u5dR0cVU9FaRG57Nhfnz0SjVvFbxDgaVgae2/B9dbgvXjPjbgPm/UPYaH9V+AQTD9Z3H+AI+rlpxC4tbl1PZV41OoaXJ3kK4OowkQwIuv5uJcWNJNaWE9jGo9JjVJgBOyDgGtUJFm7ODOamHhgLzK4ou4cktL6JAwSmTLiZybgSBvj6U6QOb6+2LLxq+w+qxAcFV5vNzTg41f5QkidOyjiex+X7CWjrZEmgjKWBAoYqiVNVL0crPSJp7PqbYNGydLSBDhlvLcH08Tr0OGT/n552BJ+BFp9Qya1tgv93ctCMp7anAF/BxwsizIffUfq/bvXZqrQ3cte4RvAEvWyijKLIg9LokSYSrwyjtqWBkdBGJhgQAciOGbqLp8rn4vOFbVAolR6UcFrrOH9Z+HirB8mHtFxybdiSjo4czMWYMhs5OshwqzqtRQfXrwZB55ffBA550Mcya+yt+AjskGxNJNibul2Odm3s6KklFj6eXkzLm7vd678VRhbw04/FdjjFeein6M89E0utFfWZB+I05qH8iv7h9LZJLgylWhz58/5bJ2B1Zlnl/y/PkRBWRvIvuuoIgCIIgCIJwoFVXV5OZmYkkSRx55JEceeT+awS1L3p7e4mKihrydbfbjXunsm59fX3/i2kJ+yhOH8sjk+462NPYYyqFisPjj2TFZjdbfV6GZWuYnjCZ6QmTh9xHISk4I/uk0OPIm/tYuLCLzEw9RxwRDcCd6x+iorcav+yn3dmJQlKE6vM6vA66XBaSBgnjHtr0ND+1LMXt97Clu4yl7Svx+D1Y/B7eqHyPBWNv4Lj0o/ms/mtuWX0PAMelH8VFBWdzYf5ZfF7/behYVX21g87/s/pvWNu5ESTwyf5Q0Nzu7MDqsfF982K6XN24/R78gQB+OYDD58Sg1qNSqDCodByXfhR+2U+jvZmjUg4NlbeQJIm56XMGnLMgIndAYzjFLv7c761EfXxo26Q2hoLv7dqcHbwyPY0Z62QsKj8ulYINmkrseNF7P+cF/5k8MON+luneJKeqicaYMKr0lTR2lxKQ/Tyy6Vn+XnwxhyRNH3DuKfETeHnGE7j8LhIMO+axvmsT9254jNWdG0jUxdHkbKEwPA+FpCDREM+U+PGUdJcxJW48L5e/xUZLCSqFiptHX8XYmFG7fL8PbHoyVFu8qq+Wq4b/BYBUUzItjrbg9rZV8xqlhrsdI7GtWY7R7UN6/0bIGQ61pZCYBqYI+OGj/RY0709apZYL8ucf7GmgMIsFg4LwW3RQg2aFUkF0tvmAdDzenbc3P0VjXw3XTnnof35uQRAEQRAEQdhZbm4uLS0txMUF64eedtppPP7448THx+9mz/2vqqqKJ554goceGvr/k++55x4WLFjwP5yV8GcSCMjc+LiF6qZg7ddrzgln5rhgY8GP675gaetKiqMKOTvnVCS/A9wdoE8BhQqHz8HDm56hzt7A3FOPZN5OdY6b7a3YfHYSDPEURxaSY87gsS0vYFIZmBw/nnj94PV7V3WsY6NlC37ZT7enh+FRw/D43CTJVsL8Njx+Dxqlhu+aFoX2+a75Jy4qOBu1Qs3spOl837wYpSK4Inq7qr4a1nVtYnhkIb2ePmRkkMHhcwLw4MYn+anlZwxqA96AF8e2es4+2Yc3oCBMbaa8t4pkQyKrOtZxScG5nJy56zIC7c4OvmxYSIwuilFRw4nQhg2otzwUu9fOI5ufpcnewokZx3JI0rR+jfR+6fiMowmUrWfdirfIcah4z/QSZ4//C5IkIcsy3zT+wBZFN6uGq+j1OohQGHD2ulErNdj9jSxqWc7JWXM55ZBr4RAYDSjrv+WWNfcQo41GkiQ2Wko4MmX2oOcPllfpX2Ll6S0vsa5zMy32VnrdvaSbUvEEvOSFZ3Na1vEkGOKZl34Una4uHtz0FL2ePlx+F181fr/boLmyr2bQ7auKL+e/tZ8hyzInZR67YweHDVNACR47+P0Q8INGD04HHl04ZX1xtPzs4PDJ+oOSmQiCIOyLgxo0G2O0By1k3ti2jKunPETktq/uCIIgCIIgCMLBsv1r1dt98cUX3HPPPb/qmLfffvtuw+BVq1Yxbty40OPm5mbmzJnDKaecwkUXXTTkfjfeeCNXXXVV6HFfXx+pqam/ar6CsF13XyAUMgOs3epGmbKBrxu/54fmJURqI9jaU06GWs+MjnfB24vbmMfX4YewtH0NJd2lSEi8WPYGE2LHhFa0KhVKtnSXoZSUnJI5j4sLzuGEzGNoc3YwLCIfpWLwWrNRukj8sj94DEnJ2dmn0F5yG2nOraia1/BQ32bOm/IseeHZVG0LGHPDdpRY+EfxZRybdgRhajPxhmCY3WRv4bqVC2h3duIJeCiKKAAZAsjMTpxGm6Odn1p+BqDR1oRZZaJTYUElB3+F1yjUhGnMIEGaOYV2Zyd2rx2zZuhVngE5wF+XXk9FbxXdnl5idFHkhmdxx9gbyQ0fuiTEdu/VfMKK9jU02Jt4u/pDorQRTI+fxL0Tbu23ang7hcfD7A+/Ja2nB4D1n77EqozJTIgbw3dNP/FR3RfE62NZY99ITlgGbr+HBnc7JrUGFQoGq6p5VOphLGpdFvwZSxITY8fudt4788t+Ot1d+GQfDp8TjVLDm4c8GyrpsV2EJhhQl/VWArC4ZRme4Z5QOYzBHJE8i7erPiQgB3D6XJzz41+YHDeOywrP55zc0wbuMONY2LwKGqsgpxivRk11vIGanFRqS6fxveJ4nG/30WMNcOqRpoH7C4Ig/Ab9qYrZyLLM25ufYn3rz1w1+QFittVZEgRBEARBEIQ/mr/97W+cfvrpuxyTkZER2m5ubuaQQw5h8uTJPP/887vcT6vVotVqdzlG2H/8AT9PbHmBTZatTI2f8Jv42vqBFBmmIDtFRVWjD0mCqNQ27tvwOL2ePir7ahgWmY9RZcBhWQ3eXgDuq13IKlUFTW4rXtlLhimt3zHtXjt9HiujooqRJAUWdw8AiYaEUP3doVyQdyaVvdVISCQa42myt5DvqsTmd6EMeMl0VvJN449cUnAOGeZU3H4Pc1JmY7f7ePHFJpZWl8D4ZUwckcDfiy5Go9RQba2lxdFGRV81voAPJQpOzz4BrVLL6dknolGoMamN1FobqLbWEqmNQKNQo1GoAVBKKjRKDTHKaAxKPeNjRw8aMrc52lnesRqzysQn9V/xZeN3aBQa7D47EpBkSOCbph/3KGgOyAHsPgdNjlYcPicqScnm7lI+qvuCywZp2gYgKxShbb9CQWBb3Wzbtn5JKklFpCYcjUKDWW0mw+wmTG0m2ZDAjMQp/Y5VZ23g5fL/YFQZuLzwfHLDs/Zo3js7J+e04CpxlR6z2sxJGccOCJkhWL5lRsIUWpxt6JRa1Ao1na6uQUurbDc/5xSmxE9gZfta3qh8DwjWqZ4QN2bw1dDmcLj+0WDjP5+Xlxf+m+/cZdiUejZvHs1IVTBcrmr07tF7a3G08n9lbwJwYf783X6uBUEQDoQ/VdD81uYnWdX0A5ePvx2dSk+vywKAXm1Eo/yN/o+yRgNPPrljWxAEQRAEQfjDkSRpwDf9fu03/2JiYoiJidmjsU1NTRxyyCGMHTuWl19+GcVO4ZBw8P3UupSF28oyfFj7OeNiRjEiuuggz2ovyQHoXgUKHUSM3OVQhULi0gtslJSqKE6Oo0FdCiWQrVKSoFPTFfAxOmY4s1OnQMU6AMq9XtBoSdDraXN1EquL4fiMo0IrbQ0qA4mG+FCt3Oy96NMzJX4C9064leq+WqYnTObFstcJl0yYsOGX/TRLJoYbElApVP0aFT79fD2ffNXI5u4WVBuScVy/iNzwLOalH8XwyGF4A176PH345QCbu7cyJnoB0xInhva/Y+yN3Lr2Xnyyj3hdLCpJhdPvRKvQEKGN4LFJd5FiSqLL1c2wyPwB87Z6rFy94lZ6PX2U9lYSrjYjIeH0uVBIilBTyJRfhKeyLA/698/JmfPY0LWZ8t4qDCoDCkmBQpKI1EQMfuG0OqIuuZOmN2+hSmVHNfes0ArkI5Jn8XPbSir6qrkwfz56pY4AMqdmHk+To5mcsKxtpS92uG/j4zTYmoBg+ZCj03bfINXlc3HHuofY3L2VaQkTuWb437hq+F/4uvF7Ms3pXFRw9pD7Hp4yk5/bV+IL+MgLzw4F0ktal/NYyfNoFRpuGHklxVGFoX0yzek02pv7HUclDR27fNHwLQubFpEXnk1tlBZntxolPiLSq8FahEoJsyfod/s+AR7Z9Cxbe8rA0klv5ToemPciPrVql+VNBEEQ9rc/1d84i+o+A+DhZdf2e/6ckVczJfWIgzGl3VOr4a9/PdizEARBEARBEA4gWZY577zzQquEXS4Xl112GUZj/9qpH3zwwX4/d3NzM7NmzSItLY0HH3yQjo6O0GsJCWJF3G+BxB+gPmvFw9D5U3A77WxIOXXIoa+Uv8V/az5FkiQuV53PtLiJrK5UckjvGkx6PfkpOahHXAeSEpDBVskhxh4+al1LvbUevUqHw++gICI3dExJkrh3/K180/QDMbpoDk2asVfTnxQ3jklxwTIzMxOn8FznWgqpBnUYY4dd06/28nZ9ff7Qtt+lQvYrCGwrkxOhDee8nNO5auUtKJDwywE+rvuiX9CcE57FbaOv5abVd+P2uzk27QiSDYm8XvkOGoWaz+q/YcG4G4ZcudrkaKXXE2zUGZD9uAMeIrUR+AI+RkQVMTNxMsWRhRybtqP56LeNP/LM1pcxqPTcPPrqftcwTGPmsSn3MC1hEq+Wv41X9nNy5rGcuHPd4V+QRk9lxOjvGfGL541qIw9MXIAsy3zX9BNPbHkBWZYxq01ckD+fit4qXi7/DwmGOE7JPA6VQoV9W41qgMreGha1/MyU+Am7DFJ/aFnCRksJAItalnFY0kz+MuwCLi88Pxim+3xD7jsqejhPTLmXVkcbw6OGhc7zXOmruHwuXLh4peItHpz47377TYufxNb0cjZ0lTApbhwjo4sHPX69rZFntrwMQHlvFcekHkGdvQGnz8WDl+WSGYgm3KwgLmrwki6/ZPPZobkeLO1YfI1c+coxVGfEMyNxMtcM/9sub16W2cuocdUwPmw80eroPTqfIAjCYP5UQfOzx359sKcgCIIgCIIgCAOce+65/R6fddZZ/7Nzf/PNN1RWVlJZWUlKSkq/135ZO1o4OGYkTGFzdymbLFuYGj/xf76aWZZlmh2tRGkj0Kv2bHXlzjpdXTgbPsSokIjSRkL3yl0GzV83fh867zdNP3BU6mFclzIen7INtUKDwl4VbACoS4DYWRA7iwtkGY3hPZ7c8iJxuhjsXgef1X/D4cke3qx8jw6XhblpR3Ba1gkDArcfmhezpaecKXHjGR3zy0h0oNlJM8g2Z9LntVIcWThkgHf66QmUldnp8ycQNms901LGcVTqoaHXj0g5hKgNkbh8Lvyyn5KeUiyubqJ0kaEx+RG5PDftIdqdneSGZ3Hz6rsJyDKlPRVU9dVwWvYJ1Nsa8QQ8HJF8SGiVMkCGKZVUUzINtiZSjEnUWOsJBPyMjR3JyzOeIEYXDBQ/rfuKlR3rGB09nLeqP8Ab8NLr8fJ6xbvcNf6mAT/L92s+weqzkWVO57SsE1BvK+exLyRJ4uum70N/13zV+D1T4ycy/8dLAUjQxyEhcXr2iVySfw6PlzxPo72ZPo+VBzY+ybSESVw/8oohj2/6RaPD7Y8lrweeWQAVm2DYWLjkZlANjEdSjEmkGJP6PWdWm+hx94a2B3tPlxScO+D5X3L5Xf0ex+ljeHPWc8jIKKShv1XiD/hpdbYTrY3s9/O+MH8+D67/HjmgIN+lZ7GzCYhnUcsyjk49nKLIgkGPt8G6gVuqb0FGJlodzVP5T2FU7lmDSEEQhF/6UwXNv0t+PyxeHNyePh2Ue3Y3UxAEQRAEQfj9ePnllw/auc877zzOO++8g3Z+YfeUCiV/L7r4oJw7IAf499oHWNO5gTCNmXvG30KaKWX3O27j8Xu4buUCZjlsFAQ6yTT7id1FyAyQHZbJhq7NwW1zJgDK8OEo278NDtAlgCaq3z5Pb32JL+q/pcnegi/gI8mQQLg6jJtX382qjnX4ZT+bLFvQKDX9ylus7ljHw5ueAeC7pp94csp9JO+iDi8EyzH83L4KlaQkLzwb7RBlGDMy9Dz+XDrd7ghSTUcPCKRzI7K5evhfeHjTM8iAJ+Dl8ZLnuX3s9f3GReuiiNYF3+/42DG8Uv4WMjImtYnrV94O21a8f9P4I7OTpjMudhRpphR0Kh3n5Z7BgrX34/A6STMmE6mNABlaHG3E6KLZbNnK86WvAbC+a1O/gDN8kJrPn9R9xeLW5fhlP/W2RtZ2biDDnMaLZW+gVqi4tODcQRsD7kqmOZ2ynmDTvXRjCjetvitUIkOWZdqcwW9ZTE2YyNSEiVy1/GYqeqsBWNO5IXScNkc75X1VFEbkhUL0afGTqM9upKS7jGkJE0M1neU1S3h2URhrbacxrqWBSyavRBrdvyY0W9bAl29DRDSc/lcwBq/H9SOu4JWKt9AqtVyUv+83BR0+J22uDlodbcxOmsGc1NnBMkq/+AZDo70ZX8BHhjkNb8DLTavuYmtPOdG6KO6fcFuopMfYmFG8NexW+O+LLDT1sjjdAASD7zD10E0iN9o2IhMM+ru8XTS6Gsk3DizFIgiCsCdE0Pxb53LBIYcEt202MIo7i4IgCIIgCIIg/G/U2xpDYV6fx8rC5kWcn3fmHu/f4+mlw9nJf9WFFAU6GBU2gVPThq6LC3DjyCv5ouE7tDuHwrGHgCoMXM0QPQ0U/fvXLG1bgUJSkB+eg1/2c07uaYyJHsHb1R/gl4MlLDwBD032ln77NTl2PPYFfLQ623YbNM//4TKWtC1Ho9CwrmsTd4+/edBx5b2V3LL6Hhw+J5Pjx3PjyH8MCJuvGfE3NnSV0O3pQUIKNSkcykmZx/Jaxdt0ubsJU5upsTaiU2owKPV81PUFdbYG3q7+kKem3EdZbyV3rnsYr+xFp9JSa20gUhuBTqVjk2ULV/14N1W1ffiVHlJTtWh1Ci7IO5OqvlpMaiMXDhKidrm6CcjBhn4uvxuFJPHAxieptzXik31YvbYBpSR259KCc0kxJuL0uZgSP4G/Lr2OOF0M7a5OAObuVNoDYFzMqFDQPD52FADN9hb+ufxmHD4nZo2JxyffQ4wuGkmSmJ9zyoBzLmuL5gvLMAA+sxQxui2SCTsP8HrhxXvA4w4+NpqDYTOQbk7ltjHXhYZW9dXweEmw9Mdfh11A/k7lRnblhdI3UKEkw5SGSlJiUBkGjPm8/hue3foKAKdmHc/IqCLWdG7A4XPg8XtY1LqMkzPn7djhkOMgdzizPW7a5S2U91YxK3EqqabkIecxLmwcH3R8gE/2kahJJF2XvkfzFwRBGIwImgVBEARBEARBEIRBRWkjMaj0OHxOAFIMSbvZo78YXTQjoorYaCmhVJ3CaZnzd7uPUW3klKzjBr4QORYYO+g+I6KKWNq6AoNKz3HpR3FK1nHIssyhSTNptLdg89rJNmdyZMrsfvtNj5/Mp3Vf0+bsoCAil+GRw3Y5t253Dys71iLLMp6Ah59aloZe8wa8/cpIfNv0U+i6LWtbRYerM7T6dGcX5s/nsZLnUUpKzs4dGIoCvFX1X57e8jJdri5GR49geNQwynsr0SrVNNibUEpKYret4nX6nHxU9wWf1H1FtbUWu8/O8KgiJsSNZl7aUYyPHc2Nq+6grLIXt8ePw9BJV3svSVGRKCUVt465dtA5AMxKmsJn9V9j9dlINiQyOnoEL5e/TafbQk1fHeW9VcxOmt5v1fjuqBQq3H4P67s2o1aoOTx5Ft82/UhuRDZ3jL2RrF80bjwz52QKInJx+d2h5oKbureGrrXVY6O0p4JpCcHr8fN6Fx98bycpVsnlp4Sh1ynYHA4tcWFEO2U0YdHIyZn9JyUHwOfd8djdv8zFzp7c8iLVfbUAPLHlRZ6ccl/oNW/Ay93rH2F912bGx47m+hFXoFQEv6W8wbKZKmtwv3BNOBu7SviycSFppmROyzoBhaTg68YfQsf6uvF78sKzKO2twBfwoVaoidD0b5gIQEoWEnAGhQNfG0ShsZDH8x6n3lXPCNMIdErd7ncSBEEYggiaBUEQBEEQBEEQhEGFaczcOe5ffN+8mHRTKoenzNqr/RWSggVjr6e0p4JYXTTxhrgDMs9rhv+VcTGj0CjUTE+YDARLBtww6kouKzwPh89B1C9q2gJE6SJ5euoDWNzdxOpiQiHgUN6t/gibz47L58KoNjA+dgwev4cFax9go6WEEVFF3DbmWjRKDWnGHatIwzVh/coX9HmsLGtfRbIhkVlJ05iWMAkJadDz19saeaXsLcp7g+UlSnsryAvPZpNlK72ePpKNiURpIonRR2H3OojXx7K9vHqGKZV6WxM5YZlcM/yvZJjTCMgB9CodAbkHj6YPGT8x7mzywiL5qWUpp2efMOT7Hx87hkcn30WVtZYpceMxa8xcXng+Z/14GWqFmlRjMu9Vf7JXQfPqjnW8XvEuACXdpdw57l+cmXMSJpVxwM9ruzExI/tdyzRjChqlBo/fg0GlJ29biQyrPcADr/bg80NZrZeYCCUpY9fxiftZ3IUTqGnN5IrZI5lQ/IvyJxotnHIZfPoaRMbA0Xu2iv+Xde2XNP/M6vZ1IEksa1vFio41TImfQEAOYFQZiNRGIMsyKcZE/r3uQdz+4Arq4A2To8kOy6DGWgdAdlgGzY42csOysLi7MaqNRGoHCZr3QaoulVRd6n45liAIf24iaBYEQRAEQRAEQRCGlBueHaptuy9UChXFUXu2uvLXnOOw5JmDvhahDSdiF4GcRqnZo7rCvZ4+Pqv/hpFRRTTYmymOLOD+CbexrH0VGy0lAGy0lLC8fTUzEqeQZkrB4Xdi9zq4rPD8UGjqDXi5buXtoTIe14+8gmkJk4Y8r1JSolQokZDwyT5AYk3nBsxqIxZ3N23Odq4supS5aUdSa6snLzwbi7uHH1qCvX7mpc/h7vE3o1IEf/1XSApuHnU157dfS0WHHY/aQqe2m629McxInBx6r4+XPE+ny8KZ2ScxMW7HSvLRMSP6NU2cEDeGOSmH8nPbSlSSiiRDwm6v5c7sPke/xzavPVRjeXe+bfyRJ7e8CMBpWccTrYtieGRhaOW41yfj8+8Y73LLlPVUIkmQMXklsJITp00YvKHj9KOC/2zzTtWHfN30A9nmDK4e/pfQz/OvYYfyxLIbCAT8/G3aSTv2L9uA6fV7IKoKEjMgKhaTKlgKUyEpmBQ3Fs22FfDjY0fxYe0XoV07nF0A/GXYBWSYU/EGfBydehgtjjaitJGY1SYitRHkhGXt0XUSBEH4XxFBsyAIgiAIgiAIgvCn0mBrQqvUDFrKYihahQaDSg/AsIg8Tsmch0apGVC+YPvjF8vewKDUY1Dq+bjuC45JC67y7XR19asVvcFSssugOdmYyLm5p7O1pwKr14ZepWN4ZCEyMmHqMKK0ERyaPIM1nRsojirApDZhUpt4ftrDtDk7yDCnhULm7YqjCsmNT0Kh91BrDZaciNZGMDV+IgCvVbzDyva1ANy/8Qnenv1Cv7IgOyvpLqWyrwaf7KPX28fFBbuuwf1LU+MnsihuGWs7NzI+dnS/UHt33q35KFQz+seWpTw//ZF+r0eFKzlvnon3vrWTFKvi5MONNPom8m3TT3gDXgoj8ojX736VfZ21gTcq3wOgw9nJ5w3fclLmXAByvv6ax6q23ajo+hgmbgubP3+T8T1qziaGdb5uJkz+B3H6GP65/CYs7h7OzjmVQ5NmEK4JY2R0MVavne+afiJGFx36rKgVao5LPzo0j+ywTB6bfDeVfdWMiCoiXBO2x9dKgFUda+lydTM9YRJGteh/JQgHggiaBUEQBEEQBEEQfmOa7S383L6KbHNGv9Wjwq/3avnbvF/zCZIkcWXRpRyaPGOP9tOpdNw25jo+rvuSeH0sp2YdD8DI6GIuKTiHtV0bGRczihHRRQChUBpAv9N2rC6G7LBMynoqAJgQO3rIc9q8Nr5sWEh5bxVFkflIBFfeTk2YiFlrxuFzcETyIfxj2U24/W6UCiUpxiS8AS/n5Z7B5PjxQx57StwEGm3NQDDMTjDEhxoh+gK+0Di/7A+FuYMp7alAKSlI3VYqpMfT2+/192s+4fvmxRSE53Jy5lwitOH9Gt+pFCpuGX3NkMfflURDPK2OdvwBPxssJRS/P42CiBwem3xP6L2cdKiRkxK2gkIJ4dFEUcQzUx+gzdlBYWTebsulQHAF8pCPNTuV99DutB0RXJV9ak8Mp+pSIeMYHtj4BJW9NQA8teX/eO/Ql0I3Aa4svpSL8s9Cr9IPON/OUk3Ju2zuJwzu07qveL70NQC+avyeRyffdZBnJAh/TCJoFgRBEARBEARB+A3p81i5ZuVtWD02AG4dcw3jY8fs8f6yLLN6dR8A48aFDV4W4A/M5XPxesW7vF/7CeHqMI5JO4Jz804Pvf5ZwzdA8Dp91bhw0KDZF/Dh9rsHrHocFpnPsMj8AePnps9hbvqcfs9dWXQJz5e+hl8O9Fvlq1KoOD79aG7ruheVQkWttWHIn+8d6x5iS3cZVq+Nbk8PacYUFJKCwsg8jt626vXrxu9DtX3Leyppd3YSrY3k/g1PMDl+HM2ONo5PP4pZSdNY1bGWZ7e+ikGl56riy5kSP541nRux++xMihtHhjkNgPk5J9Ngb6LL3c3ZOaeiVWoHnR/A+NjRvFP9EU6fk0RDPLk7lXOo7K3m1fK3geCK45fL/0NueBZ3jL2R/IjcIY85lOq+Wn5uW0l+RA7jY8dw9fC/8m71RyxvX82G7hJ8AR+drV08uvkZHpj47+BO7z4Li7eVpTj8ZDjuXOINccF64bIMrQ0QFgWGoVe4ppqSuSB/Pl83fk92WAbH7FSDeuNRh/K+aiWxPhUXHfV3QrcUTr0ctHpwO+GYswBQSTsiGJVCFbpxsJ1YZXvgbO4uDW1X9dXg8Dn63fAQBGH/EEHzb51aDfffv2NbEARBEARBEIQ/tBZHayhkBijvrdqroPmFF5r49NN2AObOjeOSS1L2+xx/y54vfY17NzxGl9uCUlLS5uxgRNSw0MrwTFMaW3vKAULB6s4qe6u5de29WD02Ts6c1y+k3htJxkRuH3v9gOer+2p5aNNTABiUet6t+ZhTso4b9BiVfcHVr2a1iRRjEtMTJjEudhSZ5vTQmOLIQvQqPU6fE61Si3lbHeAmRwuLWpcjAY+WPMeo6OE8tvl5ej3BmxAvlf+HO8bd2K+x3nZx+lgennQnbr+b8t4qOl1dQ9ZNTjOl8PTU+6mzNVAQntsvLPXLwQLJNq+DGmsdWoWWPq+Vj+u+4rq9DJotrm5uWHUHTl+w1MftY6+jOLKQi/LPRqPQ8HXjD6GxgZ2b8m1cHvy3vQ9eewjqK+DMKyAqFp79N5SsBoMJrrgbUjKHPP8JGcdwQsYx/Z7z+D3cWfMqzoxIAPSe9VzE8OCLpjCYf0W/8efmnk6vp49uTy9n55wy9Gpqtwv++wJ0tQXD8YJRe3CFhF2ZFDeWZe2rkGWZkdHFImQWhANEBM2/dRoNXHvtwZ6FIAiCIAiCIAj/IxnmNDLMadRa69GpdEyKG7dX+69ataN0wYoVvX+6oLmirxqX3wWAXw5gcfdsa6IXdMvoq/mk/isMKgPHph0xYP8Paj8LBf3v13zCKVnzBg2lWh1t1NuaGBaZh0lt2qO5tTs7uH7Vv6m21tHlspAfkUtWWMaQ449InsVn9d8gSRLn5p7O4SmzBoxJNiby+OS7Ke+tIkYXzYK1D7C6cx1hajNOnxODSo8/4Mcn+/oFm6rdlIzw+D1ct3IB1X216FQ67hl3Mznhgzefi9FFDxpE50fkclLmXF4qexONQoNWqcHmtSMjD3KUXWt2tIZCZoAnS16k02Uh0RDPv0b+g6NSD2NRy88UROTwj+LLduxYMBpWLISGSgiPhrIN8MGLMPfsYMgM4LAFx6RctFdz8ga8oc8aQJ/XuuPFLWtg+UJIzYbDTgRJIkoXOejNhwG++A/8HFx5T00p3PNG/7Icwl47JGk6KcYkLO4exohyRIJwwIigWRAEQRAEQRAE4TdEq9TywITbKeutJNmYOORK0qGMGRPGF190bNs2H4gp/uZYPVZ8sp9IbQRnZp/Ep3Vf4Q34UCvUHJ4yi3ExO+ogmzVm5uecMuSxYvUxoe0wjRmNQjNgTGVvNdev+jcev4ckYwKPTrqrXx3moTTYm3D5XKSbUtAo1AyLyOPCvPksavmZ4VHDiNRG9Bt/aeF5zE6ajkFlCNUcHkyCIZ4EQzz+gB9PwMOwiHy8AR8On4MwTRwnZhxLjC6aa4f/jf8rfwO9Us8lBefscq61tnqq+2qBYDmSn9tXDRk078p5eWdQGJHHTavupM3ZgVFt4JycU/f6OLnhWWSFZVDdV0ujvZnlHWswq414ZR8/tS7jhV80AgyZfwUUjoFnbwftthsGPi+ERQbLZTjswecSUgfuK8uw4ntw2mDiYQPKaxjVRs7JPY03K98nWhvJaVknBF+wdMDzd4LPB2sXB1c3Tz584PGH4tjxjQY87uB8D1DQvKR1OSs71jIqupjZSXtWr/z3Kjc8+2BPQRD+8ETQ/Fvn98PaYLdfxowB5e4bFQiCIAiCIAiC8PumU+kYGV28T/tedlkKI0eakWWZKVMi9u/EdmL32nlo09PU2xqZm34kx6UfPei46r5aqvpqGR0zfK9D8z2xuHUZD296Br/s5/y8Mzkh4xgWz/2cpa0rKIzM2+vrOD/7ZAA6XV2cmHFsqFnbzlZ3rsfj9wDQbG+l2lpHUWTBbo9dGJFHijGJRnszhZF5nJ17KretvY8mewtmtZF3D32JaF1Uv332JhxTSAp0Si22gA+1QsWJmcf2W91bHFXII5PuYrNlK0taVwwow7GzRH08YRozfZ7gKt28XxHSjYwqYkbiFJodrVxWcB6JxoRdjvcH/PR6+ojURoRqjG+/AfNz2yruWPsgrc527F4HbY52on4R0PejUMC4GfD3u+G/zwfLZJxwwY5yGcsXBkPmqUcO3PezN+Drd/nB1MuakucYe+KNHJI0vd+QkzPncVLG3H610J3drWh9XhTbazBbOvboOoUccQpUbwmWzjj6TDAemBtGFb1V3L/xCWRZ5ofmJcRoo0PNLAVBEPaFCJp/61wumDAhuG2zgVE0BxAEQRAEQRAEYWiSJB3QgHm7j+u+ZFXHOgBeLH2DSbHjgg3WdlLaU8GNq+7AF/ARoQ3nqSn3E6bZv6HZB7Wf4QsES2O8V/MxJ2QcQ6opmdNzTtztvnXWBno9fRRHFaKQFABolBrOzztzl/sNi8hHkiRkWSZcE0aqMXmP5mpQGXhk0p1UW+tINibybdOPlPdW0umyALBg7QM8PuWePTrWYCRJ4ubRV/Nm5ftEaMIGfR9bu8v51+o7kWWZd2s+5vLC83i76kN0Sh1XDb88VLfarDFz/4TbWdq2gixzOuNiRw841p56ZPOzoc/Kl40LGRUzfMixVo+VG1ffSZ21gcKIPO4c9y80yuCqco1SQ3FUAWatiZywTDpcXcxMnMoxg5RACWlrgpJVkJEP/36p/2spWXDyLlZpV2+lROfg4dgW8MBPm54hQR9PYWRev2E7h8zPbHmJLxq+I2aUlbs260iKSIMpu5jfYGIT4ZZngyuqD2Azz3ZnJ/JO9azbnHsZiAuCIPyCCJoFQRAEQRAEQRCEX0WSpH5h23abLFtCIXCPu5daa/1+XzGZZEigsrcmtL2nfmxewsObn0GWZaYmTOSGkVfu8b4joou4b/xtVPZVMywyjw9qPwPgpIxjMe8mSNepdAyLzAdgeGQhjm11h9UKNV3bAudfoyiygLvH3zzk6xV9VaFw0eVz8fCmZ5C2rbx9rvRV7hl/S2hssjGRU7OOp9XRxn0bHgfg/LwziNPH7tWcqq21g24PZmnbSuqsDQBs7SlnTecGJsePD70eo4vmquLL+bJxIRmmVC7MPyt0k2CAXgs8dHWwPIYkwT/uhexhez7x8bNob1ka3I4IllRpc7YPCJq3a3O080XDdwB0pibzybgZXDbikuCq6n1xAENmgHGxo8iPyKGsp5JMczpTdrrOgiAI+0IEzYIgCIIgCIIgCMJeOz7jaGqs9dTZGpibduSg4eOo6GLeqvoAb8BLjC6azG2rZfenvw67kDhdLO6AG6fPxQWLrmB4ZCF/L7p40LIX2/3U+nMocF3augLvcC9qhXqPz1sYmUdhZB7/XvtAaLVurbV+z5q9AQE5QLIxkWuG/5XXK98jXG3m6LTD9vj8u/Nlw3es7lzP2JiRHJ26oz7w+NjRvF39IVaPjQRDHG6/h253DwBKafBSjQ9teprSngoAej19zE+by6ufXI+5z8Zfiy4has6u6z3PSTmUV8rfCm0P5cfmJTy99SVKekrJMWeiU+mI26lm9nYzEqcwI3EKALIs839lb7CmcwOjoou5OP+cHTc9mut21GCW5WBjvb0JmqccwaSUNHJKHqVS0UdueNagzTlbHW1s7i4l1ZiMTqXD5Qs2CIwJT9r3kPl/IFiOZAE9nl7CNWFDB/aCIAh7SATNgiAIgiAIgiAIwl4zqAzcNPqqXY7JDc/mscl3U2OtY0RU0W5X++7rPM7NO50NXZu5efXdAHzvXMyIqCIOTR66uVlhRB6rO9YDkBOeuVch884a7c2h7SZHyx7t82XDd9y7/jEUkoKj0w7jzVnPIiPvU7O9wWzsKuHpLcEyESvb15JiSGJEdBE/tSxlQ1cJF+TNJ04XQ3ZYBnW2Rp4rfRWtQsNlhecNerxeT19ou8fTyz0Lb6S3rwoAzcpHuX7UbEhIGXI+J2XOZULsGABKukt5asv/MTtxer+Vwb6Aj8dKnkeWZeJ0sWiUGq4fcQXZYZlDHrfT1cWli69iSdsKYnRRNNiaGBaRz7SEScEB6XkQkwCdraDTQ1H/kFiWZV4u/w/vVH9IvD6O60b8neKown5j9GkFPJz6DD2eXiI04QNW7nc4O/nH8puwex1olVouLTiXNV0bSDYkcvwQdcsBaKoFex/kDj/gK5d3RZKkAU0oBUEQ9pUImgVBEARBEARBEIQDJsWYRIQm7ICEzDvbXv6hx9NLk6OFN6reY1zsKMI1YYOOPyXzOOL1sfR4ejk0aehAendOzDiWp7cGQ90TMo7Z7fg1nev516o7aXa0opSUaBrVnJQxd5eB6t7q8fSG/m312tlg2QzAgxufAuDzhm+5ZfTVGNVGhkXm89jku3d5vPPyzgiW2JAkzs05nQdrbwy95pYCexSUppqS+b55EU9t+T8AfmhewgvTHwmFnBISKoUKX8BHrC6a2UnTmZowcZfH/LJhIe2uTgA6XRYSDPGhUi0AGIxw3SNQWwaJ6RDZf3X0c6WvcPf6R3H73cTpY1nx7q0Ue/OhcAwctqPG967C2LLeSuxeR/Ba+N34Zf/uy7As/w7efDy4ynrsDDj/2l2PFwRB+J0QQbMgCIIgCIIgCIJwQPR5rNy46g7qbY2MiRnBLaOv2WU5i1+jICKXFGMSy9tXE62NpsPRyavlb3NF8SWDjpckiZmJU3/1eeekHhparRuli9zt+Bprfai5nV/245P9RGjC9/h8Lp+LJ7e8SL2tiXnpczgseeaAMZPixhGnj2Flx1rMahMf1H4eKovR6bJQY63jhlX/5sL8s3bb+BBgSvwEJscF6/dKksTfpt/I89/cgtnu5pzxl0B8Mg6fg06XhSRDwpA/4yZ7a2jb7XfT6eoKBbhKhZLrR/yd1yvfI1ITzrm5pw96jI1dJdTbG5kSN4FoXSTh6jDidDH0eq3MSpjK9ITJ/XcwmGDY2EGPtbpjPcpt5SICPR1MXdoB4S4o2wBJ6QP2C8gBynoqidCGkbitHnhBRC5mjQmrx4ZOpWN41B6U5lj9UzBkBli7GM69+jddYkMQBGFPiaBZEARBEARBEARB2Gvtzg5aHe0UROSGgtNf+qFlMfW2RgDWdm5kc/dWRkUPPyDzean8TertjSgVStwBF5Ik4Q14D8i5fml7wOzxe2hzdpBgiBuyFMfU+Al8FJaFL+BHp9Ry17h/7VFAvd1HdV/wU8vPADxe8jyjoouJ0UX3G6NRapiXPocWRztKSYEv4CPFmESKMYmtPeUY1AbC1WF8Vv/NHgXNQL+SETPTDmHmRUtCj5vtLVy3cgG9nj6GReZz17ibBg2bD02azrdNP9Lt7mGaNpvsV14EuxXmnQvF46nsq8GoMjAudtSg12R5+2ruWvcwAB/Ufs5Tk++jz2OlxlrPESmzGBszao/ey3bjYkdRa2sI3giRI8gw7fSi3Tpg/L0bHmNZ2yqUCiU3jvwHE+PGEqOL5rFJd7Olp4y88OxQAL1LmQVQuj64nZ4nQmZBEP4wRND8W6dWw2237dgWBEEQBEEQBEE4yEq6S7l1zb14/B4KInK5Z/wtgwaLsbodpQokSSJKu+eB6t5qsDWjQEGmKY0mRyvZYZnMzzn5gJ3vl/o8Vq5deRvN9lbSzancN/5WjGrjgHGJhgSemfoArc520k2pQ4b0Q/HsFJ7Lsty/VMROJsWO4/2aT+lx95JhTmN87GimxE/g4U1P82PLUtpdnSQbEvH4PXs9h196vOQFFjYvQqVQYfc5qOit7ld/ebskYyLPT3uYHk8v8e+8ilSxOPjCy/fz87XX8Gbl+wBssmwhJyyLgojcfvtvtmwNbXc4O2l3dXJ69onsq0sLziNCE8FbVe+jVobTnSuRWNMABaNhVP/V7javjWVtqwDwB/z82LKUiXHBFc+x+hhmDtK0cEhHnwlxyWDrhYn7rwGkIAjCwSaC5t86jQZuv/1gz0IQBEEQBEEQBCFkSetyPH4PAKU9FbQ620kxJg0YNyV+ApcUnMOWnnKmJ0wizTR0w7hf69i0I9jSU0aMLppLC8/jvLwz9stxN3Rt5tWKtwlTm/l70cVE66IGHbeifQ3N20pD1FkbWNe1aUdTup002Jp4vfJddEotF+TN3+uQ94T0oynrqaTO1sBx6UeRYIgfdFy8IY5npz5Is6O1X6D9z+GXs9GyhRZHGy5/sAzHVcP/sldz2JksyyxrW0VADuDxe2h1thO3i9BVp9KRoNLtKB0BEAhg89j6jbN5bfzSxLixfN7wLb6Aj0xzOo32Zpa1r2J6wmSSjYl7PXdJkljRsZqALNPltnDb+ESe/+fHg9acNqqMJBsTabIHGz7mhv2Kxo2SBONn7fv+giAIv1EiaBYEQRAEQRAEQRD2SkFELp/VfwNAtC6KGO3g4SvA3PQ5zE2fc8DnNDl+PC/PeAKn37nL8gVOnxOLu4dEQzwKadclC2RZ5s51D9PqbEev1GJQ6blu5BWDjk0xJiFJErIso5AUJA0xh7vXP0KjvRkAl9/Nv0b9cw/fIVhc3XzT9ANFkflclH8WmWHpQ45tsDWhU2rJDc/u97xaoUatUIduDJT3Vu3x+QcjSRJp5hQ8AS8On4OjUg8bEMZv6NrM86WvoVfp+Gfx5cFQeN65YOkAaw/yceeRaIwkJyyTGls9k+PGMyZm5IBzDY8axhNT7qXZ3orVa+XeDY8B8En9Vzw39aF9ajgZ7vBx+QeriO51UjeiEKbvCJk7XV08uPEpOl1dzM85mXvG38K3TT8Sq4vmkKTpe30uQRCEPzoRNP/WBQKwddvXgwoLRe0mQRAEQRAEQRAOupmJU9EpdTTYm5iRMBmdSnewpwRAhDacCIZurNdsb+H6Vf+mx93LiKgiFoy9fpfNCd1+N2u7NmDz2lFICoZF5g85tjAyj5tGXcUGy2bGxowkKyxj0HG93r7Qdo+7d/dvaptAIMANq/7N2s6NNNibSDEmMyq6mIAcYHT0cP5WdFEoOH+l/C1eLvsPLc42jkiexX0TbutXxuOw5Bm8XfXhtu2BzQR3ZV3nRj6o/YxwTRgnZBxDdlgmt4y+mjcr3ydMbebignPw+D28Xf0hXS4LJ2Qcw0Obnqbb3QPA86WvsmDsDRCTANc8CMDd6x5m+erVqBQqbh51FeNiRw95/u21pl8pfyv0nNVjo93VuU9B8xWWZNodSgIqI8fUB6C5LtgIEHiz8n1KukuBYHmQt2e/wKlZx+/1OQRBEP4sRND8W+d0QnFxcNtmA+PAGl+CIAiCIAiCIAj/axPjxjKRsQd7Gnvlh5YloXB3o6WEqr4a8n9RB3hndbYGEvRx1AeaUElKMs07VhB7/B4+qvsCl9/NcelHEa4JC16TuP7X5Jc1kC/MO4snt7yIVqnhrJxT9mjeC5sW8XjJ86zuXI+8reREl9vCV40L0Sm0fNf0IwEC/KP4MgA+rvuSir5q/LKfrxq/Z0R0EZcUnBs63vycU5gcNx6FpCDDnLZHc4BgyZSrlt9Cna0BrVLLyo61/LXwQjZ1b+XQpBnMSJwCwEtlb/Jh7ecArOvaFJozgIzc75h9HivL21cD4PV7+bbpx10GzdtNjZ/A5w3f4vK5yAvP3ueyLJHR6Uj6OCQkjLowMOzoCCjRv4TGLx8LgiAI/YmgWRAEQRAEQRAEQfhTSDUmh7Z1Kl2/ZoWDSTYmkhWWQZQ2EkmSmJYwMfTa01tfYmHTIiDYHPG+Cbf129cX8HHnuodY07mBgohc/j32BvQqPYcmz+CQpGlISEiD1AIezAtlrxGQA4SpzbQ7O1Er1URowmlxtGLb1gzwg5rPuLzwfLRKLemmlFDjOr1Kj9UzsN7xUCuuB9Pp6kKn1FLSXYrL7waCq72bHa3cuf5hdEotXzd+T4QmnBHRRbS7OkP7drt7uHn01bxS/hZapYZzc3aqne33Y1yxGLOlhyVyIxZPD1XWWiI04Vw+7IJdzik3PJvnpj5Eq7OdnLBM1Ar1Hr+fnT0Z3YIv3UOcxU7U7MM5KiI69NpZOafQ4eoKlc74tU0TBUEQ/uhE0CwIgiAIgiAIgiD8KcxInILb76HaWsvMxKlE6SJ3Od6kNvHghAUs71hNpimdEdFFodfqbY2Dbm+3pnMDazo3AMGGiYtal3Fkymwa7c30uHsZFpm/xytkw9Rm7F4HWWEZJOjj0Co1TIwdS1lvJcvaVxOuCSNWHx0qnbFg7A3IBBsUFkXmc1r2CXt0nsG8Wv4279d8gkap4dTMeSQY4uhyW9AqNQyLKKB5W3M8gGZHKyOiizg+/WjWd23C7nVwcua80Crv+zc+wTUrb+XvRRcxO2kGvP88ysVfkJbYCLF9qHVq+jxWPmv4BrPGRLIhkVmJ04YM5KN0kbv9Ge7Oiq719I4LNvbLMNs46hfHv2Pcjb/q+IIgCH8mImgWBEEQBEEQBEEQ/hD8AT8uv6tfPeJfOjxl1l4dM94Qx3HpRw94/ti0I3hs8/ME5ADzBml2GKEJ6/c4UhPBktbl3L/xCWRZZnL8eP416p8E5ADL21ejVqgYHztm0Dn8a9Q/eb3yXar76qjz1lNtraO8r5pHJt7BsMh8utzdnJl9EmqFGqvHyl3rHqbZ0colBedwQf780HEabE18Wv81sbpoTsg4Zpf1qSF4Pf9b+ykQLAGytaeCl2c8QbW1lhRDEgn6OP615k4qe2tINiYyJX4CEGwW+drMp3H53YRtq5v8ZuX7ePweAF6reDcYNNeVA2AKKInzSLgNapCguq+ONyveR6VQUWdr5Ly8MwaZ3f4xOno4P7YsDW3/Jqz+CVrqYfwhkLBvJUEEQRAOBhE0C4IgCIIgCIIgCL97zfYWblp9N52uLg5PnsUVxZcc0PPNTprBiKgivAEviYaEAa/nR+RyRdElLGtfxYioIibEjeHOdQ+F6hUva1uFy+fi2dJXQiU4Ts6cx7l5pw84VoY5jVtGX8O71R9x65p76fUEGwq+VP4fPj7ijX5jP63/mq09wQD3w9rPOTRpBunmVHwBHzevuRuLqxsAT8DD/N3UiFYqlMTrY2l1tAOQZEwg2ZhIsjExNObBCf+m09VFtC6qX3CtUWqotzXyQc2nBJBhe21mSxvRliboeTUYpNZXcnFXHLaMTNZGS+SF5VDaUxE61vZmfAfKP4ovY3zsaNQKNZPixu3bQQIBUCj2z4SWL4Q3Hg1u//w13Po86A3759iCIAgHmAiaBUEQBEEQBEEQhN+9zxq+odPVBcC3TT9ycuZcknYKRCt7q6my1jImegSx+l3XZt5TMbroXb5+eMqsfiuoCyJyWdG+BoB0cyo6lY7VHetDr6/qXDdo0Lzd0amH8UTJi/R5rMTpY9AptQPG6FX60LYkSaExLr8rFDJDsMzFrsiyzEZLCefnncmGrs2Ea8I4OXPegHFKhZJ4Q9yA56v7arli2b/Y0LUZGZlhkflM0mYRVV7GWd2xsPV9OOcquPEJ4j1u7s3MD+372Obn+K7p/9u77/gmq/0P4J/s1Sbdu7SssmcBKXsvRUCRKYKiV69y8eoPFa8D0OtCxT3Q6wVUUBzgRVEUkCGCLFtECi2WFgq0lpbulaQ5vz9iQtOmI13p+Lxfr7x48jznec43OUk5z7en5+wDAAwPGlxtnPUlk8rsixi6LDsTePMJIOMSMHIqMPMux+PGUuDyeSAgxGGRwWpdPHdtOz8XyM1iopmIWgwmmomIiIiIiKjFK7+wn0qmgqfiWmLvdHYiHj32NMosZfBSGfDWkNX2KR2aihAC1/lHQyvToKSsFONCRwIABvj3tY9ojvbrU+01PBQe2DR6LV787U3kmwrwt663VSoztd1EpBf9iXP55zEpbKw9Ceyh8MCk8LHYkbobGrkGN4RPrLau106ttcd1T7dFuL7dBJde75ncs8g35sMsrIsVlpSVYKA0BNNOGAFxEfAwAPu+Bm5cCHRxfN1Le/wNo4KHQivXoLOhY5V1/Jp5Aom5SRgcMACRnu1ciq9B7N0G/Hnx2vaI661JZQAoLgLWPGSdAkPvDfzfS4Bv5YQ8rqQBO78AdHpg0mxg4Cjg0A9AaQkQ1RvwD6k5juS/Rn2379ogL4uIqK6YaG7uFApg2bJr20RERERERFTJje0modhcjNTCy5gSPg6e5RLJJ7PjUWYpAwDklOYiJf+Cw8J+TWHNybexN+1nqOVqrOj3kD3RvbTH3zDQzzp1w6AA53M0lxfuEYrXhzxX5XG5VI6/d7/D6bH7ui/GLe1vhE6urXYeawDYl3bQvv1T+i8uJ5r7+fZCgNYPKQWpgMT6i4D+CWnWaSayrwBXLgOeXtYRwUufBUqLrUnVwFBIJBL08e1Z7fVjM3/DiuMvALBOEfLO0JfqvTCgyzwM17blckBdbuRx0ilrkhkA8rKB3w4Bo6dVvsa7q4A/L1m3iwuAOfcBK963vkeh7QGZrPoYtm8EvvvUuj1xFjB1Qd1fDxFRPTHR3NwplcCLL7o7CiIiIiIiomZNJpVhXqeZTo/18+2FT5O2wmQxwU/tiw76iCaNLdeYZ19wrsRcgh8u7UFPn24AAKlEiqFB1zVZLAEa/1qV6+HdFSeyfgcAdPfu4rRMfHYC9qb9jI76SEwMG+NwLFgbhLXD1uC3rHhAAvTy7gb/408BYR0ATwOQnmqd19hSBrz5BNIkRbDIZQj92/PWkbw1OJt3bYqJInMxLhWlNUyiWQggJRHQewG+gdWXHT0NyM+xvpZhk63n2ASGAQolYDICEgkQ2sF5XVl/Xnue+dd0Jnovx2tV5+jea9vH9jHRTERuxUQzERERERERtWqdDR3xxpDnkZx/Hr18usNDUcv5chuITq6Fr9oHWSVXAQDhutBGrzM904y3P8uD0SRw5ww9OrVz/heyJosJBaZCeKu8HPY/3vdB7L68Hzq5FiODh1Y6L6vkKp44/hyMZUYAgFqmqlTOT+2LMaHD7c/jRw7Bf/btg8HPgod0XaAFALUOOyQpeCvYOn/0wmP/wcyo12t8fTEBA7El5RsUmooQ6dkOnfVOErlOWIQFOaW58FZ5QSKRVC6wbjXw6wHrSOLFjwK9nf8SoNBUiM+S/4eTIclQhMrRT3cJs4W4dk3/YOtI7d+PAB26AVG9Kl9EIgEmzQG++RhQqoCxN9XqNTjo0O1agrpDN9fPJyJqQEw0N3cWC3Dhrz+3adeu4VayJSIiIiIiasWMZUZcKkpDsCYQarkaobpghJZbHLApyaVyPDfwcXybugsBaj/c0K76+ZEbwlub8xCXYE0Cv7ghB2ufqDyS+XJhGh499m9cLcnG8KDBeKj3P+yJUrVcXe10GZklWfYkMwBcLLxcY0yrjQeQ1ceaDF3j3QuPB90CePniq3UTAIu1zLeaP+F8XLqjcI9QvDv0ZVwqSkNHz0io5eoazyk0FeLRo/9Gcv55RBk64pkBjzmeV1JsTTIDQFkZcOTHKhPNb8Z/gJ2X9uL3q6ehU2gRn5OIQI0/RodcS6yjfRfrozqTZgNDJ1kTzaqaX0Ml85YCHbpbR0fHjHf9fCKiBsREc3NXXAy0b2/dLigAdNXPo0VERERERNTWFZgKsOzwClwqTEOgxh8vD34aBqXerTEFa4OwuMutTVZfqVHYt0tKhdMyOy7+iKsl1pHEP6X/gjkdb0I7j7BaXb+jvj36+vZCXNZJ+Ki9MaZ8grUKJovJPniqRC4BIqMAAJExM3Hp3C5ArUFkxIBa1Q8AXioDvFSGmgv+5VDGMSTnnwcAJOYm4VhmHIYFDb5WQKUGAkOvzZkcXvVChOnFf8JkMUNAoKSsFACQa8yvdSwOPGv/GiqRy4Fhk+p+PhFRA2KimYiIiIiIiFqV2KyTuFSYBgD4s/gKjmT8ivFhoxqlrgJTATac3YwCUyHmdJiBCM/wRqnHVXfe5IkX1+fCaBJYMsd5kj1IG2DfVsvVLiXj5VI5VkU/gj+LM+Cj8oZKpqrxnPt73I13Tq+DVq7BneWS7v8c8AA6BHSDRVhwY0TjJU0D1H72bYlEggCNn2OBsjKgcy/r4n0DRwMTbqnyWjdHTkVKfip81T7QybXobOiA8aEjGyt0IqIWgYlmIiIiIiIialXCdCGQSqSwCAskEgnaeTTenMj/SfgYuy/tB2AdJfvBiNcarS5XREUo8f6K6hf+mxw2DiXmUqQUXMCE0NEuj/qWSqQI1gZVPpCaBBQVWBf1KzcP8qCA/hgU0L9ScbVcjVkdprtUd1309u2BB3v9HbFZJzHQvx+iDJ0cC/y4FTiww7r9yy7g+vmAztPptYYFDUYfnx4oExZ4KHSQS5leISLiT0IiIiIiIiJqVdp7RmBV9CM4nnkCfXx6oItX50arK+uvqScAILs0B6L8gnDNnEQiwU3tb2jYi/78PfDJm9bt6BHA7Q817PXraXTIcMd5lMvLu9aWMJYCxYVVJpoBwFNZ9TGciQO+/wzw9gNm3g1oOQ0mEbV+XFmOiIiIiIiIWp2+vr2wuMutGODfr1HrmdNxBnQKLSQSCW6PmttiksyN5vj+a9uxB6yL1P0l15iHs7lJMFvMVZ5eZC6q9nijGjkV8P1rOpGRNwB+TkZr14bJCLz/DHD2JHBkD/DtxprPSb8InDpmTXATEbVQHNFMREREREREVEc9vLti0+j3YLaYoZQpnReyWICfvgVyMoFhkwHfwKYN8i9XS7KhkMqrH4lbXx27A4m/Wbc7dLNPnZGSfwHLjz6FQlMRunlF4dmBj1eabuLTpC3Y+McX0Cm0WNHvYXTzjrIfKzIXYfel/fBUeGBk8NDGSej7BwMr/wOYTYCiirashrHMiPfOfIjLV5Pxf/np8FV6WQ8UFVR/4ulY4N1V1jmiI6OAf75gXeSPiKiF4U8uIiIiIiIionqQSqRVJ5kB4IfPgW8+tm4f329NZkpr9wfGW5K/QXxOAoYHDcbI4KF1jvGTpC+x6Y8voZAqsLzP/U7nSm4QU+YBgeFAYR5w3Vj77v3ph1BoKgIAnM5JRHL+eXQ2dAQy0wEhYPb1x9ozG3Ch4CLkEjk2nP0Uzw960n7+U7++hFPZZwAAl4rSML9T1Qv11YtE4jTJnGfMx65L++Cj8sKokGFOT/3q/Lf4/uKPAIC13WRYlgIo/UKBibOrr/PEQWuSGQBSEoHsK9akd3lFhcDebYBMBoyeBihrXnyRiKipMdHc3MnlwL33XtsmIiIiIiKiluVyyrXtq1eAkiJA61HjaQfSf8G6xE0AgCNXfkWERzgiPdvVutqdF/di9+X96KRvj+2pOwEAJosJX53/1p5oPp4Zh23ndyBUF4xFnedWnzCvDYkEGDCi0u4OnhH2bZ1Ci0BNALB/O/D5WkAIyKbeBpGahBl/ZOKSXo54wxl7eSEETuck2p/HZyeiqf3r2L9xPj8VAJBZehUz299YqUyRudi+fah7CLLuXuN8scSKOva4tgihbyDg5Vu5zLrVwOlfrduXzze7ua+JiAAmmps/lQp46y13R0FERERERER1NWQicPKIde7egaNqlWQGgKul1xanE0Igx5hb6yovFl7GG/HvQwiBU9lnIADYJpsI+Sv5mW/Mx7Nxr8JYZsSvmb9Br/DEnI431boOVwwLGgwASM6/gOFBg6FXeloTzX/N4SzZ+z+supQPS6ERUokJ58KupSskEglGBMVgb9rP1u3gmEaJsSol5hJ7khkAEnL+cFpuWsRk/Hb1FFILL+PGdpNql2QGrJ8JnSeQcRnoN9T5tB3lf1mRdr72wRMRNSEmmomIiIiIiIgaU9e+wKr/AAV5QHDtRySPDh6GXZf2Izn/PAYF9Ecv7+61PrfYXAxRbiG+GZFTYLKY4CHX4ZYO0wAApRYjjGVGe5lcY16tr18Xw4IG2xPOAICQCCD9rwSutz96ZbXDeVMqZBIZpqp6OJz7YK97MT50FDwUOnTQRzZqnBWp5WrEBA7EoT+PQiqRYmTwEKflvFVeWDP433WrpHu09VGVEdcDX39kHTE+fErd6iAiamRMNDd3QgCZmdZtPz/7QgpERERERETUgui9rQ8XeCo98fqQ51BiLoFarq6y3K5finD0VCmiu6kwYYgWANDZ0BGTw8dh16V96KRvj9kdpsND4TiS2k/ti5ntb8SWlG8QrA3EjMjrq41HCIHs0hzolZ6VFvKrk/n3AyGR1vmJR90In4/WwOf3o9YR3yNnORSVSCTo7dvD+XWawPI+9yM+OwFeKgPCdCFNH8DEWUDfodY5mv1qOVKaiKiJSUT5X3E2kby8PBgMBrwycQs0Cl1TV99kMhJzMfP1GHSbGFb3ixQWAh5/dQYKCgBd632/iIiIqOWz9fNyc3Oh1+vdHQ41EbY7kfvEJxnxyGtX7c+fWeKN3lGuLRRnERZIJdUvTmi2mLHq1xcRl3USwdpALOw8B3vTfkawNhALOs+CQqqoU/wOhAD+vGRNyGvrd+8bl3USANDXt1f94yIiauNq29fjiGYiIiIiIiKiFiort6zCc4vL16gpyQwA8dkJ9uTtxYLLeOjICviqfAAAapkK8zrNtJfdmrIdJ6/GY2jgdRgbWnlhwCpJJEBQPQZq/eU/Zz7C/85/BwCYEXk97ugyv97XJCKimtX8vwkRERERERERNUuDeqrRrb11NHGXSAViers2mrm2fNU+kEllAICyCiOgr5bmWDeEwKHtL+G/u57C0eS9eO3UWiTlJTdKPNU5lHGs3PbRJq+fiKit4ohmIiIiIiIiohZKpZRg9QO+KCy2QKdpvLFkobpgPN73QfyU/gu6eHVCelEGtqZsh5/a99rczr/sQvaBrwC/q0B+NkTn3sgx5tapvhJzCUrKSuGlMrh8bm+f7th1ad9f2+6b15mIqK1hopmIiIiIiIiokeQb8/F+wkfINxVgXseb0dnQsVHqqXOS+cAOYPcWICAUuO1BQOdZZdEB/v0wwL+f/fmtnW6BQqqAxLZo/dUMjCzUY5dnLs6qSjBQ2wl9fVyfI/l0diJW/voCiszFdZr6Ykn3O9HbpzskkGBE8BCX6yciorphopmIiIiIiIiokbyf8BH2XD4AADiXfx4bRr7l5ojKycsGNr9tXYTvShqw8wtg+u21Pl0pUzruiJkA3ZEfseayDMY+g6Ac/bh13mVXlBRj29Z/oajkD8AvCFtTtmNex5uhlqtrfQmZVIbRIcNdq5eIiOrNrYnmrOR8qGVlNRdsoSwmCy79+ifkUnOdryEpLkKnv7b/2H0eQqNtmODaAIvJAmOhCcXZJSgzlUGUCVjKBCymMhiLzBBlAsIiEDogEN2nd772W3giIiIiIqIGkmfMt2/nGwsghGi+9x5C1O98H3/gyfeA4kIoPfR1u8YPnyMoORXwKgQunoO3T3jlhDYRETVLbk00xyzuAp3aw50hNKpDb/6K2A9i8duGul9DZjFhnD4GALBr2T6USRUNFF3rJVPIIJVLIFfJIZVLIVNKAYnE+ov0v/6VyqSABIAESPstA12u7wi5Uubu0ImIiIiIqJWZ32kmzuWfR76pAHd1XdC8ksx6b2DW369NnTHhFuflTCbgy/eAy+eB4VOAgaOqvqZMBtQ1yQwAxhLMy/aDHBJkycyY3uN+h4UHm5PMkiz8N2EjzKIMizrPQYgu2N0hERG5lUSI+v7K0nV5eXkwGAzIzc2FXl+P/4CaubXDN6HMaIHOX+PuUFoVU6EJxkITSgtMEBYLJBIJpHIpFFo5/Lr4wKeDF7wjDdD6qqH11UDjo4ZcKYNEJoFUJoVUIYVSq4BECkhkUshVsubV2SMiImrB2ko/jxyx3Ylq1qxHMtdk55fA/9Zbt6VSYNUHgLdf49SVexV4/xkg4zIwfiYw/ubGqacBPHHsOcRlnQQAdDK0xyuDn3FzREREjaO2fT3O0dwEWmxnohkRFoHCK0UoyiqG0kMJpacS7UcEIqiPP/y7+EBtUMEjSAdDaNULVxAREREREblLi74vLCm6tm2xAKUljVeXwQdY9nLjXb8B5ZmuTYuSW26KFCKitoqJ5uZOCMjLSgEAZpnK9YUUWrjinBIUZhRBWAQ0PmpETW6PHjdFoV1MCBQaTiNCRERERETU6EbdCCScANLOAyNuAILC3B1Rs7Cw82ys/u0NmC1lWBw1393hEBG5HRPNzZy8rBTzdlj/w9o0aSPMLqy021IJi0BxTikKrxRBoZWj/ah2CBsQiA6j28G3k7e7wyMiIiIiImpbPA3AspfcHUWz09+vDz4Z/T6AFj5inYiogTDRTM2GEAKFGUUozCyGxkeNDqPD0Xd+d0QOD+N/2kRERERERNTs8F6ViOgaJpqpWTAVmZB9IQ8abzW63dgJfeZ2Rfh1Ie4Oi4iIiIiIiIiIiGqBiWZyK2ORCbmp+RAWgbBBQRjyj/5oFxPq7rCIiIiIiIiogZgtZsilTD8QEbV2/ElPblOaV4qc1Hx4tzegy+T2iL6jF7Q+GneHRURERERERHVwOjsRp3LOINqvD9p7RsBsMePZuFdw9EosunlFYVX0I9DIec9HRNRaMdFMTc5sLENOSi6EAMIGBWHq62PhEaBzd1hERERERERUR2dzk7D86FOwCAs+TdqKN4Y8h4uFl3H0SiwA4HROIvalHcSk8LFujpSIiBoLE83UZOyL/V0pgm+UD3rP6oJes7pC5al0d2hERERERERUD2fzzsEiLACA0rJSpOSnwlft7VDGW+XlhsiIiKipMNHczFkkUqQEx9i3WypjoQnZ53Oh9dWgx8woDHtwIPTBHu4Oi4iIiIiIiBpAf9/e8FR6IN9YAH+NH3p4d4Ve6YmlPf6GgxlH0Mu7O64LiG6w+oQQOHLlVyikcvT369Ng1yUiorpjormZs8iU2B+9zN1h1JmlzILslFwICxA+KBjDlw1EaHSQu8MiIiIiIiKiBhSkDcRbQ1bjfEEqOnpGwlPpCQAYHzYK48NGNXh9r596D7su7QMAzO4wHbd2ntXgdRARkWuYaKZGYywyIftcDgzt9BiytD+iJneAUqtwd1hERERERETUCLxVXk02PcaRK7+W245lopmIqBlgopkaRUFGIYqzSxESHYipr4+DPoTTZBAREREREVHD6OfbC/vSDgIA+vr2dHM0REQEMNHc7MnNJZi3Yz4AYNOkjTDL1W6OqHpCCOSm5kNYBLrd2BHj/z0cCjU/ZkRERERERNRwHuj5dwzy7w+5VI6YgIHOCxXkASVFgB+nbyQiagrMAFKDMRYYkX0+D57BOgy8szf6L+oJiUTi7rCIiIiIiIjc7o8LJuTkW9C3ixJyOe+T6ksmlWFE8JCqC8QfB95/BjCZgNHTgJvvbLrgiIjaKCaaqUEU/FmI4pxSRAwNxbD/G4CQvoHuDomIiIiIiKhZ2H24GK9tyoUQwMAeKjx5t7e7Q2r99n5tTTIDwN5twLRFgJwpECKixsSfslQvwiJw9VwOpHIpohf1xLD/GwC5ih8rIiIiIiIim5/jSiCEdfvoqVIYTQJKBUc1N6qgcOuoZgDwD2aSmYioCfAnLdVZmakMmQlXoQvQovv0zhi5/DpOlUFERERERFRBr85KHD1VCgCIilAwydwQTCZAIqk6gXzjQsBDD+TnAqNubNrYiIjaKCaaqU5KC4y4ei4H3pEGjF0xBB3HRLg7JCIiIiIiomZpxhgdgv1kyM6zYGR0817gvd6EANIuAJ5egKehceo4sgfY9DoglQF3PAL0dLIYoFwOTLilceonIiKnmGgmlwiLQM6FPJiNZWg/PAxjVgyFX2fOL0ZERERERFSdwb1beYIZsCaZP3geiDsIqNTAfU8BHbo1fD3bNgBmMwAz8M1HzhPNRETU5JhobuYsEikuBvS3b7uTucSMq8m50Plp0G9Bd1z3935QeSrdGhMRERERERHV7EjGr9h8bisCNP64t9vt8FR6unR+SakFalUN96Q5WdYkMwCUlgAHf2icRLPBx1oXABh8G/76RERUJ0w0N3MWmRI/DnrMrTGYS83IvZgPYQG82xsw4d/DEH5diFtjIiIiIiIiotopLSvFC7+9DmOZEYm5SfBS6nF3t0W1Orek1IIn3srGmRQT+kQpseJubyiqmmPaQw/ovYG8bOvz0MgGib+SOx4Bvv4IkMmBaQsbpw4iInIZE81UJWERyEnNg6nIDEO4J3reHIXo23tCqeMoZiIiIiIiopaiTJTBZDHZn5eUldb63AOxJTiTYj33RKIRR0+VYkjfKqYBUSiB+58DDn4P+AUDwybVK+4q+QYCi5Yh+ZIJGqMEQY1TCxERuYiJZnLKXGLG1XM58AjUYfj/DUTXqR2h9dG4OywiIiIiagQ33ngj4uLikJGRAW9vb4wbNw4vvPACQkL4V2xErYFWrsU93Rbh4z8+h7/aD3M73lTrc30MsgrPa5g+IzAUmHFHXcJ0yXtf5OHr/UWQSIAHbjVg9EDerxIRuRsTzc2c3FyCW3Za/5P+fPx/YZY37gISZaYy5Kbmw1Im4N/dF2NXDEXYAP5+mIiIiKg1Gz16NP71r38hODgYly5dwrJlyzBz5kwcPHjQ3aERUQOZEj4eU8LHu3xe/24q/O1mT5xINGJQDxW6tm8ef+H63c9FAKzrD/5wqJiJZiKiZoCJ5hZA4cKfNdWVEAIF6YUouloCQztPDLyzN3rM6MxpMoiIiIjagAceeMC+HRERgeXLl2P69OkwmUxQKBRujIyImoOpI3WYOlLn7jAcdAhTIPG8dUqPDqFMbRARNQf8aUwoySlFXloBtD5qRN/eE9F39IIh1LUViImIiIiodbh69So2btyIIUOGVJlkLi0tRWnptcEQeXl5TRUeEREAYOU93vhmfxE8tBJMHqp1dzhERASghsmVqLUrzCxCfkYhwgcFY/raCRjzxBAmmYmIiIjaoEceeQQ6nQ6+vr64cOEC/ve//1VZ9rnnnoPBYLA/wsPDmzBSIiLAUyfF3MkemDpSB7lc4u5wiIgITDS3WUII5F7MR+GVYnSeEImb/jsJIf0C3R0WERERETWQlStXQiKRVPs4duyYvfxDDz2E2NhY/PDDD5DJZLjtttsghHB67UcffRS5ubn2R2pqalO9LCIiIiJqpjh1RhtkKjIhKykHHoE6DL6vHwbe1RsKNT8KRERERK3JkiVLMGfOnGrLREZG2rf9/Pzg5+eHqKgodOvWDeHh4fjll18QExNT6TyVSgWVStXQIRNRS5KXA6x/EchKBybNAWJcX2iQiIhaF2YX25DSfCPy0wshlUkQ2MMPY1cNRdiAIHeHRURERESNwJY4rgvbSOby8zATETnY8SmQ+Jt1+5M3gd6DAR2nYSQiasuYaG7mhESCdJ8e9m2Xz7cIlBYYUZBRBJlCipB+Aeg1qws6T2wPpZYriBMRERG1dUeOHMGRI0cwbNgweHt749y5c3jyySfRsWNHp6OZiYgAANJyM3FKJNYHERG1aW0u0bx//368+OKLOH78ONLS0rB161ZMnz7d3WFVqUymwg9DnnL9PFMZ8tMLYSoyQeWpgk97Awbd3Qddp3aCVMoOABERERFZaTQabNmyBStWrEBhYSGCg4MxadIkfPrpp5weg4iqNmkOcCUNyEwHJs4CtB7ujoiIiNyszSWaCwsL0adPH9x+++24+eab3R1OgxMWgcIrRSjIKIJXO0/0X9gT3aZ2hKGdHnKlzN3hEREREVEz06tXL/z444/uDoOIWhoPPfD3Fe6OgoiImpE2l2iePHkyJk+e7O4wGpyp2IzCK0UwFZuh8VIhenEvDLi9FwxhnCOLiIiIiIiIiIiIGlebSzS3NHJzCW768e8AgC1j3oFZrnY4bjaWIf9SAcrMZfAM9kD09M7oNrUjvNsbIOEcWURERERERERERNQEmGhuAdTGPIfnpmIziq8Ww1hoglQuhUegDtG390S3aZ2g1nMePSIiIiIiIiIiImpaTDS3IOZSM65eyIEQAlo/DbpM7YgOo9ohfFAQlDqlu8MjIiIiIiIiIiKiNoqJ5hYkOzUf3l2C0HtOV/SY0ZnJZSIiIiIiIiIiImoWmGhuxoQQKMwssj+Pua8f+t0zCAo1m42IiIiIiIiIiIiajzaXsSwoKMAff/xhf56cnIy4uDj4+PigXbt2bozMUWleKfLTC6HzuLZv0F19ACaZiYiIiIiIiIiIqJlpc1nLY8eOYfTo0fbnDz74IABg4cKFWL9+vZuiukYIgdzUfFjMFgT08MOo+3sBo9wdFREREREREREREVHV2lyiedSoURBCuDsMp0zFZmSn5EDrp0W/W7tj0D19ITOVAgMGWAtIpe4NkIiIiIiIiIiIiMiJNpdobm7KjGUoyS1Fab4RFrMF4YNCMOSf0QgfFGwtINcAR4+6N0giIiIiIiIiIiKiajDR7CaWMgvyLxegtMAInb8OwX0DEDE0FNF39OJif0RERERERFQ3qUnA3q8BvyBg/ExAzvtLIiJqGvwfp4kJIVCUVYzCK8XwDNKh38Ke6Du/GzwCdO4OjYiIiIiIiFoykxF48wmgMP/avslz3BcPERG1KUw0N6HSAiNyzudB46NGp7ERGPyPfgjq6V/9SUVFQPfu1u34eECrbfxAiYiIiIiIqOUpLnRMMmemuy8WIiJqc5hobgJlxjJkn8+DVCaBbycvjHjkOnQaG1G7k4UAzp+/tk1ERERERETkjN4bGDYZOPAdoPMERk11d0RERNSGMNHcyPIu5qMoqxiGcE/E/KM/Ok+IhMpD6e6wiIiIiIiIqDWacy8wZR6g0QIK3nsSEVHTYaK5ERiLTIj96BRUHkr4dPJC50nt0Wd2V/h08HJ3aERERERERNTa6b3cHQEREbVBTDQ3IGORCYk7khH74SlcOZMFCGDS6pHoPq2zu0MjIiIiIiIiIiIiajRMNDeA4uwSxG2KR+K3ychOyYW5xAyfDl7IuZAHuZpvMREREREREREREbVuzILWQ3F2Cc7uTEHsh6eQmXAVEpkEhlBPKLQKd4dGRERERERERERE1GSYaK6Dc3sv4LfNZ5AWdwUlOSWAVAJDmCeUjbHIn0QCdO9+bZuIiIiIiIiIiIiomWGi2QWphy/j5OcJSN6XiqLMEmh91fBqp4dMKWu8SrVa4NSpxrs+ERERERERERERUT0x0VwLJbml+OXtWMR/dRZFV0ug9dEgoIcvJBxhTERERERERERERMREc3VyL+bj1NaziN+aiNyLBVB5KODfxYcJZiIiIiIiIiIiIqJymGiuwFRixultf+DMN0nITMhGcXYJAMA7Ug+5yg1vV1ERMHCgdfvoUetUGkRERERERERERETNCBPNfynNN+LsD8mI23gamQlXYS41Q+OjgV9nb0ikbhzBLAQQH39tm4iIiIiIiIiIiKiZafOJ5uzzuYjbdBqJ28+hOKcEpmIzvMI8odKr3B0aERERERERERERUYvQZhPNmYlXkfh9Ck5+dgb5aYVQeSrhGewBhbrNviVEREREREREREREddKmsqp5aQVI+ekizh+4iNQj6SjKLIZSq4BflA+kMi7wR0RERERERERERFQXrT7RXGYqQ+rhNKT8dBGntyWhJLcEFrOAxlvNBDMRERERERERERFRA2i1iWZLmQVnv0/Bsf/+hszEbJhLyqDSK+EdYYBULnV3eEREREREREREREStRqtLNOenFyD2o3j8sTMF+WmFMJeaoQ/xhNJDAYmkBY5elkiAiIhr20RERERERERERETNTKtINOelFSB5XypSf0lD6uHLKMoshlQhhc5PC7VB5e7w6kerBVJS3B0FERERERERERERUZVaZKJZCIGsP3KQ8tNFnP0hBTnn81CcXQxzSRk8g3Tw7eTN6TGIiIiIiIiIiIiImkiLSTSXmS24cPASMhOu4sIvafjz5BUUXS2GXCWH0kMJ7/ZekDG5TERERERERERERNTkmnWi2WIR+PP3K0jYfg7nD1xC7qV8mIrNkMok0Hip4RflA6mslSeXi4uBESOs2/v3AxqNe+MhIiIiIiIiIiIiqqDZJZpLcktx9ocUpJ3IwKVj6Si8UozinBLIlTJ4BOlgCGuhi/rVlcUCHDt2bZuIiIiIiIiIiIiomXF7otlSZsGfv2fi0vE/cf7nS8g4nYWSnBJYzAIKrRwqDyU8g33bVnKZiIiIiIiIiIiIqAVxa6J558qfkRdfgIKMIhgLTZBIJNB4q2AI84Rc5fYcOBEREREREVHzceoYcHQvENkFGDXV3dEQERE5cGs2N/GbJOg0HlB7qaAP8eCoZSIiIiIiIiJnrqQB7z8DmM3AsX2AhwEYMMLdUREREdm5NdHs08ELGoXWnSEQERERERERNX85WdYks83VDPfFQkRE5ITU3QEQERERERERUQ06dAO6R1u3/YOB68a4Nx4iIqIKOBFyS+Dn5+4IiIiIiIiIyJ1kMuDvK4CCPEDrYX1ORETUjDDR3NzpdMCVK+6OgoiIiIiIiNxNIgE8De6OgoiIyClOnUFERERERERERERE9cJEMxERERERERERERHVCxPNzV1xMTBqlPVRXOzuaIiIiIiIiIiIiIgq4RzNzZ3FAuzbd22biIiIiIiIiIiIqJlpk4nm3Sk78G3S/5Bbmo0Qz3DM7347uvh2d3dYRERERERERERERC1Sm5s64/Dln7Hx1DpM7Xwznhr+Err4dMPLR55BVvEVd4dGRERERERERERE1CK1uUTzjnNfY0S7MRjVbhxCPMMwv8cd8NH4YnfK9+4OjYiIiIiIiIiIiKhFcuvUGXnphTDJmm7eYbPFjJScJIzxmYS8ywX2/VGa7kj4Mx55hoJqznadEAKFhYXIzc2t+0UKC2H4azM3NxcwmxskNiJyTggBi8UCs9kMk8kEi8UCIQSCg4OhUCjcHR4RERERERERUbPk1kSzPlgHjULbZPVll1yFBRYEBQdB7+Nh3+9f5I+E1FPQh3pUc7brjh0/jWUrP0Ph6vw6X0NdVoa9f21PmzYNJTJZg8RG1NpJJBIAgEwmg0QigUQicdiWSqX2cray5Z9XfHTu3Blr1qxxy2shIiIiIiIiImru3Jponrv5Ruj1+iar7/Lly/hnKDDlxdGIiYmx70995jROfnQct227qUHre3/4K8jIyIC/3r/O15BLJCj+KyEml8shZ6KZWhnb6GGLxYKysjKUlZXBZDLBaDTCaDTCZDJZP/tyORQKBVQqFZRKJVQqFRQKBWQyGRQKBeRyeaXksFwuh1KptJ+v1Wrt23K5HDKZDFKp1P6wJaClUqn9XNv+m25q2J8PREREREREREStiVsTzU3Nz88PMpkM6enpDvszMjIQGBjYKHV6eXnB29u7XteYNWUKAEDz14OoObNYLLBYLDCZTA4J4+LiYlgsFofRw0IISKVSe8LXlkzWarXw9vZGaGgogoKCEBgYCCEEwsLCEBQUhICAAAQFBUGn0zlcj4iIiIiIiIiI3KNNJZqVSiWio6Oxc+dOzJgxw75/586dmDZtmhsjI2oZhBAOyeOKo4+lUqk9eaxQKOwjkP39/REVFYXQ0FAolUrIZDKo1WoYDAYEBgbC09MTKpUKWq0WHh4eUKlU0Ov1TCITEREREREREbUQbSrRDAAPPvggFixYgAEDBiAmJgbvvfceLly4gHvuucfdoRG5RVlZGYxGI8xmM8xmM0pKSlBWVmYfmWyb1kIikcBisdinrpDJZFAqlfD19UVQUBAiIyPRvn17BAYGQqPRQK/Xw9vbG4GBgVAqle5+mURERERERERE1IjaXKJ59uzZyMrKwlNPPYW0tDT07NkT3377LSIiItwdmlOKsjI8evw4AOC56GiYOEczOWEbaWyxWCCEgBDCPuex2WyGEMJhFHJZWZnDYni2xLFCoYBarYZOp0NQUBBUKhX8/Pzg4eGBwMBABAQEwGAwICwsDB4eHvDx8YFc3uZ+jBARERERERERUQVtMkN077334t5773V3GLUiFQIDMzLs29Q6VUwM20YT26amKL9Qnu0hhLBPLWE2m6FWq+0L19kWtZPJZPZF7/z9/REWFgZvb294eXkhMDAQer0e/v7+8Pf3h4eHB7y8vKDX6+1JaCIiIiIiIiIiotpok4lmooZiG0FcMSFc/t+KCWPbiGNbktg2JYVEIoFcLodcLodUKrU/lEolNBoNtFotvLy8oNVqodfr4evrC29vbyiVSuj1egQEBMDDw8N+DYVCAY1GA4PBAIVCwZHHRERERERERETUaJh5ojbLlgi2JX5tcxTbngOwb5eVlaG0tBQmkwlms9m+6J1t9LBt2gnbKGKpVAq5XG6fz9jDw8M+BYVMJrMvkKfVaqFQKKDX62EwGKDVauHp6QmdTmdPFvv5+XFRPCIiIiIiIiIiataYaKZGJcpN92FL2pZP7NqmgCj/KD81RPnzyl/PNtWELVFs27aNDK6YmJVIJJVisSWIKyaLy59v21YoFAgPD0doaCj8/f0REBAAf39/6PV6+4hjvV4PrVYLrVYLtVoNpVLJUcRERERERERERNQmMAvWBMonSm0jZm0J0vJlnG2by8rs2/n5+SiEdSQuAIdrlE/Slh+lW/56tn8rHi+fVK2o4r7ysdmOO0sIOzvflrS1PWxzB9vmE7aVtY34tY0Mtv1bPjFsW7ROqVRCqVRCrVZDq9VCp9NBp9PB09MTKpUKCoXCIZlsG2lsm1ZCq9Xa96nVavviduXjspWXcSFGIiIiIiIiIiIip9yaaD5//jw0Go3DqFbAceQrcC0xajabUVpaCqPRiPz8fJSWlqK0tNRetvyoVtuiakajsVJy13as/By6tnNKSkpQVFTkULb8Qm0Vy9vKGI1Gh9G1Qgh4eXnh7NmzyM3NdUii2ubedTbqtuK2sVyiuaioCKa/Ep5SqdQ+764tKSqTyeyJVtt+26N8MlelUtkTuc7mBC6/kFzFfbZ/Ky40Z0vG2kbwVkwq284rP72ETqezTyWhVCrt9anVamg0Gk4XQURERERERERE1EK4JdFsSyAvWrTIPtdtTWVt27Ykr9lsdpg6oXzZitMrVDe6tzF5enpi/PjxGDdunD3RqtPpoFQqHUbISqVS+zm2bft0DqWlyBs4EADwwQcfQOXjA61Wa08Ot8ZkrNlsRn5+vrvDICIiojrIy8sD0DR9LWo+bO1ta38iIiIiaj1q28eXCDfcBZw7dw4dO3Zs6mqJiIiIqIkkJSWhQ4cO7g6DmsjFixcRHh7u7jCIiIiIqBGlpqYiLCysyuNuGdHs4+MDALhw4QIMBoM7Qmh0eXl5CA8PR2pqKvR6vbvDoXpgW7YubM/Wg23ZerAtW5fc3Fy0a9fO3t+jtiEkJASpqanw9PSs11/c8eeB+7ENmge2g/uxDdyPbdA8sB3crzm0gRAC+fn5CAkJqbacWxLNtukhDAZDq/+Q6vX6Vv8a2wq2ZevC9mw92JatB9uydSk/NRi1flKptNrRLa7izwP3Yxs0D2wH92MbuB/boHlgO7ifu9ugNoOFeQdARERERERERERERPXCRDMRERERERERERER1YtbEs0qlQorVqyASqVyR/VNoi28xraCbdm6sD1bD7Zl68G2bF3YnlQf/Py4H9ugeWA7uB/bwP3YBs0D28H9WlIbSIQQwt1BEBEREREREREREVHLxakziIiIiIiIiIiIiKhemGgmIiIiIiIiIiIionphopmIiIiIiIiIiIiI6oWJZiIiIiIiIiIiIiKqlyZJNGdnZ2PBggUwGAwwGAxYsGABcnJyqj1ny5YtmDhxIvz8/CCRSBAXF9cUobrk7bffRvv27aFWqxEdHY2ffvqp2vL79u1DdHQ01Go1OnTogHfffbeJIqWauNKWW7Zswfjx4+Hv7w+9Xo+YmBh8//33TRgt1cTV76bNzz//DLlcjr59+zZugFRrrrZlaWkpHnvsMUREREClUqFjx47473//20TRUnVcbcuNGzeiT58+0Gq1CA4Oxu23346srKwmipaqsn//fkydOhUhISGQSCT46quvajyH/R+qTkpKChYvXoz27dtDo9GgY8eOWLFiBYxGY7XnCSGwcuVKhISEQKPRYNSoUTh16lQTRd36PPPMMxgyZAi0Wi28vLxqdc6iRYsgkUgcHoMHD27cQFuxurQBvwcNry65C34X6od5lebBlXbYu3dvpc+8RCLBmTNnmjDi1qU19bGbJNE8b948xMXFYceOHdixYwfi4uKwYMGCas8pLCzE0KFD8fzzzzdFiC7bvHkz/vnPf+Kxxx5DbGwshg8fjsmTJ+PChQtOyycnJ2PKlCkYPnw4YmNj8a9//QtLly7Fl19+2cSRU0WutuX+/fsxfvx4fPvttzh+/DhGjx6NqVOnIjY2tokjJ2dcbU+b3Nxc3HbbbRg7dmwTRUo1qUtbzpo1C7t378YHH3yAhIQEfPLJJ+jatWsTRk3OuNqWBw4cwG233YbFixfj1KlT+Pzzz3H06FHceeedTRw5VVRYWIg+ffrgzTffrFV59n+oJmfOnIHFYsHatWtx6tQpvPLKK3j33Xfxr3/9q9rzVq9ejTVr1uDNN9/E0aNHERQUhPHjxyM/P7+JIm9djEYjbrnlFvz973936bxJkyYhLS3N/vj2228bKcLWry5twO9Bw6tL7gLgd6GumFdpHup6D52QkODwue/cuXMTRdz6tKo+tmhk8fHxAoD45Zdf7PsOHTokAIgzZ87UeH5ycrIAIGJjYxsxStcNGjRI3HPPPQ77unbtKpYvX+60/MMPPyy6du3qsO/uu+8WgwcPbrQYqXZcbUtnunfvLlatWtXQoVEd1LU9Z8+eLR5//HGxYsUK0adPn0aMkGrL1bb87rvvhMFgEFlZWU0RHrnA1bZ88cUXRYcOHRz2vf766yIsLKzRYiTXARBbt26ttgz7P1QXq1evFu3bt6/yuMViEUFBQeL555+37yspKREGg0G8++67TRFiq7Vu3TphMBhqVXbhwoVi2rRpjRpPW1TbNuD3oOHVNXfB70LdMa/SPLjaDnv27BEARHZ2dhNE1/a09D52o49oPnToEAwGA6677jr7vsGDB8NgMODgwYONXX2jMBqNOH78OCZMmOCwf8KECVW+pkOHDlUqP3HiRBw7dgwmk6nRYqXq1aUtK7JYLMjPz4ePj09jhEguqGt7rlu3DklJSVixYkVjh0i1VJe23LZtGwYMGIDVq1cjNDQUUVFRWLZsGYqLi5siZKpCXdpyyJAhuHjxIr799lsIIfDnn3/iiy++wPXXX98UIVMDYv+H6iI3N7faflVycjLS09MdPlsqlQojR45ssfcXLdXevXsREBCAqKgo3HXXXcjIyHB3SG0GvwcNrz65C34XXMe8SvNQn5xIv379EBwcjLFjx2LPnj2NGSZV0Jy/C42eaE5PT0dAQECl/QEBAUhPT2/s6htFZmYmysrKEBgY6LA/MDCwyteUnp7utLzZbEZmZmajxUrVq0tbVvTyyy+jsLAQs2bNaowQyQV1ac+zZ89i+fLl2LhxI+RyeVOESbVQl7Y8d+4cDhw4gN9//x1bt27Fq6++ii+++AL33XdfU4RMVahLWw4ZMgQbN27E7NmzoVQqERQUBC8vL7zxxhtNETI1IPZ/yFVJSUl44403cM8991RZxvazoz79N6q/yZMnY+PGjfjxxx/x8ssv4+jRoxgzZgxKS0vdHVqbwO9Bw6tr7oLfhbphXqV5qEs7BAcH47333sOXX36JLVu2oEuXLhg7diz279/fFCETmvd3oc6J5pUrVzqd/Lv849ixYwAAiURS6XwhhNP9LUnF+Gt6Tc7KO9tPTc/VtrT55JNPsHLlSmzevNlpp4Tco7btWVZWhnnz5mHVqlWIiopqqvDIBa58Ny0WCyQSCTZu3IhBgwZhypQpWLNmDdavX89Rzc2AK20ZHx+PpUuX4sknn8Tx48exY8cOJCcnV5t4ouaL/Z+2yZV7BZvLly9j0qRJuOWWW2o1J3td+29tRV3awBWzZ8/G9ddfj549e2Lq1Kn47rvvkJiYiO3btzfgq2jZGrsNAH4PaqOxcxf8LtQP8yrNgyvt0KVLF9x1113o378/YmJi8Pbbb+P666/HSy+91BSh0l+a63ehzsP3lixZgjlz5lRbJjIyEr/99hv+/PPPSseuXLlSKfveUvj5+UEmk1X67U5GRkaVrykoKMhpeblcDl9f30aLlapXl7a02bx5MxYvXozPP/8c48aNa8wwqZZcbc/8/HwcO3YMsbGxWLJkCQBrslIIAblcjh9++AFjxoxpktjJUV2+m8HBwQgNDYXBYLDv69atG4QQuHjxIhencJO6tOVzzz2HoUOH4qGHHgIA9O7dGzqdDsOHD8e///1vBAcHN3rc1DDY/2m7anuvYHP58mWMHj0aMTExeO+996o9LygoCIB1NE/5nwe16b+1Ja62QX0FBwcjIiICZ8+ebbBrtnSN2Qb8HtReU+cu+F2oHeZVmof65ETKGzx4MD7++OOGDo+q0Jy/C3VONPv5+cHPz6/GcjExMcjNzcWRI0cwaNAgAMDhw4eRm5uLIUOG1LV6t1IqlYiOjsbOnTsxY8YM+/6dO3di2rRpTs+JiYnB119/7bDvhx9+wIABA6BQKBo1XqpaXdoSsI5kvuOOO/DJJ59wztBmxNX21Ov1OHnypMO+t99+Gz/++CO++OILtG/fvtFjJufq8t0cOnQoPv/8cxQUFMDDwwMAkJiYCKlUirCwsCaJmyqrS1sWFRVVmspGJpMBuPabemoZ2P9pu2p7rwAAly5dwujRoxEdHY1169ZBKq3+jy7bt2+PoKAg7Ny5E/369QNgnWNy3759eOGFF+ode2vhShs0hKysLKSmpvKXgeU0Zhvwe1B7TZ274HehdphXaR7qmhOpKDY2lp/5JtSsvwtNseLgpEmTRO/evcWhQ4fEoUOHRK9evcQNN9zgUKZLly5iy5Yt9udZWVkiNjZWbN++XQAQn376qYiNjRVpaWlNEXKNPv30U6FQKMQHH3wg4uPjxT//+U+h0+lESkqKEEKI5cuXiwULFtjLnzt3Tmi1WvHAAw+I+Ph48cEHHwiFQiG++OILd70E+ourbblp0yYhl8vFW2+9JdLS0uyPnJwcd70EKsfV9qxoxYoVok+fPk0ULVXH1bbMz88XYWFhYubMmeLUqVNi3759onPnzuLOO+9010ugv7jaluvWrRNyuVy8/fbbIikpSRw4cEAMGDBADBo0yF0vgf6Sn58vYmNjRWxsrAAg1qxZI2JjY8X58+eFEOz/kOsuXbokOnXqJMaMGSMuXrzo0Lcqr+K9wvPPPy8MBoPYsmWLOHnypJg7d64IDg4WeXl5Tf0SWoXz58+L2NhYsWrVKuHh4WH/nufn59vLlG+D/Px88X//93/i4MGDIjk5WezZs0fExMSI0NBQtkEdudoGQvB70BhczV3wu1A/zKs0D662wyuvvCK2bt0qEhMTxe+//y6WL18uAIgvv/zSXS+hxWtNfewmSTRnZWWJ+fPnC09PT+Hp6Snmz58vsrOzHQMBxLp16+zP161bJwBUeqxYsaIpQq6Vt956S0RERAilUin69+8v9u3bZz+2cOFCMXLkSIfye/fuFf369RNKpVJERkaKd955p4kjpqq40pYjR450+tlcuHBh0wdOTrn63SyPiebmxdW2PH36tBg3bpzQaDQiLCxMPPjgg6KoqKiJoyZnXG3L119/XXTv3l1oNBoRHBws5s+fLy5evNjEUVNFe/bsqfb/QPZ/yFVV9fkrjoepeK9gsVjEihUrRFBQkFCpVGLEiBHi5MmTTRx967Fw4UKnbbBnzx57mfJtUFRUJCZMmCD8/f2FQqEQ7dq1EwsXLhQXLlxwzwtoBVxtAyH4PWgMruYu+F2oP+ZVmgdX2uGFF14QHTt2FGq1Wnh7e4thw4aJ7du3uyHq1qM19bElQvBvUImIiIiIiIiIiIio7qqfAI2IiIiIiIiIiIiIqAZMNBMRERERERERERFRvTDRTERERERERERERET1wkQzEREREREREREREdULE81EREREREREREREVC9MNBMRERERERERERFRvTDRTERERERERERERET1wkQzUSuRkpICiUSCuLi4Jqtz/fr18PLysj9fuXIl+vbta3++aNEiTJ8+vcniae1WrlyJwMBASCQSfPXVV073ufKeu+Mz05D27t0LiUSCnJwcd4dCRERERK2Esz53Y9dX/h6qpUlPT8f48eOh0+kc7g2JqG1iopmoBZBIJNU+Fi1a5Ja4Zs+ejcTERLfU7YqqEqotKRF++vRprFq1CmvXrkVaWhomT57sdN9rr72G9evX1+qa4eHhSEtLQ8+ePRs01qbqlBMRERG1VIsWLXLar//jjz8a5PoVB4RQ7TjrXzekpuwnb9myBRMnToSfn1+dBpdERkbi1VdfrbHcK6+8grS0NMTFxTXovWFt6yei5kXu7gCIqGZpaWn27c2bN+PJJ59EQkKCfZ9Go0F2dnaTx6XRaKDRaJq83rYoKSkJADBt2jRIJJIq96lUqlpfUyaTISgoqIEjJSIiIqLamDRpEtatW+ewz9/f303RVM1kMkGhULg7jCbhrH9dF83hPSssLMTQoUNxyy234K677mq0epKSkhAdHY3OnTs3Wh31YTQaoVQq3R0GUZvBEc1ELUBQUJD9YTAYIJFIKu2zOXfuHEaPHg2tVos+ffrg0KFDDtc6ePAgRowYAY1Gg/DwcCxduhSFhYVV1n3ixAmMHj0anp6e0Ov1iI6OxrFjxwDUfqTESy+9hODgYPj6+uK+++6DyWSyH8vOzsZtt90Gb29vaLVaTJ48GWfPnrUfd/anZK+++ioiIyMd9q1btw7dunWDWq1G165d8fbbb9uPtW/fHgDQr18/SCQSjBo1CitXrsSGDRvwv//9zz6CZO/evQCAS5cuYfbs2fD29oavry+mTZuGlJSUal/jqVOncP3110Ov18PT0xPDhw+3d1QtFgueeuophIWFQaVSoW/fvtixY4fD+dXVuXLlSkydOhUAIJVKIZFInO4DKo/StlgseOGFF9CpUyeoVCq0a9cOzzzzDADnI73j4+MxZcoUeHh4IDAwEAsWLEBmZqb9+KhRo7B06VI8/PDD8PHxQVBQEFauXGk/bmuXGTNmQCKRVGonm5iYGCxfvtxh35UrV6BQKLBnzx4AwMcff4wBAwbA09MTQUFBmDdvHjIyMqpsg4b4rBiNRixZsgTBwcFQq9WIjIzEc889V2WdRERERHWlUqkc+vRBQUGQyWQAgK+//hrR0dFQq9Xo0KEDVq1aBbPZbD93zZo16NWrF3Q6HcLDw3HvvfeioKAAgHV6sdtvvx25ubn2fq6tv+ZsRK2Xl5f9L+Js/cPPPvsMo0aNglqtxscffwyg+j6UM1988QV69eoFjUYDX19fjBs3zn7fYeuzrlq1CgEBAdDr9bj77rthNBrt5+/YsQPDhg2Dl5cXfH19ccMNN9j71zYXL17EnDlz4OPjA51OhwEDBuDw4cP24zW9j+VV1b+uqS9f3XtWXk395I8++giRkZEwGAyYM2cO8vPz7ceEEFi9ejU6dOgAjUaDPn364Isvvqj2/V+wYAGefPJJjBs3rsoyK1euRLt27aBSqRASEoKlS5cCsPb5z58/jwceeMD+GXImMjISX375JT788EOHv7TNzc3F3/72N3vbjhkzBidOnLCfl5SUhGnTpiEwMBAeHh4YOHAgdu3aZT9eVf216e/bPlvPPfccQkJCEBUVBaBu93hE5DommolamcceewzLli1DXFwcoqKiMHfuXHtn6uTJk5g4cSJuuukm/Pbbb9i8eTMOHDiAJUuWVHm9+fPnIywsDEePHsXx48exfPlyl347v2fPHiQlJWHPnj3YsGED1q9f7zC1w6JFi3Ds2DFs27YNhw4dghACU6ZMcUhG1+T999/HY489hmeeeQanT5/Gs88+iyeeeAIbNmwAABw5cgQAsGvXLqSlpWHLli1YtmwZZs2ahUmTJiEtLQ1paWkYMmQIioqKMHr0aHh4eGD//v04cOAAPDw8MGnSJIeOb3mXLl3CiBEjoFar8eOPP+L48eO444477O/7a6+9hpdffhkvvfQSfvvtN0ycOBE33nijPaFeU53Lli2zj3axxepsnzOPPvooXnjhBTzxxBOIj4/Hpk2bEBgY6LRsWloaRo4cib59++LYsWPYsWMH/vzzT8yaNcuh3IYNG6DT6XD48GGsXr0aTz31FHbu3AkAOHr0KADrjUhaWpr9eUXz58/HJ598AiGEfd/mzZsRGBiIkSNHArAmfZ9++mmcOHECX331FZKTk+s9TUxNn5XXX38d27Ztw2effYaEhAR8/PHHVSbLiYiIiBrD999/j1tvvRVLly5FfHw81q5di/Xr19sHCwDWROjrr7+O33//HRs2bMCPP/6Ihx9+GAAwZMgQvPrqq9Dr9Q59R1c88sgjWLp0KU6fPo2JEyfW2IeqKC0tDXPnzsUdd9yB06dPY+/evbjpppsc+n67d+/G6dOnsWfPHnzyySfYunUrVq1aZT9eWFiIBx98EEePHsXu3bshlUoxY8YMWCwWAEBBQQFGjhyJy5cvY9u2bThx4gQefvhh+/HavI/lVdW/rqkvX9V7VlF1/eSkpCR89dVX+Oabb/DNN99g3759eP755+3HH3/8caxbtw7vvPMOTp06hQceeAC33nor9u3bV0UL1uyLL77AK6+8grVr1+Ls2bP46quv0KtXLwDWaTfCwsLw1FNPVXuvcfToUUyaNAmzZs1CWloaXnvtNQghcP311yM9PR3ffvstjh8/jv79+2Ps2LG4evUqAGvbTZkyBbt27UJsbCwmTpyIqVOn4sKFCy7VXxXbZ2vnzp345ptv6nSPR0R1JIioRVm3bp0wGAyV9icnJwsA4j//+Y9936lTpwQAcfr0aSGEEAsWLBB/+9vfHM776aefhFQqFcXFxU7r8/T0FOvXr69VLCtWrBB9+vSxP1+4cKGIiIgQZrPZvu+WW24Rs2fPFkIIkZiYKACIn3/+2X48MzNTaDQa8dlnnzm9phBCvPLKKyIiIsL+PDw8XGzatMmhzNNPPy1iYmKEENfem9jYWIcyCxcuFNOmTXPY98EHH4guXboIi8Vi31daWio0Go34/vvvnb4Pjz76qGjfvr0wGo1Oj4eEhIhnnnnGYd/AgQPFvffeW+s6t27dKir+yHa2r/xrysvLEyqVSrz//vtO46r4vjzxxBNiwoQJDmVSU1MFAJGQkCCEEGLkyJFi2LBhlV7LI488Yn8OQGzdutVpnTYZGRlCLpeL/fv32/fFxMSIhx56qMpzjhw5IgCI/Px8IYQQe/bsEQBEdna2EKJhPiv/+Mc/xJgxYxzagoiIiKihLVy4UMhkMqHT6eyPmTNnCiGEGD58uHj22Wcdyn/00UciODi4yut99tlnwtfX1/68qnsGZ/00g8Eg1q1bJ4S41j989dVXHcrU1Ieq6Pjx4wKASElJcXp84cKFwsfHRxQWFtr3vfPOO8LDw0OUlZU5PScjI0MAECdPnhRCCLF27Vrh6ekpsrKynJavy/vorH9dU1++qvfMGWfv/4oVK4RWqxV5eXn2fQ899JC47rrrhBBCFBQUCLVaLQ4ePOhw3uLFi8XcuXNrrLOqe6GXX35ZREVFVXkPExERIV555ZUarz9t2jSxcOFC+/Pdu3cLvV4vSkpKHMp17NhRrF27tsrrdO/eXbzxxhvV1l+b/v7ChQtFYGCgKC0tte+ryz0eEdUN52gmamV69+5t3w4ODgYAZGRkoGvXrjh+/Dj++OMPbNy40V5GCAGLxYLk5GR069at0vUefPBB3Hnnnfjoo48wbtw43HLLLejYsWOt4+nRo4f9TwBtMZ08eRKAdbENuVyO6667zn7c19cXXbp0wenTp2t1/StXriA1NRWLFy92mHvMbDY7TClSW7b3yNPT02F/SUlJpT/Vs4mLi8Pw4cOdjvTOy8vD5cuXMXToUIf9Q4cOtf/5WF3qrI3Tp0+jtLQUY8eOrVX548ePY8+ePfDw8Kh0LCkpyf5nZ+U/Y4C1Taub0sIZf39/jB8/Hhs3bsTw4cORnJyMQ4cO4Z133rGXiY2NxcqVKxEXF4erV6/aR6dcuHAB3bt3d6k+oHaflUWLFmH8+PHo0qULJk2ahBtuuAETJkxwuS4iIiKimowePdqh76PT6QBY+2RHjx51GHlbVlaGkpISFBUVQavVYs+ePXj22WcRHx+PvLw8mM1mlJSUoLCw0H6d+hgwYIB9uy797T59+mDs2LHo1asXJk6ciAkTJmDmzJnw9vZ2KKPVau3PY2JiUFBQgNTUVERERCApKQlPPPEEfvnlF2RmZjr0BXv27Im4uDj069cPPj4+TmOozftYk9r05W3Kv2euioyMdLgXKN+/jo+PR0lJCcaPH+9wjtFoRL9+/epc5y233IJXX30VHTp0wKRJkzBlyhRMnToVcnn90kTHjx9HQUEBfH19HfYXFxfb720KCwuxatUqfPPNN7h8+TLMZjOKi4vtI5rrq1evXg7zMjfW/RYRVcZEM1ErUz7ZWX5eMdu/d999t33urfLatWvn9HorV67EvHnzsH37dnz33XdYsWIFPv30U8yYMcPleGwx2eIR5f50rjwhhD12qVRaqVz5aTVs13r//fcdEtYAHBLctWWxWBAdHe2QjLepanGW2iyIWHFes/KvsS511oarCzVaLBZMnToVL7zwQqVjtl9aANW3qSvmz5+P+++/H2+88QY2bdqEHj16oE+fPgCsnc8JEyZgwoQJ+Pjjj+Hv748LFy5g4sSJVf55W0N8Vvr374/k5GR899132LVrF2bNmoVx48bVOAceERERkat0Oh06depUab/FYsGqVatw0003VTqmVqtx/vx5TJkyBffccw+efvpp+Pj44MCBA1i8eHGN089JJJJq+0vlYysfD+Baf1smk2Hnzp04ePAgfvjhB7zxxht47LHHcPjwYfv6KdXFCABTp05FeHg43n//fYSEhMBisaBnz572vmBNfd2a3kdXVNeXt6lPgr+6/rXt3+3btyM0NNShnCsLgVcUHh6OhIQE7Ny5E7t27cK9996LF198Efv27avXQoYWiwXBwcH29W/Ks63v89BDD+H777/HSy+9hE6dOkGj0WDmzJk1TmNRU3/fpmJbNNb9FhFVxkQzURvSv39/nDp1ymmHtjpRUVGIiorCAw88gLlz52LdunW1TjRXp3v37jCbzTh8+DCGDBkCAMjKykJiYqJ9dLW/vz/S09MdOnPlF68LDAxEaGgozp07h/nz5zutx/bb7LKyskr7K+7r378/Nm/ebF+4ojZ69+6NDRs2OF1dWq/XIyQkBAcOHMCIESPs+w8ePIhBgwbVuc7a6Ny5MzQaDXbv3o0777yzxvL9+/fHl19+icjIyHqNZFAoFJXeV2emT5+Ou+++Gzt27MCmTZuwYMEC+7EzZ84gMzMTzz//PMLDwwHAvghlVRriswJY22z27NmYPXs2Zs6ciUmTJuHq1atVjpYhIiIiakj9+/dHQkJClX32Y8eOwWw24+WXX4ZUal126bPPPnMo46yfC1j7S+Xnuz179iyKioqqjae2faiKJBIJhg4diqFDh+LJJ59EREQEtm7digcffBCAddHx4uJie8L4l19+gYeHB8LCwpCVlYXTp09j7dq1GD58OADgwIEDDtfv3bs3/vOf/1TZT6vpfayN2vTlXVHbfnJ53bt3h0qlwoULF+xrmTQUjUaDG2+8ETfeeCPuu+8+dO3aFSdPnkT//v2r/AzVpH///khPT4dcLq9yrZOffvoJixYtst9TFhQUVFqYz1n9NfX3q4upMe63iKgyLgZI1IY88sgjOHToEO677z7ExcXh7Nmz2LZtG/7xj384LV9cXIwlS5Zg7969OH/+PH7++WccPXrU6RQbddG5c2dMmzYNd911Fw4cOIATJ07g1ltvRWhoKKZNmwbAuuLwlStXsHr1aiQlJeGtt97Cd99953CdlStX4rnnnsNrr72GxMREnDx5EuvWrcOaNWsAAAEBAdBoNPbF7XJzcwFY/0Ttt99+Q0JCAjIzM2EymTB//nz4+flh2rRp+Omnn5CcnIx9+/bh/vvvx8WLF52+jiVLliAvLw9z5szBsWPHcPbsWXz00UdISEgAYP2N/QsvvIDNmzcjISEBy5cvR1xcHO6//34AqFOdtaFWq/HII4/g4YcfxocffoikpCT88ssv+OCDD5yWv++++3D16lXMnTsXR44cwblz5/DDDz/gjjvucKmTGRkZid27dyM9PR3Z2dlVltPpdJg2bRqeeOIJnD59GvPmzbMfa9euHZRKJd544w2cO3cO27Ztw9NPP11tvQ3xWXnllVfw6aef4syZM0hMTMTnn3+OoKAg++gLIiIiosb25JNP4sMPP8TKlStx6tQpnD59Gps3b8bjjz8OAOjYsSPMZrO9n/TRRx/h3XffdbhGZGQkCgoKsHv3bmRmZtqTyWPGjMGbb76JX3/9FceOHcM999xTq9GrNfWhKjp8+DCeffZZHDt2DBcuXMCWLVtw5coVh/sIo9GIxYsXIz4+3v6Xk0uWLIFUKoW3tzd8fX3x3nvv4Y8//sCPP/5oT1DbzJ07F0FBQZg+fTp+/vlnnDt3Dl9++SUOHTpUq/extmrqy7uitv3k8jw9PbFs2TI88MAD2LBhA5KSkhAbG4u33nqrysUYAeDq1auIi4tDfHw8ACAhIQFxcXFIT08HAKxfvx4ffPABfv/9d/vnSKPRICIiwh7r/v37cenSJWRmZtb6NY4bNw4xMTGYPn06vv/+e6SkpODgwYN4/PHH7QNHOnXqhC1btiAuLg4nTpzAvHnzKv2FpLP6a9Pfd6ax7reIyAn3TA1NRHVV02KA5Rd5yM7OFgDEnj177PuOHDkixo8fLzw8PIROpxO9e/eutLiFTWlpqZgzZ44IDw8XSqVShISEiCVLltgXDqzNYoAVF9u7//77xciRI+3Pr169KhYsWCAMBoPQaDRi4sSJIjEx0eGcd955R4SHhwudTiduu+028cwzzzgs+CCEEBs3bhR9+/YVSqVSeHt7ixEjRogtW7bYj7///vsiPDxcSKVSe/0ZGRn296L8+5SWliZuu+024efnJ1QqlejQoYO46667RG5urtP3SQghTpw4ISZMmCC0Wq3w9PQUw4cPF0lJSUIIIcrKysSqVatEaGioUCgUok+fPuK7775zOL+mOuuyGKCt7n//+98iIiJCKBQK0a5dO/uiKM4+M4mJiWLGjBnCy8tLaDQa0bVrV/HPf/7TvnDGyJEjxf333+9QZ8UFQLZt2yY6deok5HJ5pXaqaPv27QKAGDFiRKVjmzZtEpGRkUKlUomYmBixbds2h3grLgYoRP0/K++9957o27ev0Ol0Qq/Xi7Fjx4pff/212tdARERE5Cpn/eTyduzYIYYMGSI0Go3Q6/Vi0KBB4r333rMfX7NmjQgODrb3nz/88MNK/aJ77rlH+Pr6CgBixYoVQgghLl26JCZMmCB0Op3o3Lmz+Pbbb50uBlhx4Tghau5vlxcfHy8mTpwo/P39hUqlElFRUQ4Lvdle/5NPPil8fX2Fh4eHuPPOOx0WkNu5c6fo1q2bUKlUonfv3mLv3r2VFtNLSUkRN998s9Dr9UKr1YoBAwaIw4cP1/p9rMhZ/7qmvnx171lFzvrJtVngzmKxiNdee0106dJFKBQK4e/vLyZOnCj27dtXZV3r1q0TACo9bJ+FrVu3iuuuu07o9Xqh0+nE4MGDxa5du+znHzp0SPTu3VuoVKpK70l5Fe8FhLAuSv6Pf/xDhISECIVCIcLDw8X8+fPFhQsX7O/Z6NGjhUajEeHh4eLNN9+sdJ9RVf019fer+m7V5R6PiFwnEaKKSVKJiIiIiIiIiBrYokWLkJOTg6+++srdoRARUQPi1BlEREREREREREREVC9MNBMRERERERERERFRvXDqDCIiIiIiIiIiIiKqF45oJiIiIiIiIiIiIqJ6YaKZiIiIiIiIiIiIiOqFiWYiIiIiIiIiIiIiqhcmmomIiIiIiIiIiIioXphoJiIiIiIiIiIiIqJ6YaKZiIiIiIiIiIiIiOqFiWYiIiIiIiIiIiIiqhcmmomIiIiIiIiIiIioXphoJiIiIiIiIiIiIqJ6+X9APG5aBIzc1gAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.cm as cm\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from sklearn.cluster import KMeans\n", + "from sklearn.datasets import make_blobs\n", + "from sklearn.metrics import silhouette_samples, silhouette_score\n", + "\n", + "\n", + "for label_name in [\"level1\", \"level2\", \"level3\"]:\n", + " y = test_data.obs[label_name]\n", + " n_clusters = y.nunique()\n", + " # Create a subplot with 1 row and 2 columns\n", + " fig, (ax1, ax2) = plt.subplots(1, 2)\n", + " fig.set_size_inches(18, 7)\n", + "\n", + " # The 1st subplot is the silhouette plot\n", + " # The silhouette coefficient can range from -1, 1 but in this example all\n", + " # lie within [-0.1, 1]\n", + " ax1.set_xlim([-0.1, 1])\n", + " # The (n_clusters+1)*10 is for inserting blank space between silhouette\n", + " # plots of individual clusters, to demarcate them clearly.\n", + " ax1.set_ylim([0, len(X) + (n_clusters + 1) * 10])\n", + "\n", + " # # Initialize the clusterer with n_clusters value and a random generator\n", + " # # seed of 10 for reproducibility.\n", + " # clusterer = KMeans(n_clusters=n_clusters, random_state=10)\n", + " label_encoder = LabelEncoder()\n", + " cluster_labels = label_encoder.fit_transform(y)\n", + "\n", + " # The silhouette_score gives the average value for all the samples.\n", + " # This gives a perspective into the density and separation of the formed\n", + " # clusters\n", + " silhouette_avg = silhouette_score(X, cluster_labels)\n", + " print(\n", + " \"For n_clusters =\",\n", + " n_clusters,\n", + " \"The average silhouette_score is :\",\n", + " silhouette_avg,\n", + " )\n", + "\n", + " # Compute the silhouette scores for each sample\n", + " sample_silhouette_values = silhouette_samples(X, cluster_labels)\n", + "\n", + " y_lower = 10\n", + " for i in range(n_clusters):\n", + " # Aggregate the silhouette scores for samples belonging to\n", + " # cluster i, and sort them\n", + " ith_cluster_silhouette_values = sample_silhouette_values[cluster_labels == i]\n", + "\n", + " ith_cluster_silhouette_values.sort()\n", + "\n", + " size_cluster_i = ith_cluster_silhouette_values.shape[0]\n", + " y_upper = y_lower + size_cluster_i\n", + "\n", + " color = cm.nipy_spectral(float(i) / n_clusters)\n", + " ax1.fill_betweenx(\n", + " np.arange(y_lower, y_upper),\n", + " 0,\n", + " ith_cluster_silhouette_values,\n", + " facecolor=color,\n", + " edgecolor=color,\n", + " alpha=0.7,\n", + " )\n", + "\n", + " # Label the silhouette plots with their cluster numbers at the middle\n", + " ax1.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))\n", + "\n", + " # Compute the new y_lower for next plot\n", + " y_lower = y_upper + 10 # 10 for the 0 samples\n", + "\n", + " ax1.set_title(\"The silhouette plot for the various clusters.\")\n", + " ax1.set_xlabel(\"The silhouette coefficient values\")\n", + " ax1.set_ylabel(\"Cluster label\")\n", + "\n", + " # The vertical line for average silhouette score of all the values\n", + " ax1.axvline(x=silhouette_avg, color=\"red\", linestyle=\"--\")\n", + "\n", + " ax1.set_yticks([]) # Clear the yaxis labels / ticks\n", + " ax1.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])\n", + "\n", + " # 2nd Plot showing the actual clusters formed\n", + " colors = cm.nipy_spectral(cluster_labels.astype(float) / n_clusters)\n", + " ax2.scatter(\n", + " X[:, 0], X[:, 1], marker=\".\", s=30, lw=0, alpha=0.7, c=colors, edgecolor=\"k\"\n", + " )\n", + "\n", + " # # Labeling the clusters\n", + " # centers = clusterer.cluster_centers_\n", + " # # Draw white circles at cluster centers\n", + " # ax2.scatter(\n", + " # centers[:, 0],\n", + " # centers[:, 1],\n", + " # marker=\"o\",\n", + " # c=\"white\",\n", + " # alpha=1,\n", + " # s=200,\n", + " # edgecolor=\"k\",\n", + " # )\n", + "\n", + " # for i, c in enumerate(centers):\n", + " # ax2.scatter(c[0], c[1], marker=\"$%d$\" % i, alpha=1, s=50, edgecolor=\"k\")\n", + "\n", + " ax2.set_title(\"The visualization of the clustered data.\")\n", + " ax2.set_xlabel(\"Feature space for the 1st feature\")\n", + " ax2.set_ylabel(\"Feature space for the 2nd feature\")\n", + "\n", + " plt.suptitle(\n", + " \"Silhouette analysis for KMeans clustering on sample data with n_clusters = %d\"\n", + " % n_clusters,\n", + " fontsize=14,\n", + " fontweight=\"bold\",\n", + " )\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Downstream task" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "LATENT_DIM = 16\n", + "DATA = test_data\n", + "LEVEL = 'level3'\n", + "HIDDEN_DIM = 16 * 4" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\adamb\\AppData\\Local\\Temp\\ipykernel_26028\\2057320055.py:9: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " X = torch.tensor(DATA.obsm[LATENT_NAME], dtype=torch.float32)\n" + ] + } + ], + "source": [ + "# Extract the labels (cell types)\n", + "labels = DATA.obs[LEVEL].values\n", + "\n", + "# Encode labels to integers\n", + "label_encoder = LabelEncoder()\n", + "labels_encoded = label_encoder.fit_transform(labels)\n", + "\n", + "# Convert to PyTorch tensors\n", + "X = torch.tensor(DATA.obsm[LATENT_NAME], dtype=torch.float32)\n", + "y = torch.tensor(labels_encoded, dtype=torch.long)\n", + "\n", + "# Split the data into training and testing sets\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", + "\n", + "# Create DataLoader for training and testing sets\n", + "train_dataset = TensorDataset(X_train, y_train)\n", + "test_dataset = TensorDataset(X_test, y_test)\n", + "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n", + "test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "from models.building_blocks import Block\n", + "\n", + "\n", + "class ClassificationModel(pl.LightningModule):\n", + " def __init__(self, latent_dim, num_classes, hidden_dim, do_batch_norm=False):\n", + " super().__init__()\n", + " self.layers = nn.Sequential(\n", + " nn.Linear(latent_dim, hidden_dim),\n", + " nn.ReLU(),\n", + " nn.Linear(hidden_dim, num_classes),\n", + " )\n", + " self.loss = nn.CrossEntropyLoss() # Adjust\n", + "\n", + " def forward(self, z):\n", + " return self.layers(z)\n", + "\n", + " def training_step(self, batch, batch_idx):\n", + " x, y = batch\n", + " y_hat = self.forward(x)\n", + " loss = self.loss(y_hat, y)\n", + " self.log(\n", + " \"train_loss\", loss, on_step=True, on_epoch=True, prog_bar=True, logger=True\n", + " )\n", + " return loss\n", + "\n", + " def validation_step(self, batch, batch_idx):\n", + " x, y = batch\n", + " y_hat = self.forward(x)\n", + " loss = self.loss(y_hat, y)\n", + " self.log(\n", + " \"val_loss\", loss, on_step=False, on_epoch=True, prog_bar=True, logger=True\n", + " )\n", + " \n", + " return loss\n", + "\n", + " def configure_optimizers(self):\n", + " # Define optimizer here\n", + " optimizer = torch.optim.Adam(\n", + " self.parameters(), lr=0.001\n", + " ) # Adjust learning rate\n", + " return optimizer" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: False, used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "--------------------------------------------\n", + "0 | layers | Sequential | 3.7 K \n", + "1 | loss | CrossEntropyLoss | 0 \n", + "--------------------------------------------\n", + "3.7 K Trainable params\n", + "0 Non-trainable params\n", + "3.7 K Total params\n", + "0.015 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9f7e12dbd1724f568c2c17f7351c9fc1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | | 0/? [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GEX_n_genes_by_countsGEX_pct_counts_mtGEX_size_factorsGEX_phaseADT_n_antibodies_by_countsADT_total_countsADT_iso_countcell_typebatchADT_pseudotime_order...DonorRaceEthnicityDonorGenderQCMedsDonorSmokeris_trainlevel1level2level3description
036324.4704902.311520G2M1354152.024.0NKs4d1NaN...WhiteHISPANIC OR LATINOMaleFalseNonsmokertestNatural Killer CellsNKNKNatural Killer Cells
117818.8433790.789157G2M1386323.030.0NKs4d1NaN...WhiteHISPANIC OR LATINOMaleFalseNonsmokertestNatural Killer CellsNKNKNatural Killer Cells
213914.8913040.556811G11375038.048.0CD8+ T CD69+ CD45RA+s4d1NaN...WhiteHISPANIC OR LATINOMaleFalseNonsmokertestT CellsCD8+ T CellsCD8+ T CD69+ CD45RA+CD8+ T Cells expressing CD69 and CD45RA
317897.4125870.733487G2M1343586.026.0NK CD158e1+s4d1NaN...WhiteHISPANIC OR LATINOMaleFalseNonsmokertestNatural Killer CellsNK CD158e1+NK CD158e1+Natural Killer Cells expressing CD158e1
436443.9353152.522098G11342841.032.0HSCs4d10.352826...WhiteHISPANIC OR LATINOMaleFalseNonsmokertestHematopoietic Stem Cells and ProgenitorsHSCHSCHematopoietic Stem Cells
..................................................................
1506118558.7798920.702011G2M1242093.012.0Naive CD20+ B IGKC-s4d9NaN...Other RaceHISPANIC OR LATINOMaleFalseNonsmokertestB Cells and Plasma CellsNaive B CellsNaive CD20+ B IGKC-Naive B Cells expressing CD20, not IGKC
1506214844.9743690.508755S1242695.014.0CD8+ T naives4d9NaN...Other RaceHISPANIC OR LATINOMaleFalseNonsmokertestT CellsCD8+ T CellsCD8+ T naiveNaive CD8+ T Cells
150638018.8424430.232119G11323590.014.0T regs4d9NaN...Other RaceHISPANIC OR LATINOMaleFalseNonsmokertestT CellsSpecial T Cell TypesT regRegulatory T Cells
1506416308.5006110.549119G11335432.017.0CD4+ T naives4d9NaN...Other RaceHISPANIC OR LATINOMaleFalseNonsmokertestT CellsCD4+ T CellsCD4+ T naiveNaive CD4+ T Cells
1506517467.0742210.661751G2M1372665.010.0CD8+ T naives4d9NaN...Other RaceHISPANIC OR LATINOMaleFalseNonsmokertestT CellsCD8+ T CellsCD8+ T naiveNaive CD8+ T Cells
\n", + "

15066 rows × 30 columns

\n", + "" + ], + "text/plain": [ + " GEX_n_genes_by_counts GEX_pct_counts_mt GEX_size_factors GEX_phase \\\n", + "0 3632 4.470490 2.311520 G2M \n", + "1 1781 8.843379 0.789157 G2M \n", + "2 1391 4.891304 0.556811 G1 \n", + "3 1789 7.412587 0.733487 G2M \n", + "4 3644 3.935315 2.522098 G1 \n", + "... ... ... ... ... \n", + "15061 1855 8.779892 0.702011 G2M \n", + "15062 1484 4.974369 0.508755 S \n", + "15063 801 8.842443 0.232119 G1 \n", + "15064 1630 8.500611 0.549119 G1 \n", + "15065 1746 7.074221 0.661751 G2M \n", + "\n", + " ADT_n_antibodies_by_counts ADT_total_counts ADT_iso_count \\\n", + "0 135 4152.0 24.0 \n", + "1 138 6323.0 30.0 \n", + "2 137 5038.0 48.0 \n", + "3 134 3586.0 26.0 \n", + "4 134 2841.0 32.0 \n", + "... ... ... ... \n", + "15061 124 2093.0 12.0 \n", + "15062 124 2695.0 14.0 \n", + "15063 132 3590.0 14.0 \n", + "15064 133 5432.0 17.0 \n", + "15065 137 2665.0 10.0 \n", + "\n", + " cell_type batch ADT_pseudotime_order ... DonorRace \\\n", + "0 NK s4d1 NaN ... White \n", + "1 NK s4d1 NaN ... White \n", + "2 CD8+ T CD69+ CD45RA+ s4d1 NaN ... White \n", + "3 NK CD158e1+ s4d1 NaN ... White \n", + "4 HSC s4d1 0.352826 ... White \n", + "... ... ... ... ... ... \n", + "15061 Naive CD20+ B IGKC- s4d9 NaN ... Other Race \n", + "15062 CD8+ T naive s4d9 NaN ... Other Race \n", + "15063 T reg s4d9 NaN ... Other Race \n", + "15064 CD4+ T naive s4d9 NaN ... Other Race \n", + "15065 CD8+ T naive s4d9 NaN ... Other Race \n", + "\n", + " Ethnicity DonorGender QCMeds DonorSmoker is_train \\\n", + "0 HISPANIC OR LATINO Male False Nonsmoker test \n", + "1 HISPANIC OR LATINO Male False Nonsmoker test \n", + "2 HISPANIC OR LATINO Male False Nonsmoker test \n", + "3 HISPANIC OR LATINO Male False Nonsmoker test \n", + "4 HISPANIC OR LATINO Male False Nonsmoker test \n", + "... ... ... ... ... ... \n", + "15061 HISPANIC OR LATINO Male False Nonsmoker test \n", + "15062 HISPANIC OR LATINO Male False Nonsmoker test \n", + "15063 HISPANIC OR LATINO Male False Nonsmoker test \n", + "15064 HISPANIC OR LATINO Male False Nonsmoker test \n", + "15065 HISPANIC OR LATINO Male False Nonsmoker test \n", + "\n", + " level1 level2 \\\n", + "0 Natural Killer Cells NK \n", + "1 Natural Killer Cells NK \n", + "2 T Cells CD8+ T Cells \n", + "3 Natural Killer Cells NK CD158e1+ \n", + "4 Hematopoietic Stem Cells and Progenitors HSC \n", + "... ... ... \n", + "15061 B Cells and Plasma Cells Naive B Cells \n", + "15062 T Cells CD8+ T Cells \n", + "15063 T Cells Special T Cell Types \n", + "15064 T Cells CD4+ T Cells \n", + "15065 T Cells CD8+ T Cells \n", + "\n", + " level3 description \n", + "0 NK Natural Killer Cells \n", + "1 NK Natural Killer Cells \n", + "2 CD8+ T CD69+ CD45RA+ CD8+ T Cells expressing CD69 and CD45RA \n", + "3 NK CD158e1+ Natural Killer Cells expressing CD158e1 \n", + "4 HSC Hematopoietic Stem Cells \n", + "... ... ... \n", + "15061 Naive CD20+ B IGKC- Naive B Cells expressing CD20, not IGKC \n", + "15062 CD8+ T naive Naive CD8+ T Cells \n", + "15063 T reg Regulatory T Cells \n", + "15064 CD4+ T naive Naive CD4+ T Cells \n", + "15065 CD8+ T naive Naive CD8+ T Cells \n", + "\n", + "[15066 rows x 30 columns]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_data.obs" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(test_data.obs[\"level1\"].value_counts())" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "18" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(test_data.obs[\"level2\"].value_counts())" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "40" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(test_data.obs[\"level3\"].value_counts())" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "AnnData object with n_obs × n_vars = 15066 × 14087\n", + " obs: 'GEX_n_genes_by_counts', 'GEX_pct_counts_mt', 'GEX_size_factors', 'GEX_phase', 'ADT_n_antibodies_by_counts', 'ADT_total_counts', 'ADT_iso_count', 'cell_type', 'batch', 'ADT_pseudotime_order', 'GEX_pseudotime_order', 'Samplename', 'Site', 'DonorNumber', 'Modality', 'VendorLot', 'DonorID', 'DonorAge', 'DonorBMI', 'DonorBloodType', 'DonorRace', 'Ethnicity', 'DonorGender', 'QCMeds', 'DonorSmoker', 'is_train', 'level1', 'level2', 'level3', 'description'\n", + " var: 'feature_types', 'gene_id'\n", + " uns: 'dataset_id', 'genome', 'organism', 'log1p'\n", + " obsm: 'ADT_X_pca', 'ADT_X_umap', 'ADT_isotype_controls', 'GEX_X_pca', 'GEX_X_umap'\n", + " layers: 'counts'" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_data" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "mask = test_data.var[\"feature_types\"] == \"ADT\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load Latent" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# LATENT_NAME = \"latent_omiae\"\n", + "# DATA_PATH = \"../data/latent/latent_omiae_test\"" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'.'" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os \n", + "os.curdir" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "LATENT_NAME = \"latent_omiiwae\"\n", + "DATA_PATH = \"../data/omiiwae_simple_2024-06-15_11-21-23/latent_test.zip\"" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "test_data.obsm[LATENT_NAME] = torch.load(DATA_PATH)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize latent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### UMAP" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# UMAP representation of latent embedding\n", + "# Clustering by all call_types\n", + "import scanpy as sc\n", + "from sklearn.metrics import silhouette_score, davies_bouldin_score\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Input: AnnData Object, 'embedding name', n_neighnors\n", + "# Silhouttte Score: Ranges from -1 to 1, higher values indicate better cluster separation\n", + "# Davies-Bouldine-Index: A low index indicates that clusters are well separates\n", + "\n", + "def umap_and_scores(adata, embedding_key, n_neighbors=20):\n", + " sc.pp.neighbors(adata, n_neighbors=n_neighbors, use_rep=embedding_key)\n", + " sc.tl.umap(adata)\n", + "\n", + " sc.pl.umap(adata, color='cell_type', size=20, ncols=1)\n", + " plt.show()\n", + "\n", + " umap_coords = adata.obsm['X_umap']\n", + " labels = adata.obs['cell_type']\n", + "\n", + " sil_score = silhouette_score(umap_coords, labels)\n", + " print(f'Silhouette-Score: {sil_score}')\n", + "\n", + " db_score = davies_bouldin_score(umap_coords, labels)\n", + " print(f'Davies-Bouldin-Index for: {db_score}')\n", + "\n", + "# Example\n", + "# umap_and_scores(adata, 'latent_embedding_combined_3', n_neighbors=30)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABMoAAAGvCAYAAACq8jl3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3xN9xvA8c+9N3tLQpaQRCJir5o1axelLYraRVGjNUpbu7R+qFGjihqlVmtTe2+pTcSMEImQIXvde39/XLlyJSEhMZ/36xVyz/mec74nyb333Oc83+er0Gq1WoQQQgghhBBCCCGEeMcpX3UHhBBCCCGEEEIIIYR4HUigTAghhBBCCCGEEEIIJFAmhBBCCCGEEEIIIQQggTIhhBBCCCGEEEIIIQAJlAkhhBBCCCGEEEIIAUigTAghhBBCCCGEEEIIQAJlQgghhBBCCCGEEEIAEigTQgghhBBCCCGEEAKQQJkQQgghhBBCCCGEEIAEyoQQT1AoFIwZM0b/ePHixSgUCoKCgl5Zn4QQQgghhBBCiJdBAmVCiDx35MgRxowZQ3R09KvuihBCCCGEEEIIkWMSKBNC5LkjR44wduxYCZQJIYQQQgghhHijSKBMCCGEEEIIIYQQQggkUCbEWyMkJIQePXrg6uqKqakpnp6e9OnTh5SUFACio6MZNGgQ7u7umJqa4u3tzaRJk9BoNHnajzFjxjB06FAAPD09USgU+hpnderUoVy5cllu5+vrS+PGjQEICgpCoVAwZcoUpk2bRtGiRTE3N6dOnTpcuHAh07aXL1/m008/xd7eHjMzMypXrszGjRvz9LyEEEIIIYQQQrz9jF51B4QQL+7u3btUqVKF6OhoevXqRYkSJQgJCeHvv/8mISGBtLQ06tSpQ0hICL1796ZIkSIcOXKEESNGEBoayvTp0/OsLx9//DFXrlxhxYoVTJs2DUdHRwAKFixIp06d6NmzJxcuXKB06dL6bU6ePMmVK1f44YcfDPa1dOlSYmNj6devH0lJScyYMYP69etz/vx5nJycALh48SI1a9bEzc2N4cOHY2lpyerVq2nVqhX//PMPrVu3zrNzE0IIIYQQQgjxdpNAmRBvgREjRhAWFsbx48epXLmyfvm4cePQarVMmDCB69evc/r0aXx8fADo3bs3rq6uTJ48mcGDB+Pu7p4nfSlbtiwVK1ZkxYoVtGrVCg8PD/26Nm3a0L9/f5YtW8bPP/+sX75s2TIsLS35+OOPDfZ17do1rl69ipubGwBNmjShatWqTJo0iV9++QWAgQMHUqRIEU6ePImpqSkAffv25f333+fbb7+VQJkQQgghhBBCiByToZdCvOE0Gg3r16+nRYsWBkGydAqFgjVr1lCrVi0KFCjAgwcP9F8NGjRArVZz4MCBl9JXW1tbPvroI1asWIFWqwVArVazatUqWrVqhaWlpUH7Vq1a6YNkAFWqVKFq1aps3boVgMjISPbs2UPbtm2JjY3Vn1dERASNGzfm6tWrhISEvJRzE0IIIYQQQgjx5pOMMiHecPfv3ycmJsZgKOOTrl69yrlz5yhYsGCW68PDw/Ore5l07tyZVatWcfDgQWrXrs2uXbu4d+8enTp1ytQ2Pfsto+LFi7N69WpAl3Gm1WoZOXIkI0eOzPJ44eHhBsE2IYQQQgghhBAiOxIoE+IdoNFoaNiwIcOGDctyffHixV9aXxo3boyTkxPLli2jdu3aLFu2DGdnZxo0aJDrfaVPRDBkyBD9RABP8vb2fqH+CiGEEEIIIYR4d0igTIg3XMGCBbGxsclyNsh0xYoVIy4u7rmCUc9DoVBku06lUtGhQwcWL17MpEmTWL9+PT179kSlUmVqe/Xq1UzLrly5oq975uXlBYCxsfFLOzchhBBCCCGEEG8vqVEmxBtOqVTSqlUrNm3ahL+/f6b1Wq2Wtm3bcvToUbZv355pfXR0NGlpaXnap/RaY9HR0Vmu79SpE1FRUfTu3Zu4uDg+//zzLNutX7/eoMbYiRMnOH78OE2bNgWgUKFC1K1bl3nz5hEaGppp+/v377/gmQghhBBCCCGEeJcotOkVtYUQb6yQkBAqV65MTEwMvXr1ws/Pj9DQUNasWcOhQ4cwMTGhVq1anDt3jq5du1KpUiXi4+M5f/48f//9N0FBQTg6OgK6bLDRo0czZswYABYvXky3bt24efOmwQyWT3Py5EmqVKlCs2bN+OyzzzA2NqZFixYGxfrLlCnDhQsX8PPz49KlSwbbBwUF4enpSZkyZYiNjaVPnz4kJyczffp0FAoF58+fx8XFBYBLly7x/vvvo1Qq6dmzJ15eXty7d4+jR49y584dzp49++I/YCGEEEIIIYQQ7wQZeinEW8DNzY3jx48zcuRIli9fTkxMDG5ubjRt2hQLCwtMTEzYv38/EydOZM2aNSxduhQbGxuKFy/O2LFjsbW1zdP+vPfee4wfP57ffvuNbdu2odFouHnzpkGgrHPnzgwbNizLIv4Z2yiVSqZPn054eDhVqlRh1qxZ+iAZQMmSJfH392fs2LEsXryYiIgIChUqRIUKFRg1alSenpcQQgghhBBCiLebZJQJIV6JGTNm8PXXXxMUFESRIkUM1qVnlE2ePJkhQ4a8oh4KIYQQQgghhHjXSI0yIcRLp9VqWbhwIXXq1MkUJBNCCCGEEEIIIV4VGXophMixuLg44uLintqmYMGCWc5gCRAfH8/GjRvZu3cv58+fZ8OGDfnRTSGEEEIIIYQQ4rlIoEwIkWNTpkxh7NixT23ztKL/9+/fp0OHDtjZ2fHdd9/RsmXLfOilEEIIIYQQQgjxfKRGmRAix27cuMGNGzee2ub999/HzMzsJfVICCGEEEIIIYTIOxIoE0IIIYQQQgghhBACKeYvhBBCCCGEEEIIIQTwimqUaTQa7t69i7W1NQqF4lV0QQghhBC5pNVqiY2NxdXVFaVS7rUJIYQQQoi3zysJlN29exd3d/dXcWghhBBCvKDbt29TuHDhV90NIYQQQggh8twrCZRZW1sDugttGxubV9EFIYQQQuRSTEwM7u7u+vdxIYQQQggh3javJFCWPtzSxsZGAmVCCCHEG0bKJgghhBBCiLeVFBgRQgghhBBCCCGEEAIJlAkhhBBCCCGEEEIIAUigTAghhBBCCCGEEEIIQAJlQgghhBBCCCGEEEIAEigTQgghhBBCCCGEEAKQQJkQQgghhBBCCCGEEIAEyoQQQgghhBBCCCGEACRQJoQQQgghhBBCCCEEIIEyIYQQQgghhBBCCCEACZQJIYQQQgghhBBCCAFIoEwIIYQQQgghhBBCCEACZUIIIYQQQgghhBBCABIoE0K85lLVaVyPCiFNk0bXrZPwmteR1Zf3vepuCSGEEEIIIYR4Cxm96g4IIURGgZG3mXJ8Ff9cOUB8ahJqrQa1VoNKoUSt1QAw+tBi2paom+0+YpMTOP/gBhUKeZOiTuPAnXMUt3cnMjGG5v98h5FSxZ7PplLK0fMlnZUQQgghhBBCiDeBBMqEEK+NuJREyv7RgxRNWqZ16UEygAJmVgD8dnojm68fpYR9UfpUaIGzpT2mRiZUW9aPSxG3sDAyJSEtOctj9dkxnQMdZuTPiQghhBBCCCGEeCNJoEwI8cpFJcWyKmAfow8vyjJI9qSToZfps30av53dBMCWG8eZ6r8aBVDDrTSXIm4BZBskAyhb0CtP+i6EEEIIIYQQ4u0hgTIhxCuzM8ifthvGEZ0c98y2KhSo0QKQptXog2QZaYHDIRdydOzbsfdz1VchhBBCCCGEEG8/KeYvhHhptFote26dYn/wWa5FhTDr1PpMQTIlikzbHWg/nYaelV9WN4UQQgghhBBCvKMko0wI8dJ8f3AhPx37CwAF0MyrWqY2mkdZY5+XbEBEYgy3Y++z+foxgmPC9W0yFvbPDQUKSti7U8HJmxkf9H++kxBCCCGEEEII8daSQJkQIt9diwoB4Fz4Df0yLbDlxrFstzkeeplrUSFo0XLhwU0qFvLRr3veQJkWLeNrdecT39q53lYIIYQQQgghxNtPhl4KIfLV1uvH8F3QhRILutAkh8Mni9oU4mrUHbSPssuMFCqaF6uuX5+Tgv9Pqubixxdlm9HSu0autxVCCCGEEEII8W6QjDIhRJ6LTorlaMglfjr2F0ExYWgeZX/dS4jGxdKB0PgIg/YKFPqgGICbpSO3Mgy1NFIoGXd06XP3p7lXVbYF+aPWakhWp2Kskpc+IYQQQgghhBCZKbRarfbZzfJWTEwMtra2PHz4EBsbm5d9eCFEHtJqtRy5up/gB0FsuneNXbcvcj/pYZZtzVQmpKpT9bNXviwK0B9xe5tJNPJ876UeX4i3hbx/CyGEEEKIt52kVQghXkh8cjyjjvyFf+RtYtKSn9o2SZ3yknplKGNYbtShRRIoE0IIIYQQQgiRJalRJoR4IT8fX8We8GvPDJK9SgVMrVCgAHSTBCSnvZqAnRBCCCGEEEKI15tklAkhcuV+QjT9d/2Kt78rw3Z/hkNRGyj/jI208ChOlTftcqle0QpUdy3J72e30K1ME0yNTPL+IEIIIYQQQggh3ngSKBNC5EqnzRPZftMfrCCw4m1mnunPN+XmZh/g0oK52oREoxxmcaWagXFSrvpkrjIh8SnDOk1Vxgyp0o4hVdrlar9CCCGEEEIIId4tEigTQuTKxQe39EGx+6YPGVlq0TOzwNQKDSZKI1I0aU9vqACMchckA7INkilR8GOtHvSt2DLX+xRCCCGEEEII8e6RGmVCiFwpbO2IidqI7jebMv+/wdQLL//0DRSQokp7dpAsQ/u8UrqgJyOqd8DW1CrvdiqEEEIIIYQQ4q0lgTIhRI4dDblIYORtUpRpdA5qRJhZJKvd973UPlibWGCXTeDLVGVMIXNbAHqV/ZADHaa/xJ4JIYQQQgghhHjTKbRarfZlHzQmJgZbW1sePnyIjY3Nyz68EOI5PEyOw2FGK9RoAFBplGgUWrSKl/4S8lTRAzai1mqwN5fXFiHymrx/CyGEEEKIt51klAkhnunig5t8tHakPkgGoFZq8i1IZqJ4XD7RSKGkpEPRbNu6WTnysc/7FLSwY8h7bbE1s5IgmRBCCCGEEEKI5yLF/IUQzzRk7zz23z4LgBFK0jIEzLJjpFQx4f3ufHtgfq6Pl6J9XM/M1cqRC93/oN/O6YTERlDQwpaF5//Vr9/48Y9UdC6e62MIIYQQQgghhBBPkowyIcQzFbcvDICJ0oia7mVytE2aRs33BxZS2Kpgjto/WcPfWKkCoGOpBvx74zhzz2xi4/UjnAwLNGhXe8UgIhIf5ugYQgghhBBCCCHE00igTAjxTL/U68PGj3+kiVcVfWaZgWxGYKah4U7cfX3QKyuWxmZ0KtUw0y5SNWoAFpzdgo2pJYpHobTrUSEG7eJTkwiLj8zxuQghhBBCCCGEENmRQJkQ4pkuRwYz5cRqDt4+/1zbpwe9lBnyxko5eNC9dBOufLGUdiXq4mrlgIeNM0WsC2FlbIa5kSkA9xMfMu/MJoZVaQdAfFqywb6beFahlKPnc/VLCCGEEEIIIYTISGqUCSGeSq1RU2VpXxKeCFAZeHLcZDb8HIpyMSIIgIsRQVyMCGJ5wG6S1an82mAAE48uJzQ+giI2hehXoRXf7v8dgGWXdlHMzjXLffYo2zQ3pyOEEEIIIYQQQmRLodVq82fauqeQ6eWFeHM8TI7DbkbLfD+OnYklMSkJaB4NwjRTmZCsTsluVCcAHrbOHO04C2cr+3zvnxBC3r+FEEIIIcTbT4ZeCiGeytbUCmsT8zzf7/tupSlgagWAAgXRKfH6IBlA0jOCZM4W9lz5YqkEyYQQQgghhBBC5BkJlAkhnqmAmfUL78NUZUxBC1tAN1Jzct0vUSh0L0FatBgpVFmO4Mw4EYC5ykT/fVhCJBOPLX/hfgkhhBBCCCHEq7J48WLs7Oye2mbMmDGUL1/+pfRHSKBMCJEDPco0e67tVIrHLzGuVg7YmFgCukkyP98ykV8bfEV115JMrtubG72X81Ptngbb25laUcmpuP6x5on9/3F+23P1Swgh0nXt2hWFQqH/cnBwoEmTJpw7d86g3YQJE6hRowYWFhbPvJhNV7duXYN9Ozk50aZNG27duvXM7QYNGmSw7Nq1a3Tv3p0iRYpgamqKm5sbH3zwAcuXLyctLU3fTqFQsH79ev3j1NRU2rdvj5ubGxcuXNDvq1u3bhQuXBhTU1M8PT1p3749/v7+OTovIcSzhYWF0b9/f7y8vDA1NcXd3Z0WLVqwe/dufRsPDw/964O5uTkeHh60bduWPXv2ZNrfgAEDqFSpEqamptl+WNZqtUyZMoXixYvrXycmTJiQZ+e0ePFiFAoFfn5+mdatWbMGhUKBh4dHnh1PiOeR/r7+888/Gyxfv349CkUOCyu/Azw8PJg+ffqr7sZrSwJlQohnOhN+zeCxbwF3vqrw0TO3M1UZ67+/+TCM69F39Y+vR9/lPecSHPl8Fv0qtGLbzRMsubjDYHtzI2P+aDqMWm5lAEhWp+R03gAhxBtLDewDVjz6X53vR2zSpAmhoaGEhoaye/dujIyMaN68uUGblJQU2rRpQ58+fXK17549exIaGsrdu3fZsGEDt2/f5vPPP8/VPk6cOEHFihUJCAhg9uzZXLhwgX379vHFF18wd+5cLl68mOV2CQkJtGzZkpMnT3Lo0CFKly6Nv78/lSpV4sqVK8ybN49Lly6xbt06SpQoweDBg7PcT1BQkHy4EG80jUbD3Zu3uHbuEndv3kKjefLWW94KCgqiUqVK7Nmzh8mTJ3P+/Hm2bdtGvXr16Nevn0HbcePGERoaSmBgIEuXLsXOzo4GDRpkGeDq3r077dq1y/a4AwcOZMGCBUyZMoXLly+zceNGqlSpkm37MWPG0LVr11ydm6WlJeHh4Rw9etRg+cKFCylSpEiu9iXeAVoNhN+B4Cu6/7X5+9xLZ2ZmxqRJk4iKisqzfaakpOTZvsTrTwJlQohnUj4RngqMus2yS7uzaf1YdjNlqhRKOpVqiL25NRuvHuaLbVPotf0XAiIMsyxC46Mo9Ud3Doac1y/TogvAedg483vjb3J/MkKI19hawAOoB3R49L/Ho+X5x9TUFGdnZ5ydnSlfvjzDhw/n9u3b3L9/X99m7NixfP3115QpUyZX+7awsMDZ2RkXFxeqVavGV199xalTp3K8vVarpWvXrhQvXpzDhw/TokULfHx88PHxoX379hw6dIiyZctm2i46OpqGDRty9+5dDh06hKenp35fPj4+HDx4kA8//JBixYpRvnx5Ro8ezYYNG3J1bkK8CW5eCmTFL3PZvGgFe/7eyOZFK1jxy1xuXgrMt2P27dsXhULBiRMn+OSTTyhevDilSpXim2++4dixYwZtra2tcXZ2pkiRItSuXZvff/+dkSNHMmrUKAIDH/dx5syZ9OvXDy8vryyPGRAQwNy5c9mwYQMtW7bE09OTSpUq0bBhwzw9NyMjIzp06MAff/yhX3bnzh327dtHhw4dMrWfO3cuxYoVw8TEBF9fX/7880+D9QqFggULFtC6dWssLCzw8fFh48aNBm32799PlSpVMDU1xcXFheHDhxtk0orX1J1rsGUJ7F8Hx7fr/t+yRLc8nzVo0ABnZ2d++umnbNv8888/lCpVClNTUzw8PJg6darBeg8PD8aPH0/nzp2xsbGhV69e+iGSmzdvxtfXFwsLCz799FMSEhJYsmQJHh4eFChQgAEDBqBWP77RFxUVRefOnSlQoAAWFhY0bdqUq1evZurT+vXr8fHxwczMjMaNG3P79u1s+3/y5EkaNmyIo6Mjtra21KlTx+D6QqvVMmbMGH0muqurKwMGDAB0meu3bt3i66+/1me1CkMSKBNCPNWhOxf45+pBAEyURpgodVli0clxmCqNDdrWLlyWj31qGSzLmFUG4GblyO0vV7H0wxHUXzmYj9aNZN3VQwZtjJVG+u+1WZT0T1anEhQTRnxq4vOf2DskMjaGxOSsg5Y5lZqWxqD5c2g/eQIhEQ/0y9VqNYF3bpOSmpppm5TUVC7cusmdB/fZ6n+c+KRn/77Co6MM2t0MC+PXzevYePwI9x9Gv9A5iNfdWuBT4M4Ty0MeLc/fYFm6uLg4li1bhre3Nw4ODnm678jISFavXk3VqlVzvM2ZM2cICAhgyJAhKJVZX7Y9eYEbFhZGnTp1AN0HTGdnZ/2+Ll68yODBg7PcV06HlArxprh5KZCdK9cRHxNrsDw+JpadK9flS7AsMjKSbdu20a9fPywtLTOtz8nzbODAgWi12lwFrzdt2oSXlxebN2/G09MTDw8PvvjiCyIjI3PT/Rzp3r07q1evJiEhAdANyWzSpAlOTk4G7datW8fAgQMZPHgwFy5coHfv3nTr1o29e/catBs7dixt27bl3LlzNGvWjI4dO+r7HRISQrNmzXjvvfc4e/Ysc+fOZeHChfz44495fl4iD925Bkf/hcQ4w+WJcbrl+RwsU6lUTJw4kV9//ZU7d568roD//vuPtm3b8tlnn3H+/HnGjBnDyJEjWbx4sUG7KVOmUK5cOU6fPs3IkSMBXbb2zJkzWblyJdu2bWPfvn20bt2arVu3snXrVv7880/mzZvH33//rd9P165d8ff3Z+PGjRw9ehStVkuzZs1IzXD9nJCQwIQJE1i6dCmHDx8mOjqazz77LNtzjI2NpUuXLhw6dIhjx47h4+NDs2bNiI3Vvd79888/TJs2jXnz5nH16lXWr1+vv9m3du1aChcurM9oDQ0Nfe6f9dvK6NlNhBDvquS0FPrtnK5/nKIxvHuXrDEMjhgrVHQr05hrUSGce3BD10b9uM2HnlVpVfx9VgXupU/5llyOCAYg8YnMs9RHx1GgQKVQotaqs5wBU53PQyfeBq0mjGTD8aMYKVUcnTyTyj6+BN+/R1xiEiWLFDVoez30LpfvBJOqVnMvOopuHzTGxFgX6Jy3bTMzNukCFZtPHkWpUDKlW29+XLOc4Pvh2FpYYGpsgpFKxfjPu9G9QRMajvqWAxfPYWpsTHJqKrYWljSuWJk/BgzB0sycY5cv8fWCucQlJfJ+ydIkp6ayeM8O7Cwt+bRmbar7lqTHzCn6372RUoW9tTWLBg6lWeWcBxrEm0ANDIQsn+ladFOADAI+AlRZtHkxmzdvxspKNwtvfHw8Li4ubN68OdvAVG7MmTOHBQsWoNVqSUhIoHjx4mzfvj3H21+5cgUAX19f/bLw8HCDrJL//e9/9O3bV/944MCBeHl5sXPnTiwsLPTL0+9elyhR4rnPR4g3hUaj4cjWXU9tc2TrLoqW8MmT53q6a9euodVqX+h5Zm9vT6FChQgKCsrxNjdu3ODWrVusWbOGpUuXolar+frrr/n000+zrHn2IipUqICXlxd///03nTp1YvHixfzyyy/cuHHDoN2UKVPo2rWr/vUpPaNuypQp1KtXT9+ua9eutG/fHoCJEycyc+ZMTpw4QZMmTZgzZw7u7u7MmjULhUJBiRIluHv3Lt9++y2jRo3K09+dyCNaDZw5+PQ2Zw6Cmxco8u/317p1a33G9MKFCw3W/fLLL3zwwQf64Ffx4sW5dOkSkydPNhiOXL9+fYOyBAcPHiQ1NVWfKQnw6aef8ueff3Lv3j2srKwoWbIk9erVY+/evbRr146rV6+yceNGDh8+TI0aNQBYvnw57u7urF+/njZt2gC6mqKzZs3S30xbsmQJfn5+nDhxIssh1PXr1zd4/Pvvv2NnZ8f+/ftp3rw5wcHBODs706BBA4yNjSlSpIh+P/b29qhUKn1Gq8hMAmVCiGx13DyRc/dvPLvhI7tvn2b37dP4ORTF0tgMtUZDtzJNuB59FxtTS5p4VOaL7bq05v/CrugDYtlp71ef3xp9TWJaMvVXDuZiRBCgy0prULQin/jWfu5ze5vFJSYSGhWBRyFnNh7X1RBJ06hZuncnfx85wC/r/yZVrcbe2poLvy7Axd6BOw/uU35Qb+ISH2dzXQ+9S1kPL76YNZXUDEMc4pKSAOg7byZpj9LKHyYkALo7yz1mTsHGwpwDF3XF0JMf3S17mBDP6kP7cSlgz/lbN9lz7ox+nxeCg/TfR8XFMX/7VuZv32pwXmkaNeEPo+k243+ELlkjF8dvlYNkziTLSAvcftSubp4fvV69esydOxfQDY+YM2cOTZs25cSJExQtWvQZWz9dx44d+f777wG4d+8eEydOpFGjRvz3339YWz/fjMIODg6cOXMG0A2feLJuSvPmzVm/fj3z5s3j66+/1i/XarMKRGatVKlS+kkH0rdLDyYC1KpVi3///fe5+i/EyxB263amTLInxcfEEnbrNq6eL/Y8zyg3z7Nn7Sc3w6E0Gg3JycksXbqU4sV1EyEtXLiQSpUqERgYiK+vLwcPHqRp06b6bVJSUtBqtQaZL/PmzaNjx47PPF737t1ZtGgRRYoUIT4+nmbNmjFr1iyDNgEBAfTq1ctgWc2aNZkxY4bBsozDxy0tLbGxsSE8PFy/j+rVqxv8LGrWrElcXBx37tyRumivo/t3M2eSPSkxTteuUOF87cqkSZOoX78+Q4YMMVgeEBDARx8Z1luuWbMm06dPR61Wo1LpbspVrlw50z4tLCz0QTIAJycnPDw8DN4jnZycDP6GjYyMDLLJHRwc8PX1JSAgQL/MyMiI9957T/+4RIkS2NnZERAQkGWg7N69e/zwww/s27eP8PBw1Go1CQkJBAfrEhHatGnD9OnT8fLyokmTJjRr1owWLVpgZCQhoJyQn5IQIltPFvEH8CtQhICo4Kdul15rrFCKHRqtlm1tJqFQKPgzQ7H+9VcPZ5k7ktFfAbv51Lc2jTwq069CK6b/9zdXou4QEveAJRd3YGdqxfQGX+X6vN50D+PjOBd0kyrFfTE1NgEgPimRtpPGcy30LlHxcVkOU/xt6yZSNY/rJUTGxvLhuO9Z2H8wyampBkEygCt377Dy4F59oOtJaersi6x/NmkCI9t9ztK9OzFRGRGbmEBYdBSmxsYs3r2Dhwnxz3HmOuEPHxIUHoaXs+tz70O8bnKa8p8/QwMsLS3x9vbWP16wYAG2trbMnz//hYf32Nra6vft7e3NwoULcXFxYdWqVXzxxRfP3N7HxweAwMBAKlSoAOiGlKTvM6sL3k6dOtGyZUu6d++OVqvlm2909RzTPzxfvnxZv6/sbN26VT8kJCQkhLp16+qDcwDm5ubP7LsQr1JCbM7eZ3LaLqd8fHxQKBRcvnz5ufcRERHB/fv38fT0zPE2Li4uGBkZ6Z/ngH52yuDgYHx9falcubLB83jmzJmEhIQwadIk/bInh09mp2PHjgwbNowxY8bQqVOnF/rwbWxsWKZDoVDk+4QLIh8lJeRtuxdQu3ZtGjduzIgRI3I9cQWQ5fDprP5eX8XfcJcuXYiIiGDGjBkULVoUU1NTqlevrr955u7uTmBgILt27WLnzp307duXyZMns3///kz9FZnJ7XghRLbuxWeeKSa7IJkCsDI2xwgl3vG6AMZnt+qz+9Ap9tw6DUDHkg2wN9NlUMTlsL5YeEI0vbb/Qt9d07kSZZhxsvH6kZyeylsjNS2NKkO+ovaIr/ngh6HM27aZe1FRNB3zHVv/O8GVu3eyreWVMUiW7vSNa1Qb2p8/dm4DQKlQ0KpaDYo4FmLD8SPcfnA/0zY5oUHLnK0bMVKpuBoaQli07m8pJTWVmIQXuzAqYGmFu2OhF9qHeN245HG7F6NQKFAqlSQm5n0dxPS71Dndd4UKFShRogRTpkzJ1UV3ly5dWLx4McOGDWPKlCkAlC9fnpIlSzJ16tQs9xUdHa3/vmjRonh7e+Pt7a3Pqkt/7O3tjZubW477IsSrYGGd+QPui7TLKXt7exo3bszs2bOJj88chMv4PMvOjBkzUCqVtGrVKsfHrVmzJmlpaVy/fl2/LH3odvpz2Nzc3OB5bG9vj7W1tcGynGa62tvb07JlS/bv30/37t2zbOPn58fhw4cNlh0+fJiSJUvm+Lz8/Pz0NZ0y7sPa2prChfM3G0k8JzOLZ7fJTbsX9PPPP7Np0yaDmVqz+9ssXry4/n06r/j5+ZGWlsbx48f1yyIiIggMDDR4LqSlpeHv769/HBgYSHR0tD7g/aTDhw8zYMAAmjVrpp+U4MGDBwZtzM3NadGiBTNnzmTfvn0cPXqU8+d1k6SZmJgYTDggDElGmRAik0sPglgRsIe0LAIr2dHyOPhVL6wC2wInodKqWOi5lSknV/OBR0Wik+KITn5GKvYjFkam+Nq7Y2ZkwqEMs15mVNUl6zeOt9WO0/789u8mroToAoaHAy5yOOAiMzauJeEFivWnpKUxf6dumKNGq2XD8aM5GDqiBB5/0F7w1WDWHj3I1v9OALohIxGxMUTExhhspc3w7/NaM3wUxpI2/papBRRGV7g/q78PxaP1tbJY9+KSk5MJCwsDdEMvZ82aRVxcHC1atNC3CQ4OJjIykuDgYNRqtT4rw9vb22C4xZMSEhL0+7537x7jx4/HzMyMRo0a5ahvCoWCRYsW0bBhQ2rWrMmIESPw8/MjNTWVAwcOcP/+/Wwv6jt16oRSqaRLly5otVqGDh3KokWLaNCgAbVq1eL777+nRIkSxMXFsWnTJnbs2MH+/ftz1C8hXnfORd2xtLF+6vBLSxtrnIu65/mxZ8+eTc2aNalSpQrjxo2jbNmypKWlsXPnTubOnWsw3Co2NpawsDBSU1O5efMmy5YtY8GCBfz0008Gma7Xrl0jLi6OsLAwEhMT9a9BJUuWxMTEhAYNGlCxYkW6d+/O9OnT0Wg09OvXj4YNGxpkmeWlxYsXM2fOnGwnPhk6dCht27alQoUKNGjQgE2bNrF27Vp27Xp67biM+vbty/Tp0+nfvz9fffUVgYGBjB49mm+++UZKMLyuCrqCudXTh1+aW+navQRlypShY8eOzJw5U79s8ODBvPfee4wfP5527dpx9OhRZs2axZw5c/L8+D4+Pnz00Uf07NmTefPmYW1tzfDhw3FzczMY/mlsbEz//v2ZOXMmRkZGfPXVV1SrVi3LYZfp+/3zzz+pXLkyMTExDB061CDbe/HixajVaqpWrYqFhQXLli3D3NxcHzj38PDgwIEDfPbZZ5iamuLo6Jjn5/4mk08aQohMmv09glsx9wxmn1Q8+vfJWSgVGtAq9A0AmF9sC8ccArhjEU68URIPk+PZcv0YW64fQ/MoAKPg6eGSxLQUTodfo+vWSVgamWVaX9+9AvMaf/O8p/jGmfTPSoYvWZDluoA7uiw/M2MTlEolCclJL3SsrIJkxioVGo0WhVKBWq1Bi2E2yjcL55CUzRDNpzE3MSUxJedBPjNjEz4oVzHXxxGvOxUwA93slk++OqS/uEwnPwr5A2zbtg0XF122mrW1NSVKlGDNmjXUrVtX32bUqFEsWbJE/zh96OLevXsN2j1p/vz5zJ8/H4ACBQpQtmxZtm7dalCc/1mqVavGf//9x8SJE+nXrx9hYWFYWlpSrlw5pk2blm02B+iGRymVSjp16oRGo+Hbb7/F39+fCRMm0LNnTx48eICLiws1atRg+vTpOe6TEK87pVJJjWYN2LlyXbZtajRrkC/BFi8vL06dOsWECRMYPHgwoaGhFCxYkEqVKunrIaYbNWoUo0aNwsTEBGdnZ6pVq8bu3bsNit0DfPHFFwaB7PTXoJs3b+Lh4YFSqWTTpk3079+f2rVrY2lpSdOmTZk6dWqen186c3Pzpw7DbtWqFTNmzGDKlCkMHDgQT09PFi1a9NTXzCe5ubmxdetWhg4dSrly5bC3t6dHjx788MMPeXAGIl8olFC+lm52y+yUr5WvhfyfNG7cOFatWqV/XLFiRVavXs2oUaMYP348Li4ujBs37rmGZ+bEokWLGDhwIM2bNyclJYXatWuzdetWgyGQFhYWfPvtt3To0IGQkBBq1aqVaRKCjBYuXEivXr2oWLEi7u7uTJw40aAWm52dHT///DPffPMNarWaMmXKsGnTJn1ge9y4cfTu3ZtixYqRnJycZ/UV3xYK7Sv4icTExGBra8vDhw+xsbF52YcXQjxDkbmfcTs2HBVKKkT6cM0qhGgTw7tC7tYFaXo7kfikeJY7Z/0yMrRKOwIigtl8/ajB8iLWhRhfqzt9dkwnIS3roI5utsvshxkZK1XsbjeVWu5ls23zpkpJTWXAvFmsP3GEpJQUXOwduB4aQmoO06PdHQty/+FDklJTnt34GRSAg40tD2IePrWdmZExSWm5C5QpADeHgnxUtQazt254Zvtizi4s+fpbavqVztVxRN7J//fvtehmv8w4zNodXZDs43w4nhDibXfzUiBHtu4yyCyztLGmRrMGeJbMecBaCJFLd67pZrfMmFlmbqULkhX2zn47IV4DEigTQmRy4f5NVgTswW9OET6/3pDb5uGUa9yTONNEg5kqq2OHb9hDFmcRKLM0MiNiwHpGHlrE5BOrDNad67qAMoW8iEmOJzDyNi3Wfm9QD83JogB/fjiCX/zXsO3myWz72dK7Bhs+frFC26+DNLWaAb/P4ujlS5TzLEbQvVD2X8x6uGlOlXBz53LIbf1jV3sHQiMjXnDQ4/OpXqIkxy4H6LMR7a2sSUhO0megDW3dBl83d/rMnYlGq0H9qHZSkYKFeBDzkMSUFAY2b820nn1fQe9FRi/n/VuNbnbLUHQ1yWqRX5lkQoh3g0ajIezWbRJi47GwtsS5qLsM2xPiZdBqdLNbJiXoapIVdH2pmWRCPC8JlAkhsnWn8X3uaaLY5nwCy4/MsC5uQWDkHSafWKlv833J5lw5cIwTlg+49UT2vbOFPf5d5jJ47zw2XTtMQloyblaO3Om7mlR1Gj8c/IP7idGUdvDkh0MLSUzTZUD1Ltuc+0kPWXvlIJbGZtQuXJZ/b57Q79dEaUSKJo3ZDQfSt4Lh1M5viqshd2jx4w+kpKXRrFIVZm/dmOfHsLeyJjIu+9osL8sPbTvy+/YthD+aZKBxhcqkqtXsOaeb5GHnuEk0KF+J6Lg4VEolp25c5XzQTbrUb4S1xcsp9CpyRt6/hRBCCCHE204CZUKIbM2Y8Q/fxy8k3igJU5UxyepUnCwKcC/hcfbX2Jpdub7+LksL7kClUaFWqA3qlSkVCjRaLZ1KNqSpVxWquvhxJ+4+AQ9u8eXO6Vke18miAGlaNRGJukLwZ7vOp/KSL0nV6oYedi/TlFE1OlHU1jnfzj2/Fe3RgeD74U9vpNSCRvH0Nm8AlVJJxWI+BN0Lw71gIXaM/Rk7Syv+2r+HUkWLUrFY/hQZFnlP3r+FEEIIIcTbTor5CyGyNTTlN1KNdMGpZLVumFx4QrR+vYnSiOaFq9PJYSIAaqU6U4X+9OL9yy7tYmHTobz3Zx/Ohl/HzlQ3S1yd8HL4Fwgk3vhxrbL0QFw1Fz8+Ll6LsoWKUa9oeXYE/Qfohoa+iUGy66F3afHjD9wICyU5J4XvHbQQCZgAiWAQgXyDqDUaTl4N5Pyv8yld1FO/vFP9hq+wV0IIIYQQQgiRmQwQFkJkq4CZdaZlzYtVY2HjwbhZOVI7sixlO3gxxf9LlOlBnGxiOVq0zPT/h3PhNwCITtYV9jxZ4DLHd8/JcgrMNr51GFr1MwBWthhJuYLFKGJTiLHvd33hc3sVJq75i4DbwTkLkgE8UIAz8AYl7tQpXZbghX/x9/BRfPvJZ3zRsCkA5T2LUcz55UwDLoQQQgghhBDPS4ZeCiGy1f3f/7Ho/DaDZeZGJqSpNaRq01Bqlaw5OoqPQ2rzb/fjtIj73mCmSitjM9r41mVnkD+RSbEkpCXjaG6LiVLF3fhIAJRaBSl/76BSwy85a3edAqZWRD0KopmpTBj7flcGVPqYwnPaEpEUg0qh5FqvZXi8YRlly/ftZviS+dyJeKBfpgSym9dTQZaxQz1nuwKERUc9pcXLYWlqRq1SZahdqixlPTz58L1qmdrci4rCwcYGI5UUZH/Tyfu3EEIIIYR420lGmRAiW2NrduXj4rVo51tPP1TSSGlEqlY386VGoWFV4f2kFEqjeoNSVHPyA6C8kTdpwTuJ3bCVP5KHcaHHH/qhmw8SHxIbnYSp2hiAyq6+fDJgNGftrgPQ2LOK/vhJ6hSG7/+diUeXE5Gkq1em1moIiX0cbHoTHL50gc9/+ckgSAbZB8kAihZ00n9vlMXMXJ/XbZDttv2afUQRx0K4OxSkRGF3OtSp/3hfKhW+boVxdyz41D7bWVrhZFeAdu/XxcvZBdAF79rXqoethaW+3U9devDvmJ8Y0aZ9lkEyAKcCBSRIJoQQQgghhHgjSI0yIUS23G0K8U+rsQAEx9yjy5af2Xf7LAAqhRK1VsPqInup2bUUv2xbw63EezS7W5U1x0ajUj8KjKwA29ZW/NXiBxac3cL5yzc5vfN3bFMt+arCTCZ/1Ztm/4zQH/PUvSv8/dFo+u2cyb2EKLTAsbuX9OsVQDVXv5f1I8iVlNRU/ty7iyIFC9GwQiX98tPXr+V6X0H37+m/T9NkDqkduHiOVtVqsv7YYQC8nJwJf/iQBuUrMKNnX2Z92d+gff0yFbh4O4hhH7ejwqAvCYvSZfQNafUpyWlpmBoZ43/9CvvOn6VK8RIc+mkaxsa6YGZqWhrrjh3C28WNisV8AEhOTSEmIYGCtna5PjchhBBCCCGEeF1JoEwIkSNFbJwo6eihD5QVNLfD1MiYghZ2FLSw5VaiLrBz0eYWFmozgh3usd/yLE3rV8UsxQSfAm782+Zndq06hfNmewC+ud8GewsbHM1t9ceJSorlE986lHL0pMbyr3iYHI9/2BX9ei0was1iroaGMK1zH9zsn54ZlV+SUlKYtuFvHKxt+aJRU5RKJcOXLmDahn8AOPDTNMp6eNJ52iQ2nzyWJ8dUKBQYq1SkpKXh6uDI3D4DOXvzOiEREUzu1puPa9TKdtsejZrqv6/uW5J1xw5RzNmV8Z93x8zEBACtVsvtB+G42jsaZIAZGxnR9v26BvszNTahoK1JnpyXEEIIIYQQQrwupEaZECLH4lIS8fq9I/cfzXy5q+1kOm35mdD4CN6z9+Vy+G1ijRLw1DhzR3WfVK2asgW9SFanEhh5m3Yl6rGyyUj4HjTXNCiHK6EqjDm0hAlHl2GiMuKPpsNo51cPgE/Wj2btlYOGnYgGLuiGIlq5mhE0bTkOGQJtL0uxnp9z414YAF3rNWLR18PoMm0SS/fuBKBiMR8uBd8iKTUlx/tUKpVoHmWPKRUK/YyhLapUp8V71ahdqiyJKcmcun6Vtu/XxcrcHK1WS5pajbFRzu97pKal4X/tCn6Fi2BnZZXj7YSQ928hhHj9jBkzhvXr13PmzJk833fdunUpX74806dPz7aNh4cHgwYNYtCgQXl+fCHy0uLFixk0aBDR0dGvuisvVVBQEJ6enpw+fZry5cuzb98+6tWrR1RUFHZ2dq+6e68lqVEmhMgxKxNzJtXpib2ZDa18aqJUKAmNjwDgUswtYo0SALipDCNVqwYgOCacwMjbAOy/fRZMgMmgXKcLkgFM8/+bNK2ahLRk6hYpB0CaRp0pSKZAYfCqFadOZMT++QRGBOfjWWf2r/9xfZAMYOm+nTScP4TChQvyZZPmdPugMaeuX81RkMzG3AI7SyuKuxXm4E/TKGRXAACNVsuab0fxx4AhrPl2JD0bf4hvYXfKe3nTvWFTrMzNgUdZZrkIkoEuQ6x6iZISJBMC6Nq1KwqFQv/l4OBAkyZNOHfunEG7CRMmUKNGDSwsLHJ8UVm3bl2DfTs5OdGmTRtu3br1zO2e/MB57do1unfvTpEiRTA1NcXNzY0PPviA5cuXk5aWpm+nUChYv369/nFqairt27fHzc2NCxcu6PfVrVs3ChcujKmpKZ6enrRv3x5/f/8cnZcQ4tmefG1J/2rSpMkL7ffJ5/jbZt++fSgUincukCHyRsbnnYmJCd7e3owbN87gfVLkjIeHR6YA+enTp2nXrh0uLi6YmppStGhRmjdvzqZNm0jPvwoKCkKhUBgE7mNjY6lXrx4lS5bkzp07+n21adMGJycnzMzM8PHxoWfPnly5coXXgQTKhBC50q1MUyIGrGdd6/HUci9LTbfSAMSnJenbqBSPMr6MzfiuWgf6VWiFm5UjKepUPts4njSNWt928vGVFDDTBWyquZbUD8M0Uqr4qmIrTFXGtPZ5n22fTsLaxBxsgJIa8NSAl5alF3ZSYmFXhu2dR3RSXL6f/8P4OD6aONpgmUarYdem00z88y9MjY3Ze/6Mfp21mflT9+fl4krUivUEzl1MDb9S/NZnIFWKl2Bshy58WrM23Ro0wdRYhjiKd4daC0eTYX2i7n/1S8h7b9KkCaGhoYSGhrJ7926MjIxo3ry5QZuUlBTatGlDnz59crXvnj17Ehoayt27d9mwYQO3b9/m888/z9U+Tpw4QcWKFQkICGD27NlcuHCBffv28cUXXzB37lwuXryY5XYJCQm0bNmSkydPcujQIUqXLo2/vz+VKlXiypUrzJs3j0uXLrFu3TpKlCjB4MGDc9UvId4UGrWaS/v2c2TFKi7t249GrX72Rnkg42tL+teKFSuybJuamvpS+pQuJSXnGe9CPDeNFu7EQGCE7n9N/r+ppz/vrl69yuDBgxkzZgyTJ0/O9+O+7TZs2EC1atWIi4tjyZIlBAQEsG3bNlq3bs0PP/zAw4cPs9zu/v371KtXj/j4eA4ePEjhwoXZvHkz1apVIzk5meXLlxMQEMCyZcuwtbVl5MiRWe5n3759eHh45OMZGpJAmRDiuRkpVbhaOWRarlXrhg/GpSYxbP/vLL6wDUtjMyKTYll1eS+frh8DwPG7AQzb/zu3Yu5R1cWPA+2no1I+ro31a4MBJA3eztrW42joWYnvqnWknW9dqpbyw7yoKaggWaO7sJx8YhVuc9pwNlw3e+acU+v5ePkoev3+C7vPnmLmpnWM27yUlQF7H9/xeBjG8P2/s+rcHrRaLUcvX8Kp06e4dG5D83Hfc/DSec6FXyc0OoK4xETdOatUmJs8DlwVtLHF1NMY3TQDsOLAXoLCdfXalAoFSqVuubGREaonZq80MzFhz3jDN+7W1d/n+JRZjPqsU+5/IUK84f5NhOrh0DYS+kfr/q8erluen0xNTXF2dsbZ2Zny5cszfPhwbt++zf379/Vtxo4dy9dff02ZMmVytW8LCwucnZ1xcXGhWrVqfPXVV5w6dSrH22u1Wrp27Urx4sU5fPgwLVq0wMfHBx8fH9q3b8+hQ4coW7Zspu2io6Np2LAhd+/e5dChQ3h6eur35ePjw8GDB/nwww8pVqwY5cuXZ/To0WzYsCFX5ybEm+Dk2vUM9CjOhHqNmd2hCxPqNWagR3FOrl2f78fO+NqS/lWggC5zXKFQMHfuXFq2bImlpSU//vgj3t7eTJkyxWAfZ86cQaFQcO3aNf2HxNatW6NQKDJ9aPzzzz/x8PDA1taWzz77jNjYWP26unXr8tVXXzFo0CAcHR1p3LgxAPv376dKlSqYmpri4uLC8OHDM2XfpKWl8dVXX2Fra4ujoyMjR47kadV7fvnlF8qUKYOlpSXu7u707duXuLjHNzNv3bpFixYtKFCgAJaWlpQqVYqtW7cSFBREvXq68hsFChRAoVDQtWvXXP3MxWvkWiQsOgv/XIZt13X/LzqrW56P0p93RYsWpU+fPjRo0ICNGzdm2fb69et89NFHODk5YWVlxXvvvceuXbsM2syZMwcfHx/MzMxwcnLi008/1a+rW7cu/fv3Z9CgQRQoUAAnJyfmz59PfHw83bp1w9raGm9vb/7991/9Nmq1mh49euDp6Ym5uTm+vr7MmDHjmed18eJFmjdvjo2NDdbW1tSqVYvr16/r1y9YsAA/Pz/MzMwoUaIEc+bMye2PLlvx8fH06NGDDz/8kC1bttCoUSO8vLzw8/OjR48enD17FlvbzKVwbt++Ta1atbC1tWXPnj04ODiQkJBAt27daNasGRs3bqRBgwZ4enpStWpVpkyZwrx58/Ks3y9CivkLIV7Il+VbsOfWaSKSYvTLNEow0kCaEhqFVcbf7graOC2Y6tZvuHaYoOgwClrYYqoyJlmdik8BN/67d4Xm/3yHtYkFu9tNwcvOVb/PsYeXMu7I0qw7oQUUkJCWzL7gM6wK2MtPx/8CfwUkKfhj6zbU5mrw08J52F7uJIuaDaP9ph85tjcA7iuYV24LXoVcCX8YDcAW/+PsSztDvFUiigQFVoEW7P/xFyoU8+HAT9PY6n+c2qXKUrNkaQIjgukxcyqHT1/Ubw+64ZMPE3TDUVPT0vBzL0LA7cfDRGv6laKAtXWe/B6EeNP9mwi9o3VP54zCNLrl84CmT0/QzBNxcXEsW7YMb29vHBwy3wh4EZGRkaxevZqqVavmeJszZ84QEBDAihUrUCqzvr+pUCgMHoeFhVGnTh2srKzYv3+/fqjomTNnuHjxIn/99VeW+5I6JeJtc3LteqZ/2h6eCOpEhtxl+qftGfT3Ct77uNWr6Ry62mI///wz06dPx8jICFNTUxYtWsSQIUP0bRYtWkTt2rXx9vbm5MmTFCpUiEWLFtGkSRNUGSbeuX79OuvXr2fz5s1ERUXRtm1bfv75ZyZMmKBvs2TJEvr06cPhw7oZs0NCQmjWrBldu3Zl6dKlXL58mZ49e2JmZsaYMWMMtuvRowcnTpzA39+fXr16UaRIEXr27JnleSmVSmbOnImnpyc3btygb9++DBs2TP/BvV+/fqSkpHDgwAEsLS25dOkSVlZWuLu7888///DJJ58QGBiIjY0N5uYv4YVf5L1rkbAli1nf41J0yz/0Bm/7l9IVc3NzIiIislwXFxdHs2bNmDBhAqampixdupQWLVoQGBhIkSJF8Pf3Z8CAAfz555/UqFGDyMhIDh40LA2zZMkShg0bxokTJ1i1ahV9+vRh3bp1tG7dmu+++45p06bRqVMngoODsbCwQKPRULhwYdasWYODgwNHjhyhV69euLi40LZt2yz7GRISQu3atalbty579uzBxsaGw4cP64Pay5cvZ9SoUcyaNYsKFSpw+vRpevbsiaWlJV26dHnhn+GOHTuIiIhg2LBh2bZ58lokMDCQoUOHUrlyZVasWIGpqe6D4Pbt23nw4EG2+3pdrkUko0wI8ULqF63IgwHrWdHiB8yNTFBq4P1oBYdPqzh+oDvbD/6Pczvnc9U0RL+NUqGkxMIu3IgO5XinOSz78DvmNxnC0gs7iEiMIehhGOuuHII04AIQBydDAwy2N/DodbmAsTVtfOtwMSLIYLUWLThpwQxQwf7gM8CjIaIPdG32nj1L4wqVMFY9vn+QbKEblqC10BKbmsD207r6PeU8izGiTQdqltQNO/V1KMLyft9hbmL61J9VxiBZ00pVWDro26e2F+JdodbC6JjMQTJ4vGxMTP4Nw9y8eTNWVlZYWVlhbW3Nxo0bWbVqVbaBqdyYM2cOVlZWWFpa4uDgQGBgIH/88UeOt0+v1eHr66tfFh4eru+vlZVVprvGAwcOJCUlhZ07dxpccF69ehWAEiVKvMAZCfFm0KjVLB04OFOQDNAvWzpoSL4Ow8z42pL+NXHiRP36Dh060K1bN7y8vChSpAhdu3YlMDCQEydOALrhmH/99Rfdu3cHoGBB3UzfdnZ2ODs76x8DaDQaFi9eTOnSpalVqxadOnVi9+7dBv3x8fHhf//7H76+vvj6+jJnzhzc3d2ZNWsWJUqUoFWrVowdO5apU6fqJxcCcHd3Z9q0afj6+tKxY0f69+/PtGnTsj3vQYMGUa9ePTw8PKhfvz4//vgjq1ev1q8PDg6mZs2alClTBi8vL5o3b07t2rVRqVTY2+uCJ4UKFcLZ2TnLLBXxmtNoYf8z6gfvD873YZharZZdu3axfft26tevn2WbcuXK0bt3b0qXLo2Pjw/jx4+nWLFi+gy04OBgLC0tad68OUWLFqVChQoMGDAg0z5++OEHfHx8GDFiBGZmZjg6OtKzZ098fHwYNWoUERER+tqnxsbGjB07lsqVK+Pp6UnHjh3p1q2bwXPkSbNnz8bW1paVK1dSuXJlihcvTrdu3fTXBqNHj2bq1Kl8/PHHeHp68vHHH/P111/nWXZWVtciJ0+eNHht27x5s8E2nTt3xtvbmzVr1uiDZPDmXItIoEwIkSc+86tPa59aaJRww8kOX9UqqtzT1eFJVKVQLqqYvq1GqyFZncqawH2UK1SMT4s34MRlE2rZtcHCyBwHcxuaelWBUUA3CG0dya7rp/Xb25tas6Pt/7AyNtMt0Oq+Sjt54mrtyG8NB+Fl64JpGWNKly/KP8PHUL1IKdDqYmq/1O8LwKqWI6lZpTQmxkZ80agpbd6vy2+jBkAFDRTX0L5kfYpYFcI6wgLfgkVo935dktJSOBEaQGJqMgBhUZGM/msJ3y1dQPIz6n3YmFkws2c/fus7iM0jf8TVwTHPfv5CvMlOpECoJvv1WuCuRtcuP9SrV48zZ85w5swZTpw4QePGjWnatOkzi+7nRMeOHTlz5gxnz57l0KFDeHt706hRI4MhUbnl4OCg76+dnV2mWkPNmzfX1yDLKKcTnTdt2lR/4VuqVKnn7qcQr9Llg4eIvBOSfQOtlsjbd7h88FC+9SHja0v615dffqlfX7lyZYP2rq6ufPjhh/pg+qZNm0hOTqZNmzbPPJaHhwfWGbLUXVxcCA8PN2hTqVIlg8cBAQFUr17dIBOkZs2axMXF6QtuA1SrVs2gTfXq1bl69SrqbIKMu3bt4oMPPsDNzQ1ra2s6depEREQECY+y7AcMGMCPP/5IzZo1GT16dKbJU8Qb7m6sLnPsaeJSdO3yQXqA2szMjKZNm9KuXTuDDEmDbsTFMWTIEPz8/LCzs8PKyoqAgACCg3WBvoYNG1K0aFG8vLzo1KkTy5cv1/8dp8tY/kClUuHg4GBQpsHJyQnA4Pk4e/ZsKlWqRMGCBbGysuL333/XHzMrZ86coVatWhgbG2daFx8fz/Xr1+nRo4dB4OrHH380GJqZ18qWLat/XYuPj880ZLtly5YcPHiQtWvXGizP6bUIYHA+TZs2JTg42GBZxtfTvCZDL4UQeWbJh8P5snwLnBYV4C/1QY5XvkyRhEL84fkvIRYP9EMkARRaBS0314QdcOxjOP0AwI0jrddTsogCY5URx25cYlHFbbQOeR+XBAfu2jzAwcyGPz8cQUOPypzttoCN144weM9cNGjxtHUGwMXakeu9lxv0rVW1mtyLj8TcyBQbU0sA3KwLcuh7w5oAdxMjwBKwhGIOrixtOcJgfc3l/TkScpH3nH050Xkun/w0Bv/g/0hJePrQAHNjY87N+p2ihZyf98crxFvr3lOCZM/TLrcsLS3x9vbWP16wYAG2trbMnz+fH3/88YX2bWtrq9+3t7c3CxcuxMXFhVWrVvHFF188c3sfHx9AN4ShQoUKgO5CPH2fRlnMetupUydatmxJ9+7d0Wq1fPPNNwAUL14cgMuXL+v3lZUFCxaQ+KguY1YX5UK8CaJDw57dKBftnseTry1ZrX/SF198QadOnZg2bRqLFi2iXbt2WFhYPPNYTz5XFQqFQVZYdsfLa0FBQTRv3pw+ffowYcIE7O3tOXToED169CAlJQULCwu++OILGjduzJYtW9ixYwc//fQTU6dOpX///vneP/ESxOdwYoqctsulevXqMXfuXExMTHB1dc3yfTLdkCFD2LlzJ1OmTMHb2xtzc3M+/fRT/Q0oa2trTp06xb59+9ixYwejRo1izJgxnDx5Up+xndVzL+Oy9CBz+vNx5cqVDBkyhKlTp1K9enWsra2ZPHkyx48fz7afTxuCnF7/b/78+ZlKO2Qcnv0iMl6LVKtWDdDVgnva69v3339P2bJl6dChA1qtVj+sNOO1SPXq1Z963IwzZx4/fpxvv/2Wffv26ZfZ2Ng8z+nkiATKhBB5xkipopZ7WSpa9uJ0pcd1CczUmT9ofRhajQ+P6V5oTZyToLguO8zKzBjjR6/praqM5F5aFIu8/iVVoWZo5Xb8r25v/T687FwZVPlTqruW4lJEEJ+VyDqtOp2T5bNrIfSv1JobD0PRarUMrPSJwTq1Rs3xu7ohoP5hVyjWqxM3wkJB8fQhlwA/d+0pQTIhsuGUw/z2nLZ7UQqFAqVSqQ8W5aX0i9ac7rtChQqUKFGCKVOm0LZt2xwPB+3SpQtKpZJu3bqh0WgYMmQI5cuXp2TJkkydOpV27dpl2ld0dDR2dna4ubnl7qSEeA3ZueTsPTen7V6WZs2aYWlpydy5c9m2bRsHDhwwWG9sbJxtJldu+fn58c8//6DVavUf5g8fPoy1tTWFCxfWt3vyA/yxY8fw8fHJ8kP4f//9h0ajYerUqfrXmKyGlLm7u/Pll1/y5ZdfMmLECObPn0///v0xeTRhUl6do3gFLHN4gyWn7XJ7+GcEqDM6fPgwXbt2pXXr1oAu6BQUFGTQxsjIiAYNGtCgQQNGjx6NnZ0de/bs4eOPP36u/h0+fJgaNWrQt29f/bJnZX6VLVuWJUuWkJqamikw5+TkhKurKzdu3KBjx47P1adnadSoEfb29kyaNIl169bleLuRI0eiVCrp2LEjWq2Wdu3a0ahRIxwdHfnf//6X5b7Sr0UAg9/jnTt3MDIyyvHv9kVJoEwIkeduGYdDhusbLWCTYkGsUQJaBRQytmPg+x+jPaJGoVVRdesWrBvWx6xQAYq5QEJqEjHJCdhaW3IvKgprc0uu9lyKvXnWdw2quvpR1dUvT/pua2rFH00zF5fcf+Es4dHRNFRUZueJU9g7WuuCZADaZ39w/e/a1TzpnxBvoyom4KLUFe7PKiFfgW59FZMsVuaB5ORkwsJ0WSVRUVHMmjWLuLg4WrRooW8THBxMZGQkwcHBqNVq/V1Ob29vrKysst13QkKCft/37t1j/PjxmJmZ0ahRoxz1TaFQsGjRIho2bEjNmjUZMWIEfn5+pKamcuDAAe7fv5/tHeNOnTqhVCrp0qULWq2WoUOHsmjRIho0aECtWrX4/vvvKVGiBHFxcWzatIkdO3awf//+HPVLiNddiVrvY1/YjciQu1nXKVMosC/sRola7+dbHzK+tqQzMjLC0TH70gsqlYquXbsyYsQIfHx8MmVceHh4sHv3bmrWrImpqal+Fs3n0bdvX6ZPn07//v356quvCAwMZPTo0XzzzTcGgfTg4GC++eYbevfuzalTp/j111+ZOnVqlvv09vYmNTWVX3/9lRYtWnD48GF+++03gzaDBg2iadOmFC9enKioKPbu3Yufn+46rmjRoigUCjZv3kyzZs0wNzd/6museA25WoOVydOHX1qZ6Nq9Yj4+Pqxdu5YWLVqgUCgYOXKkQSbm5s2buXHjBrVr16ZAgQJs3boVjUZjUKvreY65dOlStm/fjqenJ3/++ScnT57E09Mz222++uorfv31Vz777DNGjBiBra0tx44do0qVKvj6+jJ27FgGDBiAra0tTZo0ITk5GX9/f6KiovRZ5S/CysqKBQsW0K5dOz788EMGDBiAj48PcXFxbNu2Dcg+e+37779HpVLRsWNHNBoN7du3Z8GCBbRp04aWLVsyYMAAvL29efDgAatXryY4OJiVK1e+cJ9flATKhBB5bkWL75l7eiOl93myrMBOgizvkax6nF5d8L4dqQfSiC69HOXdyxxy9KeaqTcOrgUYtvc3Zvy3lhRNGoMrt8HdphANPSplGyR7GXafPUWDkYbBs/shD59olWFc6ROszc35qXOP/OmcEG8BlQLG2uhmt1RgGCxLf1aNsdG1yw/btm3DxcUF0A2zKFGiBGvWrKFu3br6NqNGjWLJkiX6x+lDF/fu3WvQ7knz589n/vz5ABQoUICyZcuydevWXF1kV6tWjf/++4+JEyfSr18/wsLCsLS0pFy5ckybNk1f6DsrHTt2RKlU0qlTJzQaDd9++y3+/v5MmDCBnj178uDBA1xcXKhRowbTp0/PcZ+EeN0pVSo6z5iqm/VSoTAMlj3Knuo8fQrKPBqalJWMry3pfH19uXz58lO369GjBxMnTqRbt26Z1k2dOpVvvvmG+fPn4+bmlin7JTfc3NzYunUrQ4cOpVy5ctjb29OjRw9++OEHg3adO3cmMTGRKlWqoFKpGDhwIL169cpyn+XKleOXX35h0qRJjBgxgtq1a/PTTz/RuXNnfRu1Wk2/fv24c+cONjY2NGnSRD85gJubG2PHjmX48OF069aNzp07s3jx4uc+R/EKKBVQp0jWs16mq1NE1+4V++WXX+jevTs1atTA0dGRb7/9lpiYGP16Ozs71q5dy5gxY0hKSsLHx4cVK1a8UP3O3r17c/r0adq1a4dCoaB9+/b07duXf//9N9ttHBwc2LNnD0OHDqVOnTqoVCrKly9PzZo1Ad2QbQsLCyZPnszQoUOxtLSkTJkyDBo06Ln7+aTWrVtz5MgRJk2aROfOnYmMjMTW1pbKlSuzcuVKmjdvnu22w4cP11+LaLVaOnTowJEjR/jpp5/o0KEDMTExuLu76yf/eB0otLmpppZHYmJisLW15eHDh/k6rlQI8YqFwdfTZzPd/h/sU6wZHNiG/Y7nOOJ4kTjjRFzTHDA3SuQ6CXjbubGwyVDqrByk39zaxIKYQZtJ06i5GnWHYnaumKhefr2cP/fupPO0SbneTqlUMqtXP/o0+ygfeiXEy5ff79//Jupmv8xY2N9VqQuSNX16GUAhhMjSybXrWTpwsEFhf3v3wnSePoX3Pm716jr2FAcPHuSDDz7g9u3b+kLgQrxxrkXqZrfMmFlmZaILknk/uxyKEK+SBMqEEPluzqkN9N8xkxGXO3LN5jarCj8a2pOxuD8KClrYcT8hGu2jfJIi1oW41Wcl1f7sx/HQAN4vXIaDHWZkfZD88CtwGNK6qam8tQ9nb97I0WYKhYIVQ76nRZVqWJia5W8fhXiJXsb7t1qrm93ynkZXk6yKSf5lkgkh3g0atZrLBw8RHRqGnYszJWq9n6+ZZM8rOTmZ+/fv06VLF5ydnVm+fPmzNxLidabR6ma3jE/V1SRztX4tMsmEeBYZeimEyHcWxqZolFomlFxG7SilPkBWP7wCe5xOA2CmMiY8IQqAL8u3wNLIjJ7lPmTT1SMcD9UV0D905zyJqcmYGz+7eP4LuwMs1X2r+BX+N74XfefO5HrY3UcNnhwgptOoQiW++ehTGld8L//7KMRbSKWA6i/hKS6EeHcoVSpK1q3zqrvxTCtWrKBHjx6UL1+epUuXvuruCPHilAooLIkx4s0jgTIhRL7rXLoRCWnJnLl3jcidR/hv108kK1MpGVMUu9YtAUhU69KyjRUqOvp9wPvuZQHYcuPxTEvVXUu+nCAZgCPgBoTAp3bjWD/6MFWL+2FqbMy10LukpBlOaV3M2ZWG5SsytceXkkUmhBBCiFzr2rUrXbt2fdXdEEKId54EyoQQ+U6pUNK3wkdotVpG3ovkbMgp6oTV5tuy8zO1VWs11FoxiO+rd+THWj3oWfZDzt+/QXxqErMaDHhpfb6bnMDwVmdx1pixeeMxAI5fCWD7/37i5LkrjF2xlFS1mkblKzG2QxeqlSj50vomhBBCCCGEECJ/SKBMCPHSKBQKfuwyAbrApQdBXNh+E0IM22geDWc8fOcioAucnb19g6KXCtEl+Gdavl+DPhXyvzj+91vO8eeZIN0DlS1oIgEtjYeN0LexNjdn+7jcF/kXQgghhBBCCPF6kkCZEOKVKOnowbrW4+i85SfOhl8nND4SgHJRxTDSqhgf343JB1by8+kVLN49nBah1bnvH43Pw074hwbysW9tPixWLd/6525noftGqwVl+kybhsVHU9LS0Gq1KBRSlFQIIYQQQggh3gYy66UQ4pW7HRNOx80TUAYoWb7vO+6bPmRiieXctgin4b33CLAJwlxtyqzTA1jguYXB5X/DSKniVu8VuFo75kufNBotVcbO5L9LxyE5HBRGoE0zaKNSKklYswUTY+Ns9iLE20Xev4UQQgghxNtOMsqEEK+cu00hDnSYAfcAFXyUNBLPeBeO7p3N0LK/8bf7AQDKPSzGV9da6wNlRsr8m9pdqVQQdO0AJD/ULXgiSAbQvUETCZIJIYQQQgghxFtE+ao7IMSrEBQOIRGvuhciEydgDBQuXpCSMUUB9P8rtApKxBTBVGNMm+A6TLPuSyHLAvnaHRsLczBzBoUJoMWvznWqtT2LTaFYAPo2a5mvxxdCCCGEEEII8XJJoEy8FZKSYctJOHRRV1IqTa37//Z9mL8dlu2Fv/bCb1th52lYfxTWHAL/q7DxOOw+C9dCIT7p8T63/QczNsCuM6DWvLJTeyct//w7SvYtQnTxOLoFNWXLwYn8e+BnPgzT1SRbfXw0X/7ektR6acQdTcy3fvz65SBwbQbmLjgUiaZ4jVs4FYugdMNgMLJm3rbN+XZsIYR4E3h4eDB9+vRX3Y0sBQUFoVAoOHPmzKvuihBCiNfA4sWLsbOze9XdeOmefD/ct28fCoWC6OjoV9qv15kEysQbKyEZouLg8CX4bRtcvQv+12DGRpi1Wff/uqO64NeDGAiPgaRUuBj8eB+HLsGNMDgfBJtPwMIdcOk2zNkMl++AFrhwC37dBNM3wKKdcOIKRMbq9pmQ/KrO/u1maWJOu6r1sfvTCr6HZt2rwY+wpfwxg3bGcUbsm3yWsLjIfOnHh5UqM7fNe1Sp/BGJMWbcvezI4eUVuHm+NBT+mAL2RfLluEKIlyssLIz+/fvj5eWFqakp7u7utGjRgt27d+vbeHh4oFAoUCgUmJub4+HhQdu2bdmzZ0+2+42IiKBw4cJ5ejFat25dfT+y+qpbt26eHOdJ2X24OHnyJL169cqz40hwS7wtwsLCGDhwIN7e3piZmeHk5ETNmjWZO3cuCQkJmdp7enqya9cu/QfYAgUKkJSUZNDm5MmT+ue6ECKzrl276p8jJiYmeHt7M27cONLSMpdQEU+X1Y2w06dP065dO1xcXDA1NaVo0aI0b96cTZs2kV76Pqv38djYWOrVq0fJkiW5c+eOfl9t2rTByckJMzMzfHx86NmzJ1euXHlZp/hUEigTb6RzN+H3bbBkN5y8mn07TS6nqtBoYccpSFFnvf5hAhwJgKV7dFlq87fBqatw8gos3gUbjsGlWxB8X5fVJl6QEmgFtIbGFd7jw9+rQWNAAYmqFDRo+Nt5P8PHzed2THi+dOHLmj4c/vpDLDXO+K8vzYPgAoSe04Immf/uXc+XYwrxTlMD/wHbH/2fz6+lQUFBVKpUiT179jB58mTOnz/Ptm3bqFevHv369TNoO27cOEJDQwkMDGTp0qXY2dnRoEEDJkyYkOW+e/ToQdmyZZ/ZhzFjxtC1a9cc9Xft2rWEhoYSGhrKiRMnANi1a5d+2dq1a3O0n7xSsGBBLCwsXuoxhcgtjUZDUMgdzl+9QlDIHTSa/B0qcOPGDSpUqMCOHTuYOHEip0+f5ujRowwbNozNmzeza9cug/bnzp0jKiqKOnXq6JdZW1uzbt06g3YLFy6kSJH8uUmXmpqaL/sV7zatWkvkvnBCVwYTuS8crTr/5xFs0qQJoaGhXL16lcGDBzNmzBgmT56c78d9223YsIFq1aoRFxfHkiVLCAgIYNu2bbRu3ZoffviBhw8fZrnd/fv3qVevHvHx8Rw8eJDChQuzefNmqlWrRnJyMsuXLycgIIBly5Zha2vLyJEjX/KZZU0CZeKNdPo1iU9ogQOX4HAARMfDzXuw4wysPaLLatt//lX38C2jAH4ETsCRL89Ts94A4lWJ1LpZhvVXD+XbYY1UKvZOmIJW++glU2mKjdUFXDwO5tsxhXgn7QFaAl8CPzz6v+Wj5fmkb9++KBQKTpw4wSeffELx4sUpVaoU33zzDceOGWaxWltb4+zsTJEiRahduza///47I0eOZNSoUQQGBhq0nTt3LtHR0QwZMiRP+2tvb4+zszPOzs4ULFgQAAcHB/0ye3v7LLc7efIkDRs2xNHREVtbW+rUqcOpU6cM2kRHR9O7d2/93d3SpUuzefNm9u3bR7du3Xj48KH+Tv2YMWMAwzvOHTp0oF27dgb7TE1NxdHRkaVLlwKwbds23n//fezs7HBwcKB58+Zcv/74Td3T0xOAChUqZMqQW7BgAX5+fpiZmVGiRAnmzJljcKwTJ05QoUIFzMzMqFy5MqdPn87dD1e8lQJuXGfGsqUs2bietbt2sGTjemYsW0rAjfy7mOzbty9GRkb4+/vTtm1b/Pz88PLy4qOPPmLLli20aNHCoP2GDRto0qQJxhkmCOrSpQt//PGH/nFiYiIrV66kS5cuzzy+QqFg7ty5NG3aFHNzc7y8vPj777/169MzPlatWkWdOnUwMzNj+fLlaDQaxo0bR+HChTE1NaV8+fJs27bNYN9HjhyhfPny+ufZ+vXrJQtUZOneujscKLYF/wb7Of/5cfwb7OdAsS3cW3cnX49ramqKs7MzRYsWpU+fPjRo0ICNGzdm2fb69et89NFHODk5YWVlxXvvvZcpkD1nzhx8fHz0maGffvqpfl3dunXp378/gwYNokCBAjg5OTF//nzi4+Pp1q0b1tbWeHt78++//+q3UavV9OjRA09PT8zNzfH19WXGjBnPPK+LFy/SvHlzbGxssLa2platWgbvn896j3wR8fHx9OjRgw8//JAtW7bQqFEjvLy88PPzo0ePHpw9exZbW9tM292+fZtatWpha2vLnj17cHBwICEhgW7dutGsWTM2btxIgwYN8PT0pGrVqkyZMoV58+blWb9fhATKxBvJxeFV9yBnTt+AwxchPFpXL239UfhjJxy7/Kp79ub7oF0l/kkaw1c3WvN7+S00KFqRr3fPpuLiXqw8n/efqksV9WT4J5/pHmiSiQ04z4NL3vo0YyHEC9oDfAs8mRwa/mh5PgTLIiMj2bZtG/369cPS0jLT+pzUMRk4cCBarZYNGzbol126dIlx48axdOlSlMrX41IrNjaWLl26cOjQIY4dO4aPjw/NmjUjNlY3OYlGo6Fp06YcPnyYZcuWcenSJX7++WdUKhU1atRg+vTp2NjY6DPXsgoAduzYkU2bNhEXF6dftn37dhISEmjdujWgu9j+5ptv8Pf3Z/fu3SiVSlq3bq3P8HkySy49Q2758uWMGjWKCRMmEBAQwMSJExk5ciRLliwBIC4ujubNm1OyZEn+++8/xowZk+dBSvHmCbhxndXb/yUmPs5geUx8HKu3/5svwbKIiAh27NiR7esKkGno5MaNG/noo48MlnXq1ImDBw8SHKyrGfLPP//g4eFBxYoVc9SPkSNH8sknn3D27Fk6duzIZ599RkBAgEGb4cOHM3DgQAICAmjcuDEzZsxg6tSpTJkyhXPnztG4cWNatmzJ1au64RsxMTG0aNGCMmXKcOrUKcaPH8+3336bo/6Id8u9dXc42/YoyXcMawknhyRytu3RfA+WZWRubk5KSkqW6+Li4mjWrBm7d+/m9OnTNGnShBYtWuifd/7+/gwYMIBx48YRGBjItm3bqF27tsE+lixZgqOjIydOnKB///706dOHNm3aUKNGDU6dOkWjRo3o1KmTfsi1RqOhcOHCrFmzhkuXLjFq1Ci+++47Vq9ene05hISEULt2bUxNTdmzZw///fcf3bt31w8pfdZ75IvasWMHERERDBs2LNs2T76uBQYGUrNmTUqWLMnWrVuxsrICdNcFDx48yHZfr0sNOaNX3QEhnscH5cDCBK6HQlT84+U2FuBSAG6GQ8prkkF+8pruK6NjgeBqD0UKvZo+vRXMwXWmIzYplhxQTmPf7bPMOLmW9UfG03x2NYKr36PITKc8PWSRgum/MC1arYItR89xaPtCSpSsSsEiZfL0WEK8U9TA1Ge0+QWoA6jy7rDXrl1Dq9VSokSJ596Hvb09hQoVIigoCIDk5GTat2/P5MmTKVKkCDdu3Mij3r6Y+vXrGzz+/fffsbOzY//+/TRv3pxdu3Zx4sQJAgICKF68OABeXl769ra2tigUCpydnbM9RuPGjbG0tGTdunV06tQJgL/++ouWLVtibW0NwCeffGKwzR9//EHBggW5dOkSpUuXzpQll2706NFMnTqVjz/+GNBlnl26dIl58+bRpUsX/vrrLzQaDQsXLsTMzIxSpUpx584d+vTp87w/MvGG02g0bDv09MzvbYcP4uvhmacB7fTXFV9fX4Pljo6O+ppj/fr1Y9KkSYDuA/C5c+do2rSpQftChQrRtGlTFi9ezKhRo/jjjz/o3r17jvvRpk0bvvjiCwDGjx/Pzp07+fXXXw2yTAYNGqR/TgFMmTKFb7/9ls8+090YnDRpEnv37mX69OnMnj2bv/76C4VCwfz58zEzM6NkyZKEhITQs2fPXPyExNtOq9Zy+eszuqE3mVYCCrj89RkKtXRDocq/entarZbdu3ezfft2+vfvn2WbcuXKUa5cOf3j8ePHs27dOjZu3MhXX31FcHAwlpaWNG/eHGtra4oWLUqFChUy7eOHH34AYMSIEfz88884OjrqnxejRo1i7ty5nDt3jmrVqmFsbMzYsWP123t6enL06FFWr15N27Zts+zn7NmzsbW1ZeXKlfrM0/T3anj2e+SLSq8blvF17eTJk9SrV0//eOXKlTRv3lz/uHPnztSsWZM1a9agUj2+eEsPvL/ItdfL8Hrc5hQil1RKeL8UdGkAzSpDASsoURi6fgBW5q9PkOxpjgTArXC4n/VwbpFDVibmmBqZ4GXrQqk4D1qG1kCJErdjjiTUSuLW32F5dqzHF9K6N/UqzjbE3jzCqW2zSEmKy37DvBQVBUlJEBcHF85DNnfIck0D7AcuZrHuGpDV6SWgGx43EAjNsPwuutpS6V3TApeA6EePn6ynKrPKijNkziR70r1H7fJQXmWEarVa/Z3UESNG4Ofnx+eff55t+4MHD2JlZaX/mjhxIsuXLzdYtnz58jzpW7p79+7Rs2dPfHx8sLW1xcbGhri4OP1d8zNnzlC4cGGDC+/cMjIyom3btvq+x8fHs2HDBjp27Khvc/XqVdq3b4+Xlxc2NjZ4eHgA6PuRlfj4eK5fv06PHj0MfkY//vijfthJQEAAZcuWxczMTL9d9erVn/tcxJsvOPRupkyyJ8XExREcevel9OfEiROcOXOGUqVKkZz8eDaojRs36ocjP6l79+4sXryYGzducPToUYPn0rM8+fdfvXr1TBlllStX1n8fExPD3bt3qVmzpkGbmjVr6rcLDAzM9DyrUqVKjvsk3g1RB+9nyiQzoIXkO4lEHbyfL8ffvHkzVlZWmJmZ0bRpU9q1a6cvF/CkuLg4hgwZgp+fH3Z2dlhZWREQEKB/T2rYsCFFixbFy8uLTp06sXz58kyTcWSsRapSqXBwcKBMmcc30J2cdDfuw8MfX+jMnj2bSpUqUbBgQaysrPj999+f+j545swZatWqZTA8O11O3iPzQ9myZTlz5gxnzpwhPj4+04QJLVu25ODBg5lqp+b02qtUqVL6c3nyRsLLIBllb5HjW7dwau9uarT4iHK16zx7g7dEcTfdVzo3B/jvWuZ2SiXkc+3WXAmL1s3KqQA+fA+8XV91j95sPvaFmdtpEP+dvEKlyOKotCosklQ8WBTD+dibuCodqdjJ54VuD/Rs1AyNRkNyaiqd6jUgYNtU4iJDUKqMUCrzMM1FC8wHjgaD41/gooJP20JAAPw6HWxswcwM7oVBxUow9kfdH7dRFi/pD6NhfDScLwS1bsC3vvDkm2wSMAdYge7n03M77DsM0d0hykMX8Cr4aL0tuqBZX+Aqj4NeS4APTkCgEcwor9uRpRo6q+AfdEEQFWABxKMLsDUG+qMLfjieAauN8F1H8CoGl4EywONrcbgPPAD8nuunKl5nD/K4XQ75+PigUCi4fPn5x8NHRERw//59fW2tPXv2cP78eX09oPQLQkdHR77//nvGjh1L5cqVDer5zJw5k5CQEH2GCTy+sM4rXbp0ISIighkzZlC0aFFMTU2pXr26fjiKubl5nhynY8eO1KlTh/DwcHbu3Im5uTlNmjTRr2/RogVFixZl/vz5uLq6otFoKF26dLbDYgD9UM758+dTtWpVg3UZ71ILkVFsFjNLvki7nPL29kahUGSqW5ieofnkc23jxo20bNkyy301bdqUXr160aNHD1q0aIGDQ97WHsluaKgQLyI5LOnZjXLRLrfq1avH3LlzMTExwdXVFaOsro8fGTJkCDt37mTKlCl4e3tjbm7Op59+qn9Psra25tSpU+zbt48dO3YwatQoxowZw8mTJ/XB7SeDVwqFwmBZ+o209BIDK1euZMiQIUydOpXq1atjbW3N5MmTOX78eLb9fNp79Mt4j/Tx8QF0wfJq1aoBulpw3t7e2W7z/fffU7ZsWTp06IBWq9Vny6XfkLt8+fJTb2ht3bpVP8lIXl2j5IYEyt4SCbGxbPp9LgBrfpnM5ZPHaTc4+zHEbzMvZ+jWACLjQK2GpFSIigM/d/j7kO7x60QLbD4J7o7Q7D0wN3nVPXpzve9bBtZB7LkEwr+LplisK8pUBc3n6F6EkxencK3kXfb5neHjrrVwscrdBadSqaRPs8cXs5WaDiTs+kns3fwwMnmBF/DYWF3w6oIZDAY0qZBkDEbJUOAQXEoF/5NQxA+0Wl3w614NMAuDywHQuSMkxMOosVC8gi7Ty/HRvof+BKcfffjeWBRcFkOPnnAnCZaEQhVbmGQFDx/94WkfwrppgBYe9Huc7XUfuI0uUHYWMLwpDXf3wCAbUNuhj0bGq2BuhjZqIPbR9wuB4kB6LfEIB+AwTI6GpF/gFlARSK/neRvohC7I9hmQCNQH0q8H0q8DUoFAwAtdUE68GRyf3SRX7XLI3t6exo0bM3v2bAYMGJDpQ2N0dPQza2XMmDEDpVJJq1atAF0docTEx3fST548Sffu3Tl48CDFihUDdBd8GS8u7e3tiYmJeeoF54s6fPgwc+bMoVmzZoCuwO6DB48jj2XLluXOnTtcuXIly6wyExMT1OpnT0Fao0YN3N3dWbVqFf/++y9t2rTRf2CIiIggMDCQ+fPnU6tWLQAOHTKciMXERPdalPFYTk5OuLq6cuPGjWwzavz8/Pjzzz9JSkrSZ7s8ORmDeLdY53A21py2yykHBwcaNmzIrFmz6N+//1ODUXFxcezdu5e5c+dmud7IyIjOnTvzv//9z6AYeE4cO3aMzp07Gzx+cshYRjY2Nri6unL48GGD2TcPHz6szxrz9fVl2bJlJCcnY2pqCuhe44TIyNTZ7NmNctEutywtLXP8fnr48GG6du2qr6MZFxenL6WQzsjIiAYNGtCgQQNGjx6NnZ0de/bsMRi2nBuHDx+mRo0a9O3bV7/sWZlfZcuWZcmSJaSmpmYKzOXkPfJFNWrUCHt7eyZNmpRpNt6nGTlyJEqlko4dO6LVamnXrh2NGjXC0dGR//3vf1nuK/3aq2jRonl5CrkmgbK3hFJpOL77/MED+FZ6j/J162WzxdvN1lL3BaDRwv1o8L8Kya9ZkCyj2w/gyCWoWxZiE8DaQjfEVOSSBVhXs+DK0jtMD/ybft+11q8yjTOh1AkPip8sTF/H6cz/7MUKPZtbO+BZvsmzGz7pdrAuI6xgITh2lNg5v3DNpzXld5qjMNsPCR8B9cD4PCge/dE+tITU1qC+Bkn1Ib4TmKwGj7tw7hpgA+tPwZEKuiGOI4DaERAWAMoHoHEENBCdoMvw+uUMpFSDDQ9B+yhIZh0DhS3g1iQw/R2ML0OyExgDFQD3R/0vpTscMYA90AVYVBZSnohiWCdDrGnWPwMvYAdQBAgGFPEQvgGML0DIozaB6LLXhgDneTyUcw26oNsGdBlnKqAScEV3ioQDpkBvwBLdMNDG6IaQHkEXSGwEtEYX+BOvXnmgEE8ffun0qF0emz17NjVr1qRKlSqMGzeOsmXLkpaWxs6dO5k7d67BUKXY2FjCwsJITU3l5s2bLFu2jAULFvDTTz/pL8rTg2Hp0oNR6cM6XhUfHx/+/PNPKleuTExMDEOHDjW4Q1unTh1q167NJ598wi+//IK3tzeXL19GoVDQpEkTPDw8iIuLY/fu3ZQrVw4LCwsssgkwdOjQgd9++40rV66wd+9e/fICBQrg4ODA77//jouLC8HBwQwfPtxg20KFCmFubs62bdsoXLgwZmZm2NraMnbsWAYMGICtrS1NmjQhOTkZf39/oqKi+Oabb+jQoQPff/89PXv2ZMSIEQQFBTFlypT8+WGKN0IRF1dsLK2eOvzSxsqKIi55n9I/Z84catasSeXKlRkzZgxly5ZFqVRy8uRJLl++TKVKlQDdLLDFixfXD0HOyvjx4xk6dGius8nWrFlD5cqVef/991m+fDknTpxg4cKFT91m6NChjB49mmLFilG+fHkWLVrEmTNn9MOp059nvXr1Yvjw4QQHB+ufZ08W8hbvrgK1CmJa2JzkkMSs65QpwNTNnAK1Cr70vj3Jx8eHtWvX0qJFCxQKBSNHjtRnfoFuGOeNGzeoXbs2BQoUYOvWrWg0mkw1CHN7zKVLl7J9+3Y8PT35888/OXnypD4zPStfffUVv/76K5999hkjRozA1taWY8eOUaVKFXx9fZ/5HvmirKysWLBgAe3atePDDz9kwIAB+Pj4EBcXp58ZN7vste+//x6VSkXHjh3RaDS0b9+eBQsW0KZNG1q2bMmAAQPw9vbmwYMHrF69muDgYFauXPnCfX5REih7S0SEhmZatnbWjHc2UJbRjlNw+YmJVRQK+KAsJKfB4Uu6YNrr4PwtuHQb1BooaAuf1ZZg2fOqVLg4lQoXJ7lmKhw0fOE21hpR70r5l9+pI4dh1gy4V56kxC5cLHKUYmkWJJoPoai/Ewrr3rp21rcguR4k1oXUYqD2ARLgoSMkz0UXpQIefA771KTXTGN3hG4YJcAC4MZCUCejS8NyBK0tvN8dxqWA2kXXTmsLxIAyFZQz4FZJSPgMrCdCb5Uu+HQcOAG0QJfhdRUw121GJDANUDyKTBsl6YJVtmpwsYQgXdczSQSWPvp+HtD7UUHP0Eq6zLH/0GWObXn0fUYZk1rSz/fAE22SgZkZHu9QY1AF/irwF7AasMuif+LlUqHLpnza5GnfkKeF/NN5eXlx6tQpJkyYwODBgwkNDaVgwYJUqlQpU5bHqFGjGDVqFCYmJjg7O1OtWjV2795tUMz2dbVw4UJ69epFxYoVcXd3Z+LEiZlmhfznn38YMmQI7du3Jz4+Hm9vb37++WdAlyn25Zdf0q5dOyIiIhg9enS2NV86duzIhAkTKFq0qEG9I6VSycqVKxkwYAClS5fG19eXmTNnUrduXX0bIyMjZs6cybhx4xg1ahS1atVi3759fPHFF1hYWDB58mSGDh2KpaUlZcqUYdCgQYDuIn7Tpk18+eWXVKhQgZIlSzJp0qRMkweId4dSqaTJ+7VYvT37TKwmNWvly8y0xYoV4/Tp00ycOJERI0Zw584dTE1NKVmyJEOGDNFnkmzYsCHbYZfpTExMcHTMfTrt2LFjWblyJX379sXFxYUVK1ZQsmTJp24zYMAAHj58yODBgwkPD6dkyZJs3LhRP+zKxsaGTZs20adPH8qXL0+ZMmUYNWoUHTp0MKhbJt5tCpWCEtPKc7btoxozGT9nPbpkLTGtfL4W8s+pX375he7du1OjRg0cHR359ttviYmJ0a+3s7Nj7dq1jBkzhqSkJHx8fFixYgWlSpV67mP27t2b06dP065dOxQKBe3bt6dv375PzRp1cHBgz549DB06lDp16qBSqShfvrz+PfZZ75F5oXXr1hw5coRJkybRuXNnIiMjsbW1pXLlypkK+T9p+PDhKJVKOnXqhFarpUOHDhw5coSffvqJDh06EBMTg7u7O/Xr1+fHH3/Msz6/CIU2ryrZ5kJMTAy2trY8fPgQGxubl334t1Kg/0n+/HFspuU/rt/8Cnrzevltq+Fwy+JuUK+MrmbZiv0Qk/D6BMqeZGMBHevCuSBwsNYNKxW5pIHUg2n8PX0/JR96UC5Wl+2hVd1F4VAIqhjphhKWAUyAvegypDrlQ186d4CICIhYBOpHd7CN/cFqITGmn2Cd8hcKoxBIc4O4jpBSH/0VRTqVBmzCIOoZd8BVQK8F8M8aSPgU4r8AP4UuKDULXYE8tQsYJUCaJSjSwOp30DhDQn1dAE3tiu6HkoGSrIvvK+LBeiEYeUJkC3SRsKcMRzVCV99MASxHN0TzILoMsSR0scB+gAe6zLAXloRhwbNHZvF4+KZ4pnx//96DbvbLjJllTuiCZPWz3EIIIZ4q4MZ1th06aJBZZmNlRZOatfDzKvaULfNXWloaTk5O/Pvvv3leEF+hULBu3Tr9kPD8tHz5crp168bDhw9fSR0h8fq6t+4Ol78+Y1DY37SwOSWmlcepdeFX2DMhnk0yyt4SxStVplCRIoRnmC3DzMrqFfbo9VGkIFx5NKGRqRE0qgBGKli6B6LjM7c3UkLaa1L0PyYBNp/QDcsEaF8bnAq82j69cZRgXMeIqBNx1EoZyP/O9aJFmB9uCT66D+PpseTbGbb5g+cLlD24D6dP6wrsP4wGewdIH2o1czo8SNEFhozPgNoVtSoUlfUcMArBRjOZuGqfYhV9Hy5fQZtaA8WTQTIAtRKiCmVebgF8jC4+tRGwvg/nQqFcBWhdGYwUsAoYABQG0qrrAl4Zs7NiB4AyAkwuQEIHg91r0aJAgVajzbpflovAbAukeoORK5idhLgvM7dTPTpm+iQARdANqfwGXaAsPUMsBvgJ+PJRf5/ICn2qguhqqhnI5k73V+hqof1GppikeAXqA3XQTfDwAF1NsvLkSyaZEOLd4OdVDF8PT4JD7xKbkIC1hQVFXFzzJZMsNyIjI/n666957733Xmk/cmvp0qV4eXnh5ubG2bNn+fbbb2nbtq0EyUQmTq0LU6ilm24WzLAkTJ3NKFCr4GuRSSbEs0ig7C0Rde8esZFRBsscXFxeUW9eLw3Kw40wXfArOQ3uhCey66yauGQL0ouOZ8wK1iVZvj4v4LczzPKWqtbVWTPNPDOweIY+X7fEeqk5yshIXO8GAj7ZN3bPflW2NBoY8g3cDwcza0iKBVMrmDtbN6vE9n8f/1mZbSElzZdtflv4MDwJlRZQKrHy/xs070HyfBRa3S85zigSU60ZxmoLQAvGxyA1ixSobqlg/jfEmUBqK0hdBld1RbLTLtbmO4cTRJrE8tPFL3A8bZtNEM4NtKlgljkqlWqcikmqCVqFFrRksb0RJFeHh2N0DxXbwXIppLpCSoMMx3his1tA16f8XE+RuyAZZBEkyyiNTG99p4BL6GqviVcvveacEELkEaVSiYfb65XBUqhQIX744YdX3Y1cCwsLY9SoUYSFheHi4kKbNm2YMGHCq+6WeE0pVArs62Zxg1eI15wEyt4SO5cvJTEu1mBZZGjYK+rN68XEGBpVhJNXdUMXNx5PQKPQFUTVajVYmCrRah8Pz1Rr8ydIVtAG7sc8u112jFSw1R8Sk3Xn4/c8wZx3mMJIQafujXQPhqbCvsfrlr23k89PNny84CkxNAOBVyHVDAqZwpVAiH4UrE6M1wXFkuPgm2vgtd1wu4QOmPha0jI4EkwjdMvSGkKcH6SVhbT0SGgqVpY/PQ4+oQATK1Btg6Qm6GeXBJgfCVpfsJ0ERr66oBegRcF2VQiTS6wCwFRjzOzTAwFIUqZgpjEB5V3QPBrKqSkKKZXBdA8kp49103LfM4QUczWW0VYUupVxDLAGVImoNR+hUYejj+GmVALLvyH5OQqIpmedwdOLu+d2nwDqLN72jAC3PDqOEEII8YrlZ2WdYcOGMWzYsHzbvxBCvA4kUPaWcHTN/CkvOTGrCtrvpuJuui+A4wHGBgljiSlPNNZq0ZL3s/e8SJAMIE2t+wK4elcCZS9krDF8h25WxU/Bbr8VaQo1D43jcEixhbK6Zhqthjux93GzckSlVOlmYDx7E5ZOgDgLuP4VWM0F42tAGngWhyIOcLg4JO8FtTtc84KIa48DNVpnSKkOwb+C6UXQKkFrA5EdQeOkq0FG+lBHY4jvCYqHoLzHCduHLPeeyifBLakd9sSQkRQnwAkSG0Ba6Udf7mg1BTByiKXbzShcEx1xSXw8a5aJ9tFbgCZjvTNFhgDZ42VuVzxJNk9CpcnibUNtgSrBklhHM+z0ZShUoLwHaSVy97sBw6yzB9m2ev59ZiWbyTmFEEIIIYQQ7xYJlL0l6n/WAVMLC7Ytejzts0atJikhAbNspm9/V9UprWH/+YekpSVgZGo4PNVICSpFIsnqF/uZGSshNR/rnD2Mh91noV5ZUL4+o0TfHBbA9McPyyZ5UbFwb87b3WCcdTdGfqQrUNZu4zj+DjzAe86+mEYZse6f8TgmeoLREEjzBpMTYPpoSsbkivDfGG40jqDQTTusTrXRLVdEQWJjsFqhe5xYE1BCXCfQWENyadAU1gXJQFeDjAxDG9N8AA1YD6BZ7QAijGGh22IiNrTCVGNYaF+LFoXqKiiiQWsHaT4oNA40vqeg8b339G3SpRmrMUnRguleUCRBUjN0UeSs/6hMEw3rfGnQoMyQ1WbzwPbxSqeSoGwMD7LaVy6GNz/v3/eTsyw9jSkGyXlCCCGEEEKId5d8NHhLKBQKQq9fz7R8zbQpr6A3r7cKPnb0/8iK1jU0ONnq0kzSg01pGkjVvHhgMT+DZAARsXA+CILu5e9x3hX3Po7ivN0NAFab7tMv33DlCABnQ24wc/MAHBPtdCvSSgBGuiCW5tGylKqgMcV9QiGsTlmA0XEgDQoM0QXJ1PYQOxmS6gMa0NpDfHdQ+4D1TNKsMsxQ64SuqLn+FVoFDydRMMkSAFO1CUqtbqX2yWhQSj2w7w/W/wOSMtUS0z8uDiYpxrp9J9eH5IaPDphdYCuz9CBZeh8yBs0IdgXnfllul6vol35EeQoYHyLrKTezkNMgmQr4EckoE0IIIYQQQgASKHurmFtbZ1qWFJ/FtI4ClUpFscJutK+rYmBLKJFhGKMm/8o6AGBnmXf7CgyBu5F5t793VTlNMZpEVsEqzZxBtp8AkJqYxojA9pSMKcji/zpQIVpXuEybMVCjsYOH39C3hBU9ql4lwuYhxlojUCSgtVoEqEH1qLK8yUMYlwrFx4DF8sf70BYAZQIq452Pl0UBDXgUE3oUVNKas/mCOT9fdWDfqYIYK++hRUsKqYYnk9QUoibrZpzUZFW4+FH/g2PBNP2PXYmW5MxNjQ89+ubpga0sJwYAOJZ5UYRThG5CgNwyugnWC6FAP1Dk4R+9GriZd7sTQgghhBBCvNkkUPYWadSpC0qVymCZmaUMu3wWhQKqFgePQrq6X++XBFf7xzXN8lpeBuIC78DaI5CPNVvfCSb+xvy7+2di122hx+lmAIzYO58R5zpwcfsftL/VRd92avG/CSk4FmxHgcUqSK3K9ydm87ftAYZ2nsZ5p1+5ZXkOomcDphA1AW1qMbQp5jD5O0ioBanFwDxNt0NlAijvkWAb/zg7LAVdDbV0ili0FqsoFleYb+/GUCYlGMw3okCBKY+HX+oDVhon0rSWbHM6wdAyv3HI4Ty3zcO5a3n00c5Bm2QFyY8DXGcaXuBK1aOkGT/ULVCFgNn+p/7ctGgyZ7Q9g3miGefrnSbNODV326b5EmXZjUi3CFDloOCfyRGw7w4mWUTrMrIAsphEVAghhBBCCPFukhplbxETMzNURkZo1I+rVl87febVdegNYmsJrao/flzZRxfQ8nQCMxPYfx6i8yg5LzXtxfeh1aSiUOrmF0xTQ1QcxCRC0YK6wJ/IpWqAKxAJ6OJk3E4OZ4rvan643Enf7KZFKEPL/YbNFRW9QpUQ1woAtyRn9u7/BYcSUymqPUqqxg1FevX+tDIoov8HWiuwmg3JoZDaG30imMYCVIsxrZKAIiibX57WGkVCB0gtC8bDATWa1NIo0OqCY8YnILU0uqgPgIJY4zia3KtCo3uV+bzKRKJM4rBR3mflkeEo0nwMssDi7eK40OgiWqWWy+/fpuW8e2B0CWLGZd0f1WUwO4LC5BhETwatbdbt9O3RF9O3iLGkzN7yKLS5u09zxy+YPT0ug7IB769MxfVCEqYJptlks6nBcjkYhYDln5BS7fGqkkAykAh8+ujLPFddEUIIIYQQQrzFJKPsLVPEr6TBY3VaKuq0PIjMvIOUCl2GmacTOBd4vLx2KTA1fv79ZpplM7fbR+8nJmwe8RGb9dN/L98H64/CnC0QEvFi+38nOQEbgP3Ae1r4LZm/Jg/mu8sduGZ1Ca3yDrdtz9G65kick5U00NjBl33h84r6XVSI9qboDV2mk5HZv2AXTZp1JHucV4LWFA0aTpm78VDtC8B+57OPjx9ujlFhh0wjHOPNkthV8NTjzKvU0hCxCCIWoUyuxZ0Pg+G9MEityOMgmY65SjddpFqhoUK0N/8e+pmVygXcK0AmqhQjVCm6+yZppmkEeX0I0XNBUzDrn5fxbbBcBca3oGrAs3++BdG/2ySbJ+mDZBrFM+qNmQOPhkVHuj0AJahSVEQVjMQkwYRzDU4R4Xo/iw3jQRmt+za13OOfqxMwG1iJ7vfdCQmSCfGCPDw8mD59+qvuRpaCgoJQKBScOXMm2zavc//Tde3alVatWr3qbgghxBtv8eLF2NnZvepuPFNOXvfr1q3LoEGDXkp/3kUSKHvLJMTGGjxWGRujMpLEwRdVr6xuSGbLqlDRG7o3fMYG+TgWMiUxEBOL0qBQotUkAaB+FG9IVcO2/x4/FjmQCAwHvtDCvhvQciH8eRpVqhVKVFhpUphQqRuObQ5y5HwwwceVeN2LgeBg+ArwPgiqmygs/oQ03XNNUTAW3AdgVHY09dWLoGArelcfRqW6MylXeyMxRvFUvO+j74LGIhEKqzMVoLdMMqNQsq0+a0qLVhe80jgDYH0lCU468Tg5WIuuLlooZiMLEts4gRvWoQy98pmuX/sV2N/3yPQjMEswo+mvLfE+5kucYxwHuu7i8vsXsv+ZJb+HVmtMkokrSee9oQ5glbHjGb53BKLRl0bTAtcrXiHKOZK4AoavV5kkArcBYyh+pCQtf25Dx+E9KLOzAkqUlN1VEYe7WQXzbCDyd3j4OxTuBSOBFcDfT/RTiEfCwsLo378/Xl5emJqa4u7uTosWLdi9e7e+jYeHBwqFAoVCgbm5OR4eHrRt25Y9e/Zku9+IiAgKFy6MQqEgOjo6T/pat25dfT+y+qpbt26eHOdJ2X24OHnyJL169cqz4+QkuJWXctv/ffv25envMydmzJjB4sWLc7VNxr9XlUqFq6srPXr0ICoqSt9mzJgxWf4NWVrmYTHVd1h2H3Sf/BuaP38+5cqVw8rKCjs7OypUqMBPP/1ksE1MTAzff/89JUqUwMzMDGdnZxo0aMDatWv1N02FELrnXfprmYmJCd7e3owbN440SRx5qpy+92bX7p9//qF+/foUKFAAc3NzfH196d69O6dPn9a3yeo6IiAgAHd3d9q0aUNKSop+X3Xr1sXW1hYrKyvKli3LuHHjiIx8uYW5JVD2Fvlv905Cr18zWFaocJFX1Ju3i6mxbjiml/Pjx5ZPmyUvH8c/Wtg3w9yuLpb2zVAozTKtj00E/6v5dvi3z05gN3BWAWNugvo8mP9DetRKa5TGD7eUmG/ciIVzYYy1j363N3WzZKKcDQ5fgtVyXb2xh7/C1VkQXBRCvXXZTIo0DjheBuDW/9k777iqyjeAf89d7L2RLaCAgnugqDhy75VaqVk/K3PkzFJc2XCllplpOcrREEfmSFHTXLhwhAMVRJG9N3f9/rhy9QbOcNX59iE873nO+z7n3Mt5z3neZ5ilkmiahoVa5wGmRYNg/A7Rh36iWFIxob5MI+WQ3XnOm9+dcV6nm1W8ERqZllSv5NteZwJaJKB2gZuWWOwyxT/PjSKrItQyFVqtFgXy2z0YPljb5NhhnWKr3y62KKqgi/4YrTVC+q8obn5LjmMZHEJn1Crn7jDlpkDJnU3jYmOs0mxIqnED48KK399KUeqMedZpOnc4RZkuL9s9iwgAOJrBH57wPdAV8AUecjiRZ4xaDWfPwP59ut93pRN4EiQkJFC/fn327t3L3LlzOXfuHDt37iQ8PJwRIwwrt86cOZPk5GQuXbrEmjVrsLa2pm3btsyePbvSvocNG0ZwcPADdZg+fTpDhgx5KH0jIyNJTk4mOTmZ6OhoAPbs2aNvi4yMfKh+qgoHBwdMTV/cfKjPs/5qtRqNRoOVldVjeUCUf18TExNZu3YtBw4cYNSoUfr948eP139vyn8CAwPp27fvPfscMmQI06dPf4yzebZo1GounzrHid1/cPnUOYM0Jc+S7777jjFjxjBq1ChiYmI4dOgQEydOpKCgQC+Tk5NDaGgoa9asYfLkyZw6dYoDBw7Qv39/Jk6cSG5u7jM8AxGR+6PVqCm4uJ/so+spuLgfrebJ/+116NCB5ORk4uLiGDduHNOnT2fu3LlPfNz/KpMmTaJ///7UqVOHrVu3cunSJdatW4ePjw+TJ0++53HHjx8nLCyMDh068OOPP6JQKPjwww/p378/DRs2ZMeOHZw/f5758+dz5swZvv/++0r7eZRnqEdBNJT9i9j05eIKbXVahT8DTf4b9Guh8zQb0AIcrZ/euHKjO5UMhXsY5EqVlTaLVIY/ILm9yiS9ALKLgBHl8XoOqrssQJ6eYKKL1ctIl3Nh4RGuD+gH9g7QuQu8vBRK/UFjD3nvQ7IzFHUDtSWfnu1GoMSddxVBBOWVG7C1CIoDjPcIpLFkObNfW8KBV6LIt72TrP794OU0bz2KsDajyZUWUGhZyJk2p0nzSkFQeXC822EuNY/VG40EBJ36J3WGLQEB43xjpCqZgWFJK9eCHF1utv/pTrfG4QAC9wVT489AgvbVqXCpBAS9sUwLSJDgkOgEKvQ5yP5O2RElCSYpqNFQQhkYgf1NB4L+CCbVK6WCwa7UuJQrDS6hVDz+l1jzsga+A6QPFBV53jj0J7z+GkyeCHM/1f1+/TVd+xPinXfeQRAEoqOj6d27N/7+/gQFBTF27FiOHjUsBmFhYYGzszMeHh60aNGCb775hqlTpxIREcGlS5cMZJcuXUpOTg7jx4+vUn1tbW1xdnbG2dkZBwedR6WdnZ2+zdbWttLjjh8/Trt27bC3t8fKyoqWLVty6tQpA5mcnByGDx+Ok5MTxsbG1KpVi23btrF//36GDh1Kbm6ufqW+3Fhyd+jiwIED6d+/v0GfSqUSe3t71qxZA8DOnTtp3rw51tbW2NnZ0aVLF65evaqX9/b2BqBu3boVPORWrFhBQEAAxsbG1KxZk6+++spgrOjoaOrWrYuxsTENGjQwWMm+F38PvRQEgRUrVtCzZ09MTU3x8/Nj69atgM6oGh6ue66ysbFBEAT9w7lGo+GTTz7B29sbExMTQkJC+OWXXwzG2rp1K35+fhgbGxMeHs7q1asNPIvKV9u3bt1KYGAgRkZGJCYmVvBMatWqFaNGjWLixIn670Nlxqvy72u1atUIDw9n8ODBBp+5ubm5/nvj7OxMamoqsbGxDBs27IHX7UUiZv9hpvYexqKRH7By+jwWjfyAqb2HEbP/8LNWja1bt9KvXz+GDRuGr68vQUFBDBgwwMD4/sEHH5CQkMCxY8cYPHgwgYGB+Pv78+abbxITE4O5uegqLfJ8knsykosTvLg2J5wb3wzk2pxwLk7wIvfkk13QMTIywtnZGU9PT95++23atm2rv4//natXr9K9e3ecnJwwNzenYcOG7Nmzx0Dmq6++0t+7nZyc6NOnj35fq1atGDlyJGPGjMHGxgYnJyeWL19OYWEhQ4cOxcLCAl9fX3bs2KE/Rq1WM2zYMP18UaNGDRYtWlSpfjNmzMDBwQFLS0veeustvddVZXz//fc0aNBAf+8fOHAgaWlp+v3Z2dkMGjQIBwcHTExM8PPzY+XKlcD95977cfToUebMmcOCBQtYsGABYWFheHh4UL9+faZMmWJw3nezd+9eWrduzbBhw1i+fDkSiYTo6Gg+/vhj5s+fz9y5cwkNDcXLy4t27dqxceNGBg8eXGlfTwrRUPYvIf3mjUrD/Rp26PAMtPlvYGUKId7gZANtQ561Nob8lQi5VVR84N/OTWJ4t8HrzKk1EaXpThBApYhGozgE0gSkinUAXPZxhuhjkFsd0tdjd+FTAtY2xWRNKNrr36Pd/S65NeR3GX5KoLgHFIxAlfchPZKbEZNTmy92X0ZARXydq1xuchGNqgW5UoGll0fSyMGdhHpXie59SK/fHifdS02OoGCNzx9smrKeM51PsH/o74CEPPs8rte5xoXm59AIuiqUZ5uf5qT9MdTy2wZArc5zTZ8TTAYSpURXUKAu0BEoAqlKRoNfm9B4a3MUpXeqaV7q9hcquc5wJSDwu0UyhQqd91upaQlFloVohdvn/Tfb7V7pKRq3HUGZRIkxCl0i/dv9XAr7C7VURa5Lji5XmAR2D9+Gx3lv5GWPlgiw0KkQlZsKXgPJOAk4PtLhIs8Dh/6Ej2dBRoZhe0aGrv0JGMuysrLYuXMnI0aMqDTc7GG8eEaPHo1Wq2XLli36ttjYWGbOnMmaNWuQSJ6PR638/HwGDx7Mn3/+ydGjR/Hz86NTp07k307ZoNFo6NixI4cOHeKHH34gNjaWTz/9FKlUSmhoKAsXLsTS0lLveVSZAXDQoEH8+uuvBt4wu3btoqioiJ49ewJQWFjI2LFjOXHiBFFRUUgkEnr27IlGo7s//d1LrtxDbu3atURERDB79mwuXLjAxx9/zNSpU1m9ejUABQUFdOnShcDAQE6ePMn06dMf20g5Y8YM+vXrx9mzZ+nUqRODBg0iKysLd3d3Nm7cCMClS5dITk7Wv9x88sknrFmzhq+//pq//vqL9957j1deeYU//tBVD46Pj6dPnz706NGDM2fOMHz4cD788MMKYxcVFfHZZ5+xYsUK/vrrLxwdK7+ZrV69GjMzM44dO8acOXOYOXMmu3fvvuc5JSUl8euvv9K48b3L/K5YsQJ/f3/CwsIe+lo978TsP8zyDz8hJ90wgWtOeibLP/zkmRvLnJ2dOXr0KNevX690v0ajYcOGDQwaNAhXV9cK+83NzZGJKVZEnkNyT0ZyfUkflNk3DdqV2UlcX9LniRvL7sbExOSeBqaCggI6depEVFQUp0+fpkOHDnTt2pXExEQATpw4wahRo5g5cyaXLl1i586dtGjRwqCP1atXY29vT3R0NCNHjuTtt9+mb9++hIaGcurUKV566SVeffVViop00RoajQY3Nzd+/vlnYmNjiYiI4IMPPuCnn34y6DcqKooLFy6wf/9+1q9fT2RkJDNmzLjneSqVSmbNmsWZM2fYvHkzCQkJBp5WU6dOJTY2lh07dnDhwgWWLl2Kvb09cO+590GsX78ec3Nz3nnnnUr3V+bUsWnTJjp37syUKVP47LPP9O1r1669b19PO7eceGf9F3Ah+hg/zvusQrsgkaAwEmONngaO1hAWBBdvQlEJFFaMoKuAVqu9p0fY41LeZ6kSVu6Bhn6Qlgt1fcDLqUqH+tcw7eBKvvO8CdzEWVOf1zLOIlPWgbJmAAjFL4PiY0qLCqBWbTjQAbS2enuQvFjB70O20XxtOPIPVDqvLcUhMN2CtqgbQllz4iXmnPzwEGXmltSX+2F26wgHX7kM6JLbL9s3FikSVH+p2PDxKkxzyl/Y1Xx5+g3e9zpNujKIT6yV/PhHIBYaOWaZuhXk0B/DONb7MIJGQNAK3KxxgzMdT6CVaLFOsaX6KT8kWgnp7qkU2hbgdaY6WpUWjVTD4f5/UOCQT6N3m2GH/Z2LsgF4B7i9CFXoU4harkamlKORaHBSG2Nepru3mOabER98BetUWxLKMnm3zmJGZPagc0YDzLPNaZBbk/bJDTHRGMYqp3ukYptkz8lu0dgU2WC1yxoAv+iaJPvfxPOszx3hQOBDYAS6fGeOwGfolnr+BHzBrLWYU+eFRq2Gb5beX+abr6FJU5BWnavglStX0Gq11KxZ87H7sLW1xdHRkYSEBABKS0sZMGAAc+fOxcPDg2vXrlWRtv+M1q1bG2x/8803WFtb88cff9ClSxf27NlDdHQ0Fy5cwN/fHwAfnzt/h1ZWVgiCgLOz8z3HaN++PWZmZmzatIlXX9VVDF63bh3dunXDwsICgN69exsc89133+Hg4EBsbCy1atWq4CVXzrRp05g/fz69evUCdKvfsbGxLFu2jMGDB7Nu3To0Gg3ffvstxsbGBAUFcfPmTd5+++1HvlZDhgxhwIABAHz88ccsXryY6OhoOnTooPfYc3R01D+0l5aW8vHHH7Nnzx6aNm2qv3Z//vkny5Yto2XLlixbtowaNWrow39q1KjB+fPnK4TtKpVKvvrqK0JC7r8CFxwczLRp0wDw8/Pjyy+/JCoqinbt7iRRnTRpElOmTEGtVlNSUkLjxo1ZsGBBpf2VlJSwdu1a3n///Ue8Ws8vGrWanxd+c1+ZXxYtJzisMZIqvK/czbZt2yp4fKnvCvucNm0avXr1wsvLC39/f5o2bUqnTp3o06cPEomEjIwMsrOz/9E9SkTkaaPVqLm1bjQVku/q9gICt9aPwbJudwTJk3P/12q1REVFsWvXLkaOHFmpTEhIiMH9dtasWWzatImtW7fy7rvvkpiYiJmZGV26dMHCwgJPT0/q1q1boY8pU6YAMHnyZD799FPs7e158803AYiIiGDp0qWcPXuWJk2aIJfLDQxe3t7eHDlyhJ9++ol+/frp2xUKBd999x2mpqYEBQUxc+ZMJkyYwKxZsypdhHv99df1//bx8WHx4sU0bNiQgoICzM3NSUxMpG7dujRo0ADQeVSXc6+590FcvnwZHx8fA4P9ggULiIiI0G8nJSVhZWUF6AyTffv25YMPPmDSpEkGfcXFxeHj44Nc/g+q5lUhoqHsX0Dk4s9RlVvJBUHvWWZfze0+R4lUNfV9dT9qDVxLgex8kMvAwlT3DphbBCfjNJQohSo3kJXz936P385Vlp4L/xOdCyuleuxNcAFBCz5lMSCVg1CCLvu8BA1qrhkZY/bSWxDiBiXxcEiLVg5FNoVE9zxMavVkLjU7Sb3fWgJlaK1mIwhqlIpznE//BDsna8rMddbTC/UC8ZLqklFKVBJkpTKkt517ZSoZXeb2wiJLN5kg5PN6Qie+ss0h3QQaFNjS4niogf5GeSa0/q69ftv9kgfV/nIn4I9gHK87UmhZwPk2J7Aq2I7f2USQT0BQ1udm0HXiG+hyGp5pf9KgDzYCZinoykQKqK1V7B6+Ha+Y6pgmW7GyOJNPEkMw1krRChrcY72QqWTk1c6lZl1zxqYvpnr2JHLdsnGJc2Xm4cEUSUow0RihMlJxtt0pyqxLccp1ISXkFtUKPGCXbmhnYzeONT5IWqcUGiQ3RSgS4C3AEtgOJAPVuBNWaVjoV+RF5a/zFT3J/k5Guk4uuOpceKsqCfbdCx+TJ08mICCAV1555Z7yBw8epGPHjvrtsrIytFqtQajesmXLGDRoUJXoB5CamsqUKVPYv38/aWlpqNVqioqK9KvmMTExuLm56Y1kj4NMJqNfv36sXbuWV199lcLCQrZs2cKGDRv0MnFxcURERHDs2DEyMjL0nmSJiYnUqlWr0n4LCwu5evUqw4YN0794AKhUKv3D94ULFwgODsbY+M4CYbnR6lG5O6+cmZkZlpaWBuErf+fKlSsUFRUZGKlA97mWv1BdunSJhg0bGuxv1KhRhb4UCsVD5bX7u4yLi0sFHSdMmMCQIUPQarXcuHGDDz74gM6dO3PgwAGkfzMMbdq0Se91eDdr165l+PDh+u3S0lIEQWDevHn6th07djyXXmhXzsRW8CT7O9lpGVw5E4t/vdpPRIfw8HCWLjVcBDh27Jj+/uDi4sKRI0c4f/48Bw4c4PDhwwwePJgVK1awc+dOMVG/yAtJ4eWDFTzJDNGizLpB4eWDmNdsVeXjlxuolUolGo2GgQMH3jO3YkFBAdOnT+e3334jOTkZlUpFcXGxfm5s164dnp6e+Pj40KFDBzp06KAPzS/n7vuxVCrFzs6O2rXv3FOcnHTeCnffo5csWcJ3331HYmIixcXFlJWVUadOHQPdQkJCDMZp2rQpBQUF3LhxA09PzwrnUu5NfebMGbKzsw3m18DAQN5++2169+6t93Lr0aMHoaGhFfr5p7z++ut069ZNf6+7+z5mYmJC8+bNWb58OQMGDCAgIEC/72Hvd0/rGUo0lL3glBQVUnxXiMPd4Zc936ncci7yZJFKwK+idzwAdX20fLG1GEFqhlZTBBLTJ2I002q1KIsvIzepjiDIsBHTV9yTyZYB1ImJx1GdRv18KQhqsMmAot0gzUJith7fIjPIaAARw6CwEDz3Idyci1mKOSG/12N39SQUuavY4SyjY4YNSq0lCiGbOBM1UqkCt1tuWMbbkuWZwbcZ53g52wXfo/7UjqqLZaaVgT5W6TZ3NrTWAEy7VY/3XW/RNqcSt0ApaFQahNv/adHSeuUdq6hZnjmpPhkUZbWm2tVVGGt/Ic/aA+tkW2SlMlRGKvLtc8l2ycQm2U53UOReXXVNdCtKIZYNOFPzBKpmKoQf1Xy2NQgj7e0Kn1opEhXk2+Txx+DdtJR442NjwzXhMkrTMlL8k9guv8lZ66tMrt+Kjp7d8XOqgYmRGXKpHB9uV/90A+Rg1ciKl+hS+YclB8T6JP9OHraSURVXPPLz80MQBC5evPjYfWRmZpKenq7P77F3717OnTunf2Arf/Czt7fnww8/ZMaMGTRo0MCgYtTixYtJSkoyCEEof7CuKgYPHkxmZiaLFi3C09MTIyMjmjZtqg9HMbmdf/GfMmjQIFq2bElaWhq7d+/GxMSEDnelgejatSuenp4sX74cV1dXNBoNtWrVum/elfJQzuXLl1cIHfy7wacq+PtqtiAI+heO++n322+/Ua1aNYN9Rkb3q/xTERMTk4d6LngYHe3t7fH19QV03/WFCxfStGlT9u3bR9u2bQ1kV6xYQZcuXSp877p162ZwzSdNmkS1atUMigL8/ZyfF/IyH+5+8bByj4OZmZn+Myjn5s2KBoRatWpRq1Yt3nnnHd566y3CwsL4448/aNmyJdbW1v/oHiUi8rRR5iRXqdyjUm6gVigUuLq63jc8efz48ezevZt58+bh6+uLiYkJffr00c9JFhYWnDp1iv379/P7778TERHB9OnTOX78uN6ruLL78d1t5ff08nv0hg0bGD9+PPPnz6dp06ZYWFgwd+5cjh079tjnXFhYSPv27Wnfvj1r167FwcGBxMRE2rdvrz+Xjh07cv36dbZv387u3btp06YNI0aMMFj4eFT8/Pz4888/USqV+nO2trbG2tq60nudVCpl8+bN9OrVi/DwcPbt26c3lvn7+1foqzKe1jPU85E4Q+SxyMvMYOGIt+65/+9JskWePXKZlDa1srE1ukCLgFxqVHsynmVlRbEU5+ymJO8oDf2hlmelKexEAKFPfzrlZdIgzwJKm4LKBbW6GrzUHkz2gFAK0ix2We1Ao6/UU6JPXu9Q4kT3z7qQkNCZXd7TwPY9BEk2i1xktKyr4ppDJlKVjJZft+fXyFvsTL/EwcKrNPupFRaZlno90q0zUElVFNjk68I3rQAZaCQaTLukMLVnGjW7xKGUGSa5l6lkSJCgFbTku+aikqlQS9VkeKShVCjRouWlrzoTvrID5td+QJYRgUWiJVbp1nT/rB8Nfwkl1zmHw8MOQHkOcNk1MP4dUIN9Doq6Chq6h5IYF8+fjfeiKK344icvlSPR6KYUd5kNSlPdpKxSa/jN5ji967egU4Oe2Hs7YmlqjVz6twmwGVDRuULkv8I9EtA/ttxDD2tL+/btWbJkCYWFFRM7lidZvx+LFi1CIpHok61v3LiRM2fOEBMTQ0xMDCtWrAB0K6DlVTRNTEzw9fXV/9ja2uoT/pb/lIcqVhWHDh1i1KhRdOrUiaCgIIyMjMi4y4svODiYmzdvcvny5UqPVygUBiFj9yI0NBR3d3d+/PFH1q5dS9++ffUPvJmZmVy6dIkpU6bQpk0bAgICyM7OrjAOGIanOTk54erqyrVr1wyuka+vr95AGRAQwNmzZykpuVNm9+/FGKqCyvS7O/H+3/Vzd3cHdKGWJ06cMOjr+PHjVa7f/Sg3KhYXFxu0x8fHs2/fvkqT+Ff2vbS1tTVoqyoja1Vjafdw94uHlXtaBAbqXKULCwuRSCS8/PLLrF27llu3blWQLSgoQKVSPW0VRUTui9zapUrlHpVyA7WHh8cDc/gdOnSIIUOG0LNnT2rXro2zs7M+lUI5MpmMtm3bMmfOHM6ePUtCQgJ79+59bP0OHTpEaGgo77zzDnXr1sXX19egqE05Z86cMbhfHz16FHNzc/28cjcXL14kMzOTTz/9lLCwMGrWrFmpJ7SDgwODBw/mhx9+YOHChXzzjS48vbK57WEYMGAABQUFFYrr3A8jIyMiIyNp2LAh4eHhxMbGArqCQPfrq/yZ7Gk9Q4keZS8wh7ZuoeBvD5jltBkwCM8AMSbpeSTE342QuyJbWpXAvnMQV/H557HQaEooyf2jfIvjt995isugXvWqGeNfRcotnRUx+3NyHM0pNc2nyCqFw2HLCTDyoO7+IvYEuDG5eDsrGhjzs0M3aNYKbgGnoKRrCbGx13C/Xp320dZAPnJgRLKK7rc+wytdF2pjo7Tgk3NvEOV4ilcS27LBbS/1FB645DgS1+QiWa4ZtFnREYvs28az29Xed4z+iUxPXRXMGqeykKt0L5xKuZKLYecJ/CMYqVqKRCvB4pYVWkrY/dYuUvxv0WBTUwIO1sK4WPcSIyADjQzF7fdI0xwzbtRO0PVXrUyXm2wJYNQTChaC7BMYMxrMQbtCS45/FgigkaqRqu9MH1q0GBeZ0G5pF+KaXOBa/TiMMcHayoYmvmEMbP46xrI7xQFERCoQVAvs7e8ffmnvoJOrYpYsWUKzZs1o1KgRM2fOJDg4GJVKxe7du1m6dCkXLlzQy+bn55OSkoJSqSQ+Pp4ffviBFStW8Mknn+i9RqpXN7zRlhujAgICnnoi2rvx8/PTV8TKy8tjwoQJBgaOli1b0qJFC3r37s2CBQvw9fXl4sWLCIJAhw4d8PLyoqCggKioKH04yN0hIXczcOBAvv76ay5fvsy+ffv07TY2NtjZ2fHNN9/g4uJCYmJihZxYjo6OmJiYsHPnTtzc3DA2NsbKyooZM2YwatQorKys6NChA6WlpZw4cYLs7GzGjh3LwIED+fDDD3nzzTeZPHkyCQkJ/2iV/F54enoiCALbtm2jU6dOmJiYYGFhwfjx43nvvffQaDQ0b96c3NxcDh06hKWlJYMHD2b48OEsWLCASZMmMWzYMGJiYli1ahVw7wrW/5Ty72t56OXEiRNxcHCoEGrz3Xff4eLiYhDK8m/ANyQQawe7+4Zf2jja4xvy7J6X3377bVxdXWndujVubm4kJyfz0Ucf4eDgoA8dnj17Nvv376dx48bMnj2bBg0aIJfLOXjwIJ988omBZ4uIyPOAmX8Ychs3lNlJVJ6nTEBu64aZ/7MP2fbz8yMyMpKuXbsiCAJTp0418M7dtm0b165do0WLFtjY2LB9+3Y0Gg01atT4R2OuWbOGXbt24e3tzffff8/x48f1Cz/llJWVMWzYMKZMmUJCQgLTpk3j3XffrTQ/mYeHBwqFgi+++IK33nqL8+fPM2vWLAOZiIgI6tevT1BQEKWlpWzbtk3vzXWvufdBNG3alHHjxjFu3DiuX79Or169cHd3Jzk5mW+//RZBECrV18jIiI0bN9K3b1/Cw8PZu3cvjRs3ZuLEiYwbN46kpCR69uyJq6srV65c4euvv6Z58+aMHj36US71P0L0KHtB0Wg0HN+1s9J97v41CO8/4ClrJPK4mBpD54YwtC10qF+haOAjI5EYY+74GkYWjTC2uJOf5Ub6P+z430qLVtC2HSnV1WwbF8nvI37ndId4CrRavqnmzsy32pDS048xNVvwqnIw2tWvo37Lk9NGxznd5zhHlQe4bH+BM/WP0zDkQ5AFU2JlRbaLDeeH7iUh5Kq+ImSNfHdO3JqLh9IBW6Ul/td8EbQCsS3P4RVTXedJBgZLGK1WN8fxmjk+x/1wP9UfALVEzbXXruB0xRUtGgPv0TTvDFL8buFyqRqBB2sjIFBsXkSOQzZqqZpSk1K9V5qAgPcVX0wVpoTVaA02wBRggh3MmAVTp8DtFRlBKmCWpYvh3fvOLrShWrj9jqx10I3vlOJMyK76tFrbjt6eA3gpuAuWplaikUzkwUil8L8HJF3/31tVmsi/HB8fH06dOkV4eDjjxo2jVq1atGvXjqioqAq5hSIiInBxccHX15dXX32V3NxcoqKiKiSkfR759ttvyc7Opl69erz66quMGjWqQkXFjRs30rBhQwYMGEBgYCATJ07Ury6Hhoby1ltv0b9/fxwcHJgzZ849xxo0aBCxsbFUq1aNZs2a6dslEgkbNmzg5MmT1KpVi/fee0+f3L4cmUzG4sWLWbZsGa6urnTv3h2AN954gxUrVrBy5Upq165Ny5YtWbVqlf7FwtzcnF9//ZVz585Rt25dPvzwQ4MwjKqiWrVqzJgxg/fffx8nJyfeffddQJcAeurUqXzyyScEBATQoUMHfvvtN71+3t7e/PLLL0RGRhIcHMzSpUv1VS8fNTzzYSn/vrq6utKlSxfMzMz4/fffsbOz08toNBpWrVrFkCFDnkgY67NEIpXSd8z/7ivTZ/SbTyyR/8PQtm1bjh49St++ffH396d3794YGxsTFRWl/5xsbW05evQor7zyCh999BF169YlLCyM9evXM3fu3Id6mRUReZoIEimuAxeVb/19LwCuAxY+0UT+D8uCBQuwsbEhNDSUrl270r59e+rVq6ffb21tTWRkJK1btyYgIICvv/6a9evXExQU9NhjDh8+nF69etG/f38aN25MZmZmpZUe27Rpg5+fHy1atKB///5069btnrnWHBwcWLVqFT///DOBgYF8+umnFRaLFAoFkydPJjg4mBYtWiCVSvU5RO819z4M8+bNY926dZw+fZouXbrg5+dH37590Wg0HDlyBEtLy0qPUygU/PLLL4SGhhIeHs758+f57LPPWLduHceOHaN9+/YEBQUxduxYgoODK+TQfNII2meQJTIvLw8rKytyc3PveeFE7k9WaioLhld0kQdw9anOOwsWVbpP5PkntxBSc0CjhYIS+PMvsLPQFQkoKAaFHIpKwVgOJcoHdKbV6go8AEEe0K7uA+T/w1w+doGjZQcBsL9RzHEzM7xtDfO9+B8KoMnGMC41ieVYvz8BsDSxIq9Y5/5lb+GIv0MApdoSTsYfQyaR0XvKICTFErQyDRKtknMdV5Js4k2DTc1wLNXlIzvVPpqQPfWQqmVoBA2SERK4AWwpH1lXIcgACyC/4nkc7vcHV5pcwuamHV0+74WgFSh2LqI4sIjfOm4CAYwKjGmsaI6nmTc0RJf760GooPSXUtLMk3F4yRljhTEUA+noqlCeBbyAE4Av8Pj5wEWeY574/H3oT131y7s9y+wddEayZs2rfjwRkWfI7Nmz+frrr7lx48azVuVfTcz+w/y88BsDzzIbR3v6jH6TOq2qPpG1iIiIjtyTkdxaN9ogsb/c1h3XAQuxqt/rGWomIvJgxNDLF5S8zHuHp5hUcV4TkaeLlZnuJ68ITl2BtnV0Rq7ygqaCADmFsC36IQxlgoC5sa7yZkO/p6H9i4tPAz/SL92i9NQlGq0No7k2k43vxyOVgkapwPGqAyG/1ydLVspZ7zsvNaZG5jpDmRYy8tPIyE+jxsFAPHv6YGtuh9xfziWTWJzTVmOTc466R7QE58zllkRJilEmlkoz6u5qiICAUqYkp1cWDi2cIIu7DGWV+BlWYiTDAzzOeRNf/wpF1oUcGLWXEKN6WPewwURuStOUFlxJvUQ1b3c83L0ezX1RBkYvG+GO1502E+4k1y/PL9bpEfoUEfk7zZpDk6a66pZZWbqcZEG1nognmYjI0+arr76iYcOG2NnZcejQIebOnav3SBN5ctRpFUpwWGOunIklLzMLSztbfEMCn6knmYjIfwGr+r2wrNtdVwUzJxm5tQtm/mHPhSeZiMiDEA1lLygXj907QW1otx5PTxGRJ8aeGEi8HS7paAWO1nDxhi6fmbkxZN1V7NTcWOd9BuUV1tQIgu7P28IEJAL8eFBndKv+ZPJmvvAUlxaSmRJP2E89Mc9wIaX6LaTSeABqH3Im5NeXSJIXEx68iwj/60i0ChAEUnKSAJCVyFCZ6BLqagUt1zOucT3jGtL/SXFeXA2TfAd+GxJOkbkxzdYWYJ1hjGmuGVLNnYcFqVqKw09OsAdYAdQE4oHShzyJteD2ugcvfzgYQSNB86UGWcM7t3lf5xr4Oj9+TgURkaeCVArBIc9aCxGRKicuLo6PPvqIrKwsPDw8GDduHJMnT37Wav0nkEil+Ner/azVEBH5zyFIpJjXbPWs1RAReWREQ9kLSs3GTfhzy6ZK9ymeUK4LkaeL/PZfpyCATAqlSth1WteWVQCmRlBaBjIZONvAleRyeYHC7H2YWrVCkMhJvl3vQVWazO9HbvBy25rYiCHPFbj5w1c0OBOLRK4B/odpjhaJSoNGJqHmgWbItBI8y8z4UZbBFSMTlIIuLFNWKqP9l92wuWVLfN0raOQalAolgfuCCfm9HoVWhVilWXO1YUcyXY4AcLRvAgV257G9YU+Hpd2Qleg+bK1Eq6umWQJ8DZRXgx8A7AByACMMDWctgDygI2AMvATSJTJwA0kNMQ2liIiIyPPC559/zueff/6s1RARERERERF5AKKh7AXFKzCIhh06cXzndn1bjYaN8KtbD+9a4orZv4F2daGaHThYga0FJP2taFPRbWOJWqkzkkklujxmAAoTPxDu/HlrNMUUZm6mEDU/7rzKW/3EYg9/x2/7n8iUKlDtQ61og1Qr0HX5UXIdwSS/M2CBWqrGxMIGpbHO1U9WKsE20R67JHsAXC/YYVJsh0aiocy4DHmpAus0BaUmJThe88A4/zSlpqWUmOk+vCz3DIqHF2GxSGe4lA6U6oxkbYGTtxWTAu2BMehygpUAXwAFQBeg1d9OZMjtdktAzKEvIiIiIiIiIiIiIiLySIiGsheQstISrsTEGBjJAOq3aUdgk6b3OErkRcNYDvWq39l2sgYrU8gtMjSKldO4Bhy7CGotyI29DHdq9f+jTPmgxGb/TWRmVpCTiVZSgpRUzLJCUZW8jFXu52hthpHg1ZNjXUyoccwKRZERSuMyAvYHkVLtGMgugcqXbNNNGJs0RihKRi6UAV1I90xl9/DfaL28A70+GkhGtXSOvHIFleV13G09sWhqqTNoyYAe3KlFXBeoBdgD5fnlzG7/TH/AydhX9dURERERERERERERERH5byAayl4w8rIyWfLeKApzcyvsy0y+9Qw0EnlayKQwtJ3u35l5cOEGJGdBUpauTa2BGu4Qm1jxWInUBFPbLhTn7CM7L48/TkTTskGjioL/VW4B/m9B9GwESRGY/oK2rCn55g1Bs5KkBruwLj6Meb43ZebZ9FrfA3WyIyZZJmwOyeWm80jcSqVkyRrj2r4Jxb/vJlmp4mQbGSUtbqCVaEnxv4VGquFov4O81L4L5sZhd8bvV4lOAiDavUVERERERERERERERJ4qYgKbF4yEv85XaiSTyGQ0bN/xGWgk8iyws9Ql5U/Pu9MWfRmyK1RC1HmRadRFaNR5SGS6EL9Dp0/fTvovAsCo3XDoe7RaU1QyKbGNzfhz0F5s0uywyXBFur89b+XZ4m1Tl4a1BiGNr4ZGoUFjpcH9ug916kFR7kJqJU+HVTXIMhuNc8lHdN7rhVWKNTZJdvgc9yOzRTq1m9bF3FisTCsiIiIiIiIiIiIiIvI8InqUvWC41ai8Yp2puTnGpqZPWRuRZ8mZeChT3dnWaiElx1BGQEALFGb+ikaVDoIcU/v+FGdtpaCoCAszs6ep8vNL8ddo5QXs6decZB8nzC5bUByTTG1yscaKuLIzaGOvMikukaU1g3ArssesSIYGDfXxZ9vBz0HtqetLKMI1zhUBCVCTrOUF1HvNBul8BbVr1X2mpykiIiIiIiIiIiIiIiJyf0RD2QtCVmoKG+Z8SlpiJXF16Mpe52VlYmlr95Q1E3lWeDnCpZvlPmM6fJzgaspdMk4QnwpaTaGuQaukKHMTVpaemJmYPFV9n2uCAim+fpZkHycAlNXKaP31S0y0nIi/pBp/2anx9R5I0rm9/OV3DpfT1RA0AhKtzim3UXYAEvIABWjNbxvJQC2o0bazJfg1n2d1ZiIiIiIiIiIiIiIiIiKPgBh6+ZyjVqm4GH2MAxt/4dbVK6iUZZXK5WVmsu7Tj5+ydiLPkpruuuT+5cil0LUxvNYaGvqBpSlIJLrE/0bm9e8IasvIy7uKRqOp2Ol/lC9C7ck0ssL+RiFoocahQKwkVnxdPJ+RMil1+32Id5NehL42ndSGSewZvkNvJAOQIAGs0N1SpQBo0ZLer5ihk0QjmYiIyL+D/fv3IwgCOTk5z1oVERERERGRR2bVqlVYW1s/azUeyJAhQ+jRo8d9ZVq1asWYMWOeij7/RURD2XPOlqVL+OHjWZzau+eBsmqxmuF/Cq0WcorubKvUut+2FrpE/3lFcDUZmtQAhVkwEpmDTkAwQiJzQhCEp6/0c0qLzadxz0yl09qdhG5QoChWYKYxRaI0R1bQEeF2PjcHezu6xPam7ZaOOruYAeXXU3t7S8B5qPlTOwcREZHHJyUlhZEjR+Lj44ORkRHu7u507dqVqKgovYyXlxeCICAIAiYmJnh5edGvXz/27t17z34zMzNxc3OrUuNSq1at9HpU9tOqVasqGacyQkNDSU5Oxsqqwg1QRETkb9z9ovswL72nT5+mb9++ODk5YWxsjJ+fH2+++SaXL19+8sqKiPxLGDJkiH4+VCgU+Pr6MnPmTFQq1YMP/g+TkJCAIAjExMQ8ltzGjRtp3bo1NjY2mJiYUKNGDV5//XVOnz6tl6nMSHnhwgXc3d3p27cvZWVl+r5atWqFlZUV5ubmBAcHM3PmTLKysqriVB8a0VD2nJNxKwkAzQP+uO1cXOg/ftLTUEnkOUEQoI737X8DDfzv7PN01P22tQCpFARBwMKxP+b2/bBwegUzu66k5kqfus7PK3ZWNXX/0EowUrlh9JoJOACCFqnjeXoWR9HYH7oGq7D91hZpkhQq1tTQ4XzbYOZFJcY0ERGRB6HWqNmfGMP62Cj2J8ag1qif6HgJCQnUr1+fvXv3MnfuXM6dO8fOnTsJDw9nxIgRBrIzZ84kOTmZS5cusWbNGqytrWnbti2zZ8+utO9hw4YRHBz8QB2mT5/OkCFDHkrfyMhIkpOTSU5OJjo6GoA9e/bo2yIjIx+qn8dBoVDg7OwsLrSIvHCo1WoOn9nP5r3rOXxmP2r1k72vPCrbtm2jSZMmlJaWsnbtWi5cuMAPP/yAlZUVU6dOfdbqiYg8NlotFCuhoEz3+2nUEuvQoQPJycnExcUxbtw4pk+fzty5c5/8wP9RJk2aRP/+/alTpw5bt27l0qVLrFu3Dh8fHyZPnnzP444fP05YWBgdOnTgxx9/RKFQ8OGHH9K/f38aNmzIjh07OH/+PPPnz+fMmTN8//33T/GsREPZc0/jjp0eSs7Szp7S4uInrI3I80arYBj2EthbQVwSpN823rStowvBHNgSgr2gtheAFqnCEYnEBEGiIDtX/L6Uqco4GX+M3Lfao3WchsZlEe7ObfEd5g91gN8F2Pgabq90omkAWM+dDNK4ih3VBVoCC4FIYNXtHzELpIjIIxF5+QBeywYSvmEsA7fNJnzDWLyWDSTy8oEnNuY777yDIAhER0fTu3dv/P39CQoKYuzYsRw9etRA1sLCAmdnZzw8PGjRogXffPMNU6dOJSIigkuXLhnILl26lJycHMaPH1+l+tra2uLs7IyzszMODjpPYTs7O32bra1tpceVe7TMmzcPFxcX7OzsGDFiBMq7vNG///57GjRooD/PgQMHkpaWpt9/d+hlXl4eJiYm7Nixw2CcTZs2YWFhQVGRzuX5xo0b9OvXD2tra2xtbenevTsJCQlVek1ERO7H9oORNHnFi37jw3n3k4H0Gx9Ok1e82H7wyRmVH4WioiKGDh1Kp06d2Lp1K23btsXb25vGjRszb948li1b9qxVFBF5LArLIDEPkgshrUj3OzFP1/4kMTIywtnZGU9PT95++23atm3L1q1bK5W9evUq3bt3x8nJCXNzcxo2bMiePYaRXF999RV+fn4YGxvj5OREnz599PtatWrFyJEjGTNmDDY2Njg5ObF8+XIKCwsZOnQoFhYW+Pr6GsyVarWaYcOG4e3trfe+WrRoUaX6zZgxAwcHBywtLXnrrbf0XleV8aA5PDs7m0GDBuHg4ICJiQl+fn6sXLkSAG9vnfdF3bp1H8k7/ejRo8yZM4cFCxawYMECwsLC8PDwoH79+kyZMqXCM0I5e/fupXXr1gwbNozly5cjkUiIjo7m448/Zv78+cydO5fQ0FC8vLxo164dGzduZPDgwQ+lU1UhGsqeU5RlZdy4dJFq1f0eSj7+/Dkiv1j4ZJUSeS65dFNnIMsphPPXdW2CoPMmk0l1P21CIMglDlVZuv646DjRI+DktaP8dfMMsqVGCOdDkZzzh/L7+W7A6C5htRr+Og82Y8F4G9hpuWiax9S6ZzkyPgPmAc0AORAEiAVFRUQeicjLB+izeTo389MN2pPy0+mzefoTMZZlZWWxc+dORowYgVklVYAfJo/J6NGj0Wq1bNmyRd8WGxvLzJkzWbNmDRLJ8/OotW/fPq5evcq+fftYvXo1q1atYtWqVfr9SqWSWbNmcebMGTZv3kxCQsI9Pd0sLS3p0qUL69atM2hfu3YtPXr0wNTUFKVSSfv27bGwsODgwYMcOnQIc3NzOnTocN+HfRGRqmL7wUiGz+xDcsZNg/aUjCSGz+zzXBjLdu3aRUZGBhMnTqx0/4uQT0lE5O8UlkFqEaj/5kGm1uran7Sx7G5MTEzuOecUFBTQqVMnoqKiOH36NB06dKBr164k3i6gd+LECUaNGsXMmTO5dOkSO3fupEWLFgZ9rF69Gnt7e6Kjoxk5ciRvv/02ffv2JTQ0lFOnTvHSSy/x6quv6heQNBoNbm5u/Pzzz8TGxhIREcEHH3zATz/9ZNBvVFQUFy5cYP/+/axfv57IyEhmzJhxz/N80Bw+depUYmNj2bFjBxcuXGDp0qXY29sDVPBQf1jv9PXr12Nubs4777xT6f7KPNA3bdpE586dmTJlCp999pm+fe3atfft62nfC0V/h+cQtVrNF6PfJSv5Fnau1TC3tKAgL/+e8oJEglajwfIeq8gi/z6Ss8DMGOJPH+PM3j8xEUwp8+uHl9O9q576VjPl9NVsUOg8EPILcwHjp6Tx80eJsoT49CsAKEoUusa7J3MJkA543N6WSlH3exvJtniETjK4KNBJvp94bSGfr7hEyqwemBvJn+IZwI3rSaz6+gfSUtJJTkrF3MKMcVNHUrtO0FPVQ0Tkn6LWqBkdtYTKIjK06MLLx0QtobtvM6SSqgsbv3LlClqtlpo1az52H7a2tjg6Ouq9pEpLSxkwYABz587Fw8ODa9euVZG2/xwbGxu+/PJLpFIpNWvWpHPnzkRFRfHmm28C8Prrr+tlfXx8WLx4MQ0bNqSgoABz84o5FwcNGqR/+Dc1NSUvL4/ffvuNTZs2AfDjjz+i0WhYsWKF/mF55cqVWFtbs3//fl566aWncNYi/1XUajXTvhqNtpI7ixYtAgLTl46hfWh3pNJnl44iLk7nqf5P7kMiIs8TWi1kPCBwJaMYTOW6xf0np4eWqKgodu3axciRIyuVCQkJISQkRL89a9YsNm3axNatW3n33XdJTEzEzMyMLl26YGFhgaenJ3Xr1q3Qx5QpUwCYPHkyn376Kfb29vq5NSIigqVLl3L27FmaNGmCXC43MHh5e3tz5MgRfvrpJ/r166dvVygUfPfdd5iamhIUFMTMmTOZMGECs2bNqnQR7kFzeGJiInXr1qVBgwaALvdqOX/3UH9YLl++jI+PDzLZHbPSggULiIiI0G8nJSXpc5sWFBTQt29fPvjgAyZNMkwbFRcXh4+PD3L5032fuhfPzzKniJ6jv/1KVvItADJvJVGQX3BfeVef6vQaOYb+E95/GuqJPGOiL8GPB2HNXjj251+olUqEslxMLn2HcfGNex7nXc0NTfFpivMOU5i1C+3TSBLwHFNQkodKczv3nwk6T7C70QDJdzav3Yij+IfWCPFjUG9rB9GFumQL6B64n/blPHfqPO8OGcvRg8e5FpdAcVEx6akZvP/uNI4fOf3gDkREniMO3jxXwZPsbrTAjfx0Dt48V6XjVtV9UKvV6g1BkydPJiAggFdeeeWe8gcPHsTc3Fz/8/HHH+tXUst/1q5dWyW63U1QUJCBQcDFxcUgLOPkyZN07doVDw8PLCwsaNmyJYB+Zf3vdOrUCblcrg9p2bhxI5aWlrRt2xaAM2fOcOXKFSwsLPTnZWtrS0lJCVevXq3y8xMRuZtj5w9W8CS7Gy1abqXf4Nj5g09Rq0r0+I8/j4n8+yhRVfQk+ztqrU7uSbBt2zbMzc0xNjamY8eO9O/fn+nTp1cqW1BQwPjx4wkICMDa2hpzc3MuXLign/fatWuHp6cnPj4+vPrqq6xdu1bvGVbO3blIpVIpdnZ21K5dW9/m5OQEYDDfLlmyhPr16+Pg4IC5uTnffPNNhbk2JCQEU1NT/XbTpk0pKCjgxo3K3/ceNIe//fbbbNiwgTp16jBx4kQOHz583+v4uLz++uvExMSwbNkyCgsLDe5xJiYmtGvXjuXLl3PhwgWD4x7mXpiYmFjh+elJIRrKnkO0Gs3fGir50ggCtZuH0ax7TwZMmky9Nm0xvusPSeTfS2qO7rdKDVYeNfTtGpWas4ePUVxQSMr1m2g1Fb83Teu1Rq3MRGbkgUTm+JQ0fs4ogew52eTPycPF2I0aVwPxPuwLdxeNdQBeAxrdaUpMTMA82wIASVYZ2IxgbVokzctUrM1ritmPMnhKuYEzM7L4cOwsVMrKB5w3YyFqtVp8+BZ5YUguyKxSuYfFz88PQRC4ePHiY/eRmZlJenq6Pr/H3r17+fnnn5HJZMhkMtq0aQOAvb0906ZNA6BBgwbExMTof9566y26detm0NatW7d/foJ/4++rtIIgoLn9zFFYWEj79u2xtLRk7dq1HD9+XO8Zdq+QFYVCQZ8+ffThl+vWraN///76leWCggLq169vcF4xMTFcvnyZgQMHVvn5iYjcTVpm8oOFHkHuSeHvr6vG9E/uQyIizxMPMpI9qtyjEh4eTkxMDHFxcRQXF7N69epK0ysAjB8/nk2bNvHxxx9z8OBBYmJiqF27tn7es7Cw4NSpU6xfvx4XFxciIiIICQkxqGRd2dx6d1v5Qlr5fLthwwbGjx/PsGHD+P3334mJiWHo0KH/KCXBw8zhHTt25Pr167z33nvcunWLNm3a/OM8qn5+fly7ds0g36m1tTW+vr5Uq1atgrxUKmXz5s3Uq1eP8PBwA2OZv79/hb7+jqura4XnpyeFGHr5HJB05Qo/zvsMEwtzXv0wgqZdurF77Q+olZX/sTi4ezBy4RdInqGbuMizo0lNKC4DKzNoExzKlTPmHNq+G7VShZO7Gz8v+ZaSwiICGtQhrFsHg2MvXdmPujQVdVkScmNPcgtNsfqP5dLS/qTF5mcbbLAhW5JF3fMN7+w0BgYBfwL+6OK9buPp78PBvnuIlWzBqFRFaL6EndYhdD1Wnx433eEkYAd0ebL6Z2dm8+e+I6hV97bKFRQUMvGdqVy5dI2atfyZNX8KCiPFk1VMROQf4GJ+77Dxx5F7WGxtbWnfvj1Llixh1KhRFR6kc3JyHpgTY9GiRUgkEnr06AHovKqK7yquc/z4cV5//XUOHjxI9erVAd2Kqq+vr4EeeXl5Bm1Pm4sXL5KZmcmnn36Ku7s7oMvN8iAGDRpEu3bt+Ouvv9i7dy8fffSRfl+9evX48ccfcXR0xNLS8onpLiJSGY52LlUq96R46aWXsLe3Z86cOfoX27t5mPuQiMjzhPQhwykfVu5RMTMze+j59NChQwwZMoSePXsCugWevxeckclktG3blrZt2zJt2jSsra3Zu3cvvXr1eiz9Dh06RGhoqEEursq8rM+cOUNxcTEmJiaALnG+ubm5fo6+m4edwx0cHBg8eDCDBw8mLCyMCRMmMG/ePBQK3XvCo1YEHjBgAF988QVfffUVo0ePfqhjjIyMiIyMpE+fPoSHh7N3714CAwMZOHAgixcvvmdf5ffCp/WsJBrKngOO7fiNrJRkSIFv3p9AaVHxPY1kLw0eSvNuPUQj2X8YByvoF1a+JVCzfgjegTUoKy2luLCI6N37AUi7eavCsXnlmTO1KgoyNqFW9wX+WwYUraUuLwlAmUmpLuzyNqU2aoy+vf23NRNIQpen7H/g7VCdwy+vZkfSEtw1jZBoXqc6kKlNhJuBumPu6utJcPiPY8z+8OHKW1+5dA2VSsX5mFjmzlyEvYMdYa1DCQwWc6CIPH+EudXGzcKBpPz0SvOUCYCbhQNhbrUr2fvPWLJkCc2aNaNRo0bMnDmT4OBgVCoVu3fvZunSpQarnfn5+aSkpKBUKomPj+eHH35gxYoVfPLJJ/oHt3JjWDkZGRkA+rCO5xUPDw8UCgVffPEFb731FufPn2fWrFkPPK5FixY4OzszaNAgfaW+cgYNGsTcuXPp3r07M2fOxM3NjevXrxMZGcnEiRNxc3N7kqck8h+nca0wXOzdSMlIqjRPmYCAi4MbjWuFVXJ01ZObm0tMTIxBm52dHe7u7qxYsYK+ffvSrVs3Ro0aha+vLxkZGfz0008kJiayYcOGp6KjiEhVYCzTGcHu5zEmFXRyzxo/Pz8iIyPp2rUrgiAwdepUvecX6MI4r127RosWLbCxsWH79u1oNBpq1Khxn14fPOaaNWvYtWsX3t7efP/99xw/flzvmV5OWVkZw4YNY8qUKSQkJDBt2jTefffdSvOTPcwcHhERQf369QkKCqK0tJRt27YREBAAgKOjIyYmJuzcuRM3NzeMjY31ecXuR9OmTRk3bhzjxo3j+vXr9OrVC3d3d5KTk/n2228RBKFSfY2MjNi4cSN9+/bVG8saN27MxIkTGTduHElJSfTs2RNXV1euXLnC119/TfPmzR/aGFcViKGXzwE16jdAIpEgUyjISkmhMC+3UjkXb2+ad+8pGslEKmBkYoyFtRUOrs7UatIAB1dnGrdvXUHOw7M9CLpSjlp1NgdOxfznwvPUXdT8+do+DrwaRVzjixRlFcI0yLApxShZeud6qBNgKfALsKAEAJfc6kz4bgMtT72q789HbcxNWSEaiRZaPjm9NRoNSz9f8VCyEolgUGXm8B/H2PrLdqaO++iRV4pERJ4GUomURW1GAAaOnAbbC9uMqNJE/uX4+Phw6tQpwsPDGTduHLVq1aJdu3ZERUWxdOlSA9mIiAhcXFzw9fXl1VdfJTc3l6ioqAoJaV9EHBwcWLVqFT///DOBgYF8+umnzJs374HHCYLAgAEDOHPmDIMGDTLYZ2pqyoEDB/Dw8KBXr14EBAQwbNgwSkpKRA8zkSeOVCplxjuLAPQLZOWUb09/e+FTS+S/f/9+6tata/BTntC7e/fuHD58GLlczsCBA6lZsyYDBgwgNzfXwEtTRORFQBDA/gGLx/YmTzaR/8OyYMECbGxsCA0NpWvXrrRv35569erp91tbWxMZGUnr1q0JCAjg66+/Zv369QQFPX7hrOHDh9OrVy/69+9P48aNyczMrLTSY5s2bfDz86NFixb079+fbt263TPX2sPM4QqFgsmTJxMcHEyLFi2QSqV6I7xMJmPx4sUsW7YMV1dXunfv/tDnM2/ePNatW8fp06fp0qULfn5+9O3bF41Gw5EjR+453ysUCn755RdCQ0MJDw/n/PnzfPbZZ6xbt45jx47Rvn17goKCGDt2LMHBwQwePPihdaoKBO0zeEvOy8vDysqK3Nxc8UHpNgU52Zzc8zu7f/i+0v12Lq6M/nKpaCQT+Udk5MG63/8iO/0AErkdGmUG3cPDqVMz4Fmr9tQ4GX+Uv26e1W832RGG/8cBJDUtoprqrjx/LusheYDu3xYlsNaYrHml2B4wQiPR8NfMsxQeKaHB7w2QKWW6Clq/C2DzZPSO2rGfBbO/1G9r0SJTyFCXPbzhy9jEmJ93ral0ZUdE5GF40vN35OUDjI5aYpDY393CgYVtRtDLv8V9jhQRERGpnO0HI5n21WiDxP6uDu5Mf3shncIeL3RKRETkwRSW6apb3u1ZJr1tRDP7bwW0iLyAPAcOj88/l0+dIj87k5AWrZDJ5ZSVlHDr6hVKi4u5du4sdcPb4OzlhVqlQqvVIrudvC8rJZlv3p+ASqnk1SnT8AwIvOcYxYWFHNxcMS9BOUZmpqKRTOQfY28Jo/oEsfa3RK4k6mLhc/Lzn7FWT4EyYAxwGpz6uPJXI52hTFFshOtAXehP/gglRxZkcNEij74/uGN+wxMm7YWS1pBvDMsh6mIqffFAqxEIWBGM5jrItDqjk4DA0jHfUhpXirJBGeMWjqpSg9TfVzQEhIc2kpV7mJUUl/DxlHlM+XhileklIlKV9PJvQXffZhy8eY7kgkxczO0Ic6v9RDzJRERE/ht0CutF+9DuHDt/kLTMZBztXGhcK+ypeZKJiPxXMVOAqfxOFczycMvnwZNMRORBiB5lDyBy8UJO7d0DgLmpCTVDm3MjLo7U6wl6GTNLK16fNZuvJ4xDrVbR973x1G4exg+zZ3Hx+DEAXLx9GPH54gr9lxYXs3pGBIkXL1TYV46tswsjFizCSKxqKVIV7L/E8sO/c8tGN0vZ29gw4uVBDzjoBeddQPeniNZey7llp5HLFNR0CTIIUazAgRKYaAQIoAG0sN4ugW+cr7L7ihkJ0hM4l7ZHIsg4I/0Nv9IB2GPHDeEmyxt+Ta+h/ajTIPje/T8Ck0ZEcP5M7GMd++mXM/hw9AzUal3OhZ93rcHU7DHuJ1otFJWCkRxk4gvGf5EXaf4WEREREREREREReRxEj7JKKCks5GbcZSQymd5IBlBQVMyJPbsryBfm53Ho1y0oy0oB+P371dRuHoZXYJDeUFbNz8/gmPysLOJOn0Iil9/XSFa7eQv6jxe9P55XcjKyMDEzxcjE+Fmr8nBkFcL4n6jW2JhbNrrkAdUcHCkpg4ISncfZv5JTd/4ptBEI9qh3b9m7aWEMm4GDwBxdUyBWzMkOYbfxG3xZIkOQ7aOHvQVRGlvWJOsuoL3WlveunGD+uPNkvj+GNh1b/eNTiL96/bGPff/daZiamlBSUkKrdmGPZyQDSM2BgmKQCODpCOJqvIiIiIiIiIiIiIjIvwzRUPY3tFotyydPJDXx3i+lcmNjVGVlaG9XxBAEgeohdTh124jm7OWNRq0moElTbJydUZaWUqdVuP74q2fPsGr6VLQaDXIjo/vqU6tZ8yo4q/82GrUGifTBIXDXzl8kIzmVWk0bYGpupjtWoyErNQ0rW1tys7LZvWET+dk5aKXGCGjQarWYGMvo/c7rmFlaPOlT+efIpWAko8PhIpyURuxsaMnlG7kk79FQqpTQyB9C/03pykqBtwElYA50BcY+Yh/OQE9gOZANIZk28Bl885kJoESLwHi3luRKjTBnC2MyGiNXZ+EsGPOReTEXdv0KVWAoa9qiEXu270OLlhJBi1wrIKuQ9vzeFBUV89WaBXj6eDzawEoVpGSDWgNaDQU3Mjn8/k9IzRQ0/m445p4OOjnRj15ERERERERERERE5F+AaCj7G2qVirSbN+4royzRVcAzt7GhMC8PGwcHflkwDzNra1r26kujjp3YMPdTYo8eoZqfP+0HD0Wj0VCQnUVZSSlrZk3XG9mUpaX3HSuwSdOqObF/MaXFJWSlplOYl0/0nv3YuThhbWdLbPRp5EYKivILMLUwo1XPLphZWmBsbsqVmL8wNjPBL6QWABnJKez5aTMAmSmpmJiZEnc2FtCi1WhRmBhTVlyiH1NQ6/4tACVFSjJT0l4MQ5mFMXw3FMmJBI7l3kKluoVKVYIydSemNh24kS6Bf5Oh7Bpw7va/HXh0I1k5MnRGtjWAE1Afei/5mLQP52FSoOSqWkWuzJgV3mUojFMwT1nAZ9JiALxzM/7hSeh4Y+Rg9u78A41Gg0yr5axZIfUKzZFIJAZlrO9H0o3khzaUlWTkkXUqAROJFhsvB337jahYWn09BJmpEfEbj1Hq78xfS6Oo1qsR1d+oWGlVRERERERERERERETkRULMUVYJJ3bvYvcPayjMzX3kY/3r1afb2yNY+M5wVEqlvt3I1JTSoqKH7sfMyprub48QDWUPQKVU8vOXK8jPzkUilaJRPzi5uSAR0Gq0+n+bWVhQr2UoB7bufOhxteiMZMhNcfdx4aX+PZHKXiy785KNx8hIPwPaMgBMbbvSL9wTT8dnrFhVoAKk6DzJRgBngdHAwH/YbwI6g5vZXW3r4OCKNFrUjqLcwcuktJjN8VsJFkqROrvggArGjCXD1R1zC3OMje/vSVoZSqWSgZ2HUlSkM9Jq0PLGO69x8a/LHP7jGB7ebnh6e3Bw7+F79iFIBL7fvBwbW+v7jqUuLmVHgykU3sikwdQebFVksftsLOM7v4R3Qgne3XShq8VpeRjbW/D7gCVkxN6k47X52Lo4gEoNUonoZfYv5Hmfv0VERERERERERET+KaKh7B6citpN5BeLHutYezcPzCwtuB7712Md7+TpychFSx7r2H8reVk5XL8Yh7t/dWRyGQe37kSr0VJcWERmSuo/7l8QBB72T0EikVC9SXNc/WtR3d0UmfzFMpCVU6KEuavWolFlA6AwDWby4BbctiEieVFtHAeADwA7dOGSjugMZ0/qY0oAhkNX5z/YZnNL32yblcbLyhssydO5tOVbWPHyTQ32jnYsXPHZA41VlRHZ9zX2pOZzXaPLDebs6siXqxfw6dQFnDh66gFH66pfrtz4NfYOdvcWyshFm1OIAJTmFJJUWoTv6MmYGRlR09KWiccEOm0di4mDpT6kOenaTb5qlU6avISB+f6kavK5bJpPT3kwtQWXRz5PkeeXF2H+FhEREREREREREfknvJhv+E+Bem3acSUmhthjRzCztCI3I72CzL08mDJuJvI4wVYKU1O8agbQYegbj3H0v5vIr1dRVlLC8agDyBUKigsLq7T/BxnJHKu50Gnwy0ikEmRyeZWO/awwlkPDoNocO3MAgLKiWA6dr8/ZRJ27VO9QcLR+hgo+Bml5Kch/UWBTagu3gGigC/e+05UA2wF3oOFjDuoF/AZbIlvg8/lWrtctAg0YWznwUcpeyhQyFGUq8suUgJSMtEyuXo6nQZO6jzxU7dAG1Nm1g3EFppQhkHIrjQ2rf+F8zION8m6e1Rg24rUKRjItWtZwisSD5/H94jr5K1rgaGtM9yx3pEZyJAn5/DpxJB3q1EYiCFz5+Rgrpy6Db9rS0tSH2kU2ZAWZkarQhaz/Ib/BTRNd2OnP2nPURjSUiYiIiIiIiIiIiIi8OIgeZY9Afk42B3/5mcunTlInvDWp1xM49+fBKuu/ZZ9+tHvltSrr70Um6VoCe37cjIm5GR5+1Tl7OPqp62Bpa01RQSE+gTVo1avLUx//aTF/zToKCrMAMLfvh1Shi71s7A9NX5R8ZdGgfV9LrlkO58JPE/pLC6QOMliBLlTyXnwMbEIXMrkKCPwHOvSBvOtlvGx5GKmNwIrkmtzoNZ8rwR4YFZViJXdh+ZLdSKVSpjTxo2bqDejZC1o9Wl4v1dGjLPwukn2x1yrsk0qlNG3RiPMxseRkG4aO+wX6UuTsQA1/b8a90kvXqNGQk5vFGsUZ6PUrycN9SO9VDYDmO+Xc/PUCYTnGtJzRV9+PVqtlpMdRSoxApobFCY1IORFP1IdrIauEG1vDsQ1xp3OOOyaCHGdnD5Ddro6p1ujCMo3+Hcbm/yIv6vwtIiIiIiIiIiIi8rCIHmWPgIW1DZ3e+B+dbm8ry8rwCqrFn1s2kZue/lD5se7OVRbSKpyeI0ZRVlpKYW4ODtXcnqD2LxanDxyhtLiE0uISctIzn8qYxmamlBTeySNXvVYgDdu2eCpjP0tC67UmKjoamcIFQWqOXKpCJpXh6/qsNXsEtoCQL2Cdb4NUI2Xr5xvp2bj/g4/Lu/1bC+T/Qx3agOV3CrbntdL3G1kciJlxGWXGCjzc62NschBZeho1D+3VCcybA3XqgbX1Qw8ja9IE72upBoYyt0wBq0KBkPFdUdiacejYcf2+8nx6cbFX0P4VR+SOfWjWRPP6mH7Y1fHEuqiMd6nJtz3jsCpUkw6YL7rI4Y9Os8uhhH1SM7ZldsDETlesQhAEzDVySlAiSS9he6f5mDtbI7+aj7W/M6/YhSNPvWMIU6ZkILe1AoUcbqTrjGU25mAnGllERER0bN68mfHjxxMfH8/IkSNZuHDhs1ZJRERERETkmTFkyBBycnLYvHlzlfft5eXFmDFjGDNmzD1lBEFg06ZN9OjRo8rHf1GQPGsFXmTkCgWNO3Zm3NcrmLlxCxEbfuGtOfOZuv5n+o+fRO2wMFr1fZmBk6fyxsef8coHUxn79Qq6Dn+H1yJm0HfMOGRyOabm5qKR7C6unrvArWvXn/q4zu7VeGXiSMJ7daFVry7UD2/+1HV4FjSt5YyzrTVadREFGT9TmLaS/3UAB6v7H5eUCXvPwI2qKer48OwC+gNTgZO3fysAGaht1Vi2sCK89ksP19c4oDfwHtD4H+r1Nqg+V5Fjm0OhZSH5AaVMSjHj0wMmzNxnypoT+UwdMYxvvlkIzcJ1x2i1kJ93324B8q+l8kevBexsGkHS9tM42NrrLGCAsURG2EU5wTdkVDuQzq2bKcj8bPTH3p1qThAE6kkVXLlylSPj1lKcqPvwJAi0q9WYN2wbEzr8Ag3GxtIiQ8Hb8WZcMSrBc/wHvDJzsb6fsTdrUvO9c9Rpvp+Cy2nEyrMpczTCOsQN+e3Q5HJnZXmJGu2tLEjK0BnJAIrLHu8ai4g8IVJSUhg5ciQ+Pj4YGRnh7u5O165diYqK0st4eXkhCAKCIGBiYoKXlxf9+vVj7969Ffo7fvw4bdq0wdraGhsbG9q3b8+ZM2eqRNchQ4bo9ajsx8vL657HlpWVMWfOHEJCQjA1NcXe3p5mzZqxcuVKlLcLEN3dv1wux8nJiXbt2vHdd9/ds8KuVqulY8eOCIJQ4aE+KiqK0NBQLCwscHZ2ZtKkSahUKgOZ4cOH06dPH27cuMGsWbP+0fUREXleGDJkiP4l8+5/34vTp0/Tt29fnJycMDY2xs/PjzfffJPLly/rZUaNGkX9+vUxMjKiTp06T055EZEXmLvnMYVCga+vLzNnzqww9zwPJCQkIAgCMTExz1qVJ8aqVauwfgSngOcF0VBWhSiMjXHzr4GRiQm1m4fRf9wk2g56hcDGjfEKDKJmo8aYWVrSuGMn/OvVf9bqPrekJN584mPYOVWMx/MNCcLU3Ay/OrXwr1NLn6j8v0BtHyvKis6hVedTUlb2wGKFWi1sOQpnE2Dr0Tv2jyeCCvgN2AP0QmcYuwbsBN66/Xsb8AlIt0mp1agO1qY29+rNEAfgfQyqYe6LPs3qNz8nYXM0aLTkXkgiMTIajfLBk2tk/FYGFb5Bv9LBDKxdD0t7FRfSZdxIVVH0RxQ+7q4IUilpjVpyXS1QbGUD7h5Er97FslZ9WdP9TcrSstBcucXVRdvZ0WQqKfv+YkvjCG5sOkHG0SscGfYNO7fvAQGKNRqytTq9tGg5tecEGX9mYD26Phbv1MG4iw9/j61vel2Oe74EbX1nilJy2Ca9xiT7YyxrmMSvYUXUD6yGRKH77pvYmiG0cCGjuJgd169SWKDLPZYasw+rzN+RNHDGal0P2gx8CdXHplxodg61Ro26TMWZ7/bxl0kOeVIloAXlbY9bQQBbi4f7fET+k6g1GvbHpbL+ZAL741JR38M4U1UkJCRQv3599u7dy9y5czl37hw7d+4kPDycESNGGMjOnDmT5ORkLl26xJo1a7C2tqZt27bMnj1bL1NQUECHDh3w8PDg2LFj/Pnnn1hYWNC+fXu9MervrFq1ilatWj2UvosWLSI5OVn/A7By5Ur99vHjxys9rqysjPbt2/Ppp5/yv//9j8OHDxMdHc2IESP44osv+OuvO7kOO3ToQHJyMgkJCezYsYPw8HBGjx5Nly5dKn3RWLhwIUIlE8eZM2fo1KkTHTp04PTp0/z4449s3bqV999/3+B6paWl0b59e1xdXbGwqHh/eJTrIyJSGWqtmnO5+zmQsZ5zuftRax8cBfI02bZtG02aNKG0tJS1a9dy4cIFfvjhB6ysrJg6daqB7Ouvv07//g/hNS8i8hygVqvZv/8k69fvYv/+k6gfIgKrKiifx+Li4hg3bhzTp09n7ty5FeTKyp7c4u295vwnxZM8l/8iYuilyHOH8BTKLXb/32sUFRRy/WIcLp7umFtbYWxq8sTHfV7x9/Jm5yFdvj2tVotGo0EiubehUBBAIYMyFchlPNCw9o9YAvzwEHJ2wCOkvsotLKRUpeTiyVg+//JbUm0VBPdqhfXI7TillxJ59jL8+h5l5xJxPdUU/6HtaLL8zXv2d/DUOVZt3Y/NLS11suVcDJYzcuQ2ftz2KnnHj5CZEUdcfEuqe7rx8x/H2F5gzrsDeuP+yRau//EDw83yQJXHuRWrqN3vZap3rkP0pA0seWUuv9nlEmhpTIdrAtYBrmSlpQFgIpFwuKSEwjHNSTp5kZOaDMiIwTbfHvOBAWiVGlL33cCqUAlaUKggwV6NT5qUWsPDMXd1YrN3ef6/UtKN0rFrY01c/d9o5TkBk2B7/BrncfPwTUoFJZ9l7KHeJ8dJOHecbL84bm0ex4L4Blho5PiX1eTsqS1IJVJQQPzrbvzhHIdcI2FmekNMirWg1aKxNSf1SBwmPhakpBzFysEbF99GhhezPHWmIBC3Yh9ZJ68RNKkb5l73Szgn8m8g8swNRm86yc2cYn2bm7UJi3rWp1eI+xMZ85133kEQBKKjozEzM9O3BwUF8frrrxvIlntFAXh4eNCiRQtcXFyIiIigT58+1KhRg4sXL5KVlcXMmTNxd9fpPG3aNIKDg7l+/Tq+vr7/SF8rKyusrAxdfq2trfV63YuFCxdy4MABTpw4Qd26d4qJ+Pj40LdvX4MHbCMjI31/1apVo169ejRp0oQ2bdqwatUq3njjTtGhmJgY5s+fz4kTJ3BxMSze8eOPPxIcHExERAQAvr6+zJkzh379+jFt2jROnjxJeLjOw7Z1a12+xn379olGMZEq5UhmJCsSxpBZdmch1k7hxhteC2lq1+sZaqajqKiIoUOH0qlTJzZt2qRv9/b2pnHjxuTk5OjbFi/WeXenp6dz9uzZp62qiMgjERm5j9Gj53PzZpq+zc3NkUWLxtGrV/gTHfvueeztt99m06ZNbN26lUuXLpGTk0PDhg1ZsmQJRkZGxMfHc+7cOUaPHs2RI0cwNTWld+/eLFiwAHNzc32fK1asYP78+cTHx+Pl5cWoUaN45513AN2im7e3Nxs2bOCrr77i2LFjzJ8/n8mTJ/Pdd9/Rp08ffT+bN29m0KBBpKSk4O3tDaCfl1u2bMn+/fv1svPmzWP+/PmUlZXx8ssvs3DhQn30hpeXF8OGDSMuLo7NmzfTq1cvVq1axcaNG4mIiODKlSu4uLgwcuRIxo0bZ3B98vPzGTBgAFu3bsXa2poPPvigwuLg3UyaNIlNmzZx8+ZNnJ2dGTRoEBEREXpdzpw5w5gxYzhx4gSCIODn58eyZcsoKChg6NChAPoFtWnTpjF9+vRH/kyfNv8dlxmRFwafwJrIFHIkUukT6b96rQBkcjmWNtbUbtoQe1fn/7SRDKC0rNRge0/0OQ6ch7Scex/TpxmEBel+V4lt8151RbLuIX+3mb8zUPvhhzrxxyk2OA5ni+MIlk/+Evez+fTYmE3MqiiSLUrZE6xir00O56cMJieojHzHm2Qev4ZWqyUxJY2wYeNp+eYEktJ0oYsFydlsD59FnV3JHDAuwSlHwH9XDdavsSNAG0vfAQGUKZWMnjGXOiNGsH3vQYykMmo2qc+JDzYQ42bK6duLTmnqDN6dNoeg4eMZFpDBUrt0YsxLWWeTi+PHXQn/eij+nrqXb5VWS6lWy4G0m1wUbifvlwmcnRBFzPLTOL0RzeCIQSikchBAJYUMK4j2U7O01g0iE04hS7yTl0+qFfijhpSst9txM/osRe/vo+WBYiZ92JkxqwZhvOsWBT8VoQl6icKRU9AKUCzRrQyWlhZy9tRW1GrdifQU/Jl4M4hseRnFpcX6z/f01F+IavsxOxtFEB+9izN7viE/6yYUlUBuIRSVQnwKJKSSfTqeY28uJ+7rKI6+ufzhP2CRF5LIMzfos/JPAyMZQFJOMX1W/knkmRtVPmZWVhY7d+5kxIgRBkaych4mVGD06NFotVq2bNkCQI0aNbCzs+Pbb7+lrKyM4uJivv32WwICAu4bFvmkWbt2LW3btjUwkpUjl8srPf+7ad26NSEhIURGRurbioqKGDhwIEuWLKnUUFdaWoqxsbFBm4mJCSUlJZw8eZLQ0FAuXboEwMaNG0lOTiY0NPRxTk9EpFKOZEby2eW+BkYygMyyJD673JcjmZH3OPLpsWvXLjIyMpg4cWKl+1/EkCURkcjIffTpM8nASAaQlJRGnz6TiIzc91T1MTEx0S8IRUVFcenSJXbv3s22bdsoLCykffv22NjYcPz4cX7++Wf27NnDu+++qz9+7dq1REREMHv2bC5cuMDHH3/M1KlTWb16tcE477//PqNHj+bChQv06tWLl19+mZUrVxrIrFy5kj59+mBhYUF0tG7Bes+ePSQnJxvMsfv27ePq1avs27eP1atXs2rVKlatWmXQ17x58wgJCeH06dNMnTqVkydP0q9fP15++WXOnTvH9OnTmTp1aoXj5s6dqz+uXOfdu3ff8/pZWFiwatUqYmNjWbRoEcuXL+fzzz/X7x80aBBubm4cP36ckydP8v777yOXywkNDWXhwoVYWlrqPd/Hjx//4A/sOUD0KBN57nD2dOPViSMREDhz6Bg3r8RTt2UoNg52HPh1F0lX4h+7byt7W1r37VaF2v47cLCxxcrCgtx8XUb7I6cPYmwJF26EMLzjHbm0HEjLBX9XsDaH+v/MMeIOOQWQkaerhljNDiQSnWElrwh8JcBdhkxLYACw7Pa2ALz8aMPF/HQAsyJdOJdThkDINSkCAq/9VsieDhaQmo22QIn8ZC4yK3+MC6zJTr7O1p6zOVLPkkNnYgFYvmkn04e/wrXv9hOUp7udtk03RgA2V5NwdvcVznKFsOktkI0JIvrbwxTINNiYO/P50P9RdOlPNviq+D0ml8+QsvhlP/68lE6X5CS+ygOkUJ6MzFQrodhCYMLshQT6edOyWSO+OxyNKZAYfw0jCwVGhbrzkxSrOLXsFDUntCKtWSlBqTLMM7SUmEo44V6GpJo5mRYq1n+3A01aETIfKzq82o4TzSFXrsSvaRcsNCfJIw3fuVdp8EML9tppyMlRUmanIHZ9I5BJUBRq+D5qB6Gn5WjVubTtPR6JRIYWLQIC9ipj+qR7YKs20l97E0vdZ6nKUGIud8O1ei0UZRLIyrrzeWp1521mpkAil6JRqlFYmUJ+kU7A4vb3QanWtRUUg0ajc22US8FIoTO4mRmLYZ4vCGqNhtGbTlYIFYY7BSnGbDpF99rVkN7H2/VRuXLlClqtlpo1az52H7a2tjg6OpKQkADoHib3799Pjx499Pm2/Pz82LVrFzLZs3vsiouL+8eeWjVr1jTwYnnvvfcIDQ2le/fulcq3b9+ehQsXsn79evr160dKSgozZ84EIDk5GYVCgaOjrtKyra3tA73iREQeBbVWzYqEMXCfO8u3Ce/RyLY7UuHJLM4+DHFxcQD/6D4kIvI8oVarGT16fqVr4Fqt7nFtzJgFdO/eAukTcoy4M56WqKgodu3axciRI0lPT8fMzIwVK1agUCgAWL58OSUlJaxZs0a/aPTll1/StWtXPvvsM5ycnJg2bRrz58+nVy+dF6q3tzexsbEsW7aMwYMH68cbM2aMXgbgjTfeIDQ0lOTkZFxcXEhLS2P79u3s2bMHAAcHXbSEnZ1dhTnQxsaGL7/8EqlUSs2aNencuTNRUVG8+eadCJfWrVsbeIsNGjSINm3a6EO2/f39iY2NZe7cuQwZMkQv16xZM30aBH9/fw4dOsTnn39Ou3btKr2OU6ZM0f/by8uL8ePHs2HDBr2BPzExkQkTJujvY35+fnp5KysrBEF44eZ40VAm8lwiv33jqh/e3CCpfufX+pObmc2JqANcPX/hofszNjPFq6YfDdu2rDSPyn8dqVTK6EGvsWLjz9xK1638lBZeQGIfopfJK4IfD+rykcWnQNd/mvxe33Eh2vRc3edSqoSUbDA3gex8UKrR5BghudtQ1qgIvEoAWwC0DYopSI+HElOUgNzSBAsfp/sOGf56J3avOw1laraGW+CZlodNgZYkeylGqSXINFI8bG0I6XcaQeoJKp1RTUgvokVAA+Zv+x0EcA1xYfbNnZTa38RPAmjA19cB2zfrITgmwA8xIIC5ixlm50sJMbYlTVXGycx8an00h1Uz3ia3mSOcj0cDrF+XzDB3S3oYqwkuknBWJdAuzQjvIinViiUsX/8LWgEuXU0AwE8rxVgux1IigUIVgYEepJpKOXD0IjK5BNsarrgUm+OqsUSamQ2ZUFjNkjg0qBLzqR5SnaGBzUlLzaSecQCmSckkJifzmllDLFbUIeH38xQbgSbEHv/iErLr1iB3/Q1kuUpUdkaYXS/G5e2jXFWqafpZf9y96nHAIpVY01wa5duxek4i3ep6QLM71961cx1uHLiIc4cgarVrjFSQQZHeOnbnl1aLQiLw8rlPUJcq0Wq0aG9loS5TIXOw1BnCNJU8gSnVaIvKdEUMSpVknbiKRRN/5EZyXbywIFCcn0lexnXs3YKQynVGvOKSPLaqziFRmNJZGoApt41tJgqQPbsXqP8KB6+mV/AkuxstcCOniINX02nld/+/70dBey9P1sfop3xuKS4uZtiwYTRr1oz169ejVquZN28enTt35vjx45iYmJCYmEhgYKD+eJVKhVKpNAjx+OCDD/jggw+qRL9yHauij/Lz3Lp1K3v37uX06dP3lH/ppZeYO3cub731Fq+++ipGRkZMnTqVgwcP3je8/1lcH5F/H7F5Byt4khmiJaPsBrF5B6lt1eppqVVRiyq6D4mIPC8cPBhTwZPsbrRauHEjlYMHY2jV6snk7d62bRvm5uYolUo0Gg0DBw5k+vTpjBgxgtq1a+uNZAAXLlwgJCTEwLO6WbNmaDQaLl26hLm5OVevXmXYsGEGRiqVSlUhFUKDBg0Mths1akRQUBCrV6/m/fff54cffsDT05MWLVo88ByCgoIMDIkuLi6cO3fuvuNduHChwuJVs2bNWLhwIWq1Wt9f06ZNDWSaNm1634rTP/74I4sXL+bq1asUFBSgUqmwtLxTwX7s2LG88cYbfP/997Rt25a+fftSvXr1B57j84xoKBN54bCys6FNv+40ateSstJSBEGCtYMdaTdvUVxQiLGpCX9s2k5edg4+tWpSq3EDnD3FqqIPQhAEUjLvlLCUS0vpfVcETJnqTtL+olKqhqJStKk5hsbLolKDAS6n7EV5S4aJwhahQRnVBwbpPK3GZkGyDKFtIebGlmyo/QHqMhUShYyXDkZgX9cXfgZMge4YlH+sXt+f6tmrdQ+npw6TGBrHjbPJ/JF7Bfu4XBDA7Y8cBK0EVBpujKqONF8FXWrTssCINaNeZWf9Qg47pCKzN4LhrlzUBuLcshpB/Y6R/cl+3pFLaGppgc/MjhzJyCR7+TmsAAdHB64U3cC1kStR7YsxFjxhis5LsiyvlJomNVEX3uSErYZYyyBiL2ajKixF7mKJrZ2KnNw81Lc/CA1qHK3kUKBFgorC+F/4UwijUKULhzT7NZvJ5q1Z6bwHaVw2CJBalI/ylhaT+ecZM3wonqZ2UNOPg6O/x9dUwcBpPZHJFeAOVvW8cPGxxk5lhX8enOkgI2HuSeqF7ievmzsOG67TfNGrWHrZk3E9lYRtpznWIJtLzU04YZGJneYCS2ck0XhlKObVdIZNax9HfBc3JOXqCQSa6D4QjRaNVML5jAL+vJHNsCBnLpvnscXuBm5lpryaVh0pAsrCUja3+YTGM3pz9ZdovHvUx6tznQpfq/KPujSnkN97LaJj5GisfBzBzAiljTGHN85EWVKAvXttGnQeg7K0iB9Of01JcAPeSvREI6SDRE5ZcQEqdSmmbp5gY15hHJGqIznv3kayx5F7WPz8/BAEgYsXLz52H5mZmaSnp+vzjKxbt46EhASOHDmiNwatW7cOGxsbtmzZwssvv4yrq6tBhavIyEg2btzI2rVr9W22traPrVNl+Pv7/6PzBN0DePl57t27l6tXr1YIC+vduzdhYWH6HCtjx47lvffeIzk5GRsbGxISEpg8eTI+Pj73HOdZXB+Rfx/ZyuQqlXtS+Pv7A3Dx4sUKL68iIi8iyckZDxZ6BLnHITw8nKVLl6JQKHB1dTXw6H5QqoG/U1BQAOg8zxo3NvQU+LtHXGV9v/HGGyxZsoT333+flStXMnTo0Idy3CjP/1WOIAgVqk8/6rk8DkeOHGHQoEHMmDGD9u3bY2VlxYYNG5g/f75eZvr06QwcOJDffvuNHTt2MG3aNDZs2EDPnj2fuH5PCtFQJvLCYmFjbbDt7HHHGNb7ndcpyM3D2sFO9CB7BO6+UlKhDFsLuJUFpkZgbwmtQyA5Cxr63bOLRyMr3+DzudtboXzbxNWSE7dWo5Ca08ZnApphTggmAsLUDGhYAkDu5TTUZbpKbJoyFVmnErA/4wvf3O5IAXSq5HwFgbd864CVN7SAd777kuu3DWV/hiiofUuCtZ811yMCkJkb4+z+G7Ps8kiy0yJ1NsNpYfs7AR3m5gwyr8OVC1G6NqWGuplS7NclUK2JM+UZtoTbE7Wtvy2CRMCzlSdBng6QqmTw+z0x9XDl+Kf5yFXgOX4AN90242BqQd+B3ekvk3AtNZn3N6+h5GYe8rRSTMuKcDfbh0wopVhjTUZOrv78fGxtOHLyLL+o46lWU8Aj0IvM1NtGudQiPExsKS7KJS0lDr8hTXGqU11//a9tPsmJjzbTatnrUN8KJWpslSacmN+SaJcsGmWaIZ13gUPj1pLyZxf8PjuHKTKynCwBXQ61wpedsV5kwy95WQxJtwWJgNJYIC5al3/h+OnVNG7+NhSVsub8LYZG6XIVxTulk+1fBIJAgnEhjfIdCCy2Ii8+Hecmvvw5di2aMhXJhy7j2TGkQgGQ8u9RSU4RcnMjnZEMoLCUgox4lCW6B56i3FQAivMzkeTmEJ7jhBwJaKEgL5Wj0ctQqUsJqtkN9+qhUKZi061cBmw5wysNvFjRryFkFej+cG4bJ7G3gv9QxdyqwsXy4fJEPqzcw2Jra0v79u1ZsmQJo0aNqvDAmZOT88D8QIsWLUIikdCjRw9Al7dLIpEY3MvKt8sfcGUymUFSf0dHR0xMTP5xov/7MXDgQD744ANOnz5dIU+ZUqmkrKzsvg/ce/fu5dy5c7z33nuALg/L3Un9AWrXrs3nn39O165dDdoFQcDV1RWA9evX4+7uTr169e451rO4PiL/PmzkLg8WegS5J8VLL72Evb09c+bMMUjmX87D3IdERJ4nXFzsq1TucTAzM3voOSMgIIBVq1ZRWFionwcPHTqERCKhRo0aODk54erqyrVr1xg0aNAj6/LKK68wceJEFi9eTGxsrEGoZrlnW1VVAw0ICODQoUMGbYcOHcLf39/AqHf06FEDmaNHjxIQEFBpn4cPH8bT05MPP/xQ33b9+vUKcv7+/vj7+/Pee+8xYMAAVq5cSc+ePVEoFE+t2mlVIhrKRP6VyI0U2Dg+uZvvvxVTYxPyi3SJropLS9l+LJPLKXYIgpZ420z61zClvZdp1Q1oaYKmoBgQkMgkFYyaV4tv4t65Fq1N38Qk0h2blNsTXhFoTxshNLYg59ItYr7cTc1325EVk4iRmQLvZr6wvRC4/dKnhq9O/MmSk38yPNGSutfUBLzXEftGvgbhe528a7HGTEW2kYCLqz8hXn781igdrQwsEyX8LEiQW+jk1SmFhFyzI+t8Fqp5R2iiMuJU1GZkr/hiezATZWoB6lIlGYcuw6HL/O/15pz5/TjmGHOrujf2V6UEpJqSeSmJ5sdkbPFV8O7XK7GzMOeveTPJ3naepYtWcjb+KgB9ur+EkZUZPk4utGraEMurJbRsXB+NBL5Y7sGl+EQkWgnNXOyISkrCRiKh6FYqp1IzQIAkOy2dWoZw5CedoaxrmzBUyhK+mtuRrMzr+Pg3Z1jdHwHIvZXJ4YkbQKvlwLur6XNkOnKkuEvNyOlgBaYQDbx98G2qFZvSe+5y4mW5fDt8CK5maaTfvp4loTYA/GmZzmtZfkg8ncnU5nEprB42VxOwl5qBrQUlecXsu5mj/xxKqpXqS6kq1BJ8S3TeXDaB1Qhb+Aq/dphD7tU0TJwtQSYBjRYtkGZhipNChpCZB4CFux1SUyNuHo6jWlNfBEHAxsQVEJAZmZBGTw4cSCMszI1Q81p4FBjdzgsHuXlJqNQ6z8bMrKu4uzUEoJ29Gaf61uHQ+d2c/f0sQd4vIZXqVvw0GhUpl49QJC/Dt0kPXe604lKwMgPFI5Rk/Q8SVt0BN2sTknKKK80mJABu1qaEVa/6yqdLliyhWbNmNGrUiJkzZxIcHIxKpWL37t0sXbqUCxfuhPnn5+eTkpKCUqkkPj6eH374gRUrVvDJJ5/oH8jbtWvHhAkTGDFiBCNHjkSj0fDpp58ik8n0FR6fBWPGjOG3336jTZs2zJo1i+bNm2NhYcGJEyf47LPP+Pbbb6lTpw6gS8KfkpKCWq0mNTWVnTt38sknn9ClSxdee+01AJydnSvNN+Lh4aH3OgNdwuAOHTogkUiIjIzk008/5aeffnrieWlERAItw7BTuJFZlkTlecoE7BVuBFqGPRV9cnNzDTwlQZeXyN3dnRUrVtC3b1+6devGqFGj8PX1JSMjg59++onExEQ2bNgA6PIqFhQUkJKSQnFxsb6/wMBAg1AyEZFnSVhYHdzcHElKSqs0T5kggJubE2FhdZ66bpUxaNAgpk2bxuDBg5k+fTrp6emMHDmSV199FScnXbqHGTNmMGrUKKysrOjQoQOlpaWcOHGC7Oxsxo4de9/+bWxs6NWrFxMmTOCll17Cze2Oc0f5QtDOnTtxc3PD2Ni4QjjnozBu3DgaNmzIrFmz6N+/P0eOHOHLL7/kq6++MpA7dOgQc+bMoUePHuzevZuff/6Z3377rdI+/fz89Pehhg0b8ttvvxkY9YuLi5kwYQJ9+vTB29ubmzdvcvz4cXr37g3ocpoVFBQQFRVFSEgIpqammJpW4fvkE0I0lImIiOgxMTbWG8oAkjKUlBaeQ6sp5XixE5vScrjeqwpX9C3NuP5LNMqkLPwHVAw3kMoUKFQCrmE1yN+nhBRde5l7PormxSAxwrpBdVptn6TbkZGnKwwA0DUXJGqwlkJnMybM2cJU+9rYfLyT60D6ocv0SvwCrM3IOhVP0rZT5H0VReM3qjPo3YE4y3VGtoa3XLhkkseMpd9zoHE8HoWmdLZwQ5Vagmn4aowkWkxUOqOO8R+6ocuDw2xru5F1TpcfRbn9Eqet1GwpuUCtsmr89Nb/MM03IldZjb8a5fGV5gIUQGZ+AQnpGTjamGJvrYv9lwgC0V/soOk7HciIuc47rVtDsG6MIyfPcuHqLUBGkKcnXTu3RvrVSrTAnoNHaRRUg5q2dijyBJp7+WP87iscq6fkmpkp6clpZGXqVoQyUq/or7tMkOqrVJZkFFCSXYDx7dBDG6XO4COUabCWm3Hw2jWOxCUCsGjHHrZ+MIr3D29HUGkpbeZMiVSNVKmmRCrHVCLwNce5GeSMLNCF7pqXQKpg7JlbrLmk8+56I8CZV6v58kPpcWwx4X/JvhQLahRaKRKJwFabGxw/25bOl2xpZOyOoNWSbGJMj++PEJ2Sx3f9GzHU2QzUGiRWZvS4tuj2dyMXbU4hN25GA1rOXWvM2QsFbPp9PytXNyXI1Zjs1IuYueq8XBwdamJnW52S0jw8PZqBVAC1FnO5lEA7C8zbtGVd8e8k5EbRyTKcuKt7yMtPITcvCalUjkZdhp9TcwSgMOUmJbZS7KpVvlInAlKJhEU969Nn5Z936jncptx8vrBnvSpN5F+Oj48Pp06dYvbs2YwbN47k5GQcHByoX78+S5cuNZCNiIggIiIChUKBs7MzTZo0ISoqysAAVrNmTX799VdmzJhB06ZNkUgk1K1bl507d+Li8uw8V4yMjNi9ezeff/45y5YtY/z48ZiamhIQEMCoUaOoVauWXrZcV5lMho2NDSEhISxevJjBgwffN7dYZezYsYPZs2dTWlpKSEgIW7ZsoWPHjg8+UETkHyIVpLzhtZDPLveFe9xZhnl9/tQS+e/fv7+CN+ewYcNYsWIF3bt35/Dhw3zyyScMHDiQvLw83N3dad26NR999JFe/o033uCPP/7Qb5f3Fx8f/0yr6oqI3I1UKmXRonH06TMJQTAsbF++Jr5w4djnZsHE1NSUXbt2MXr0aBo2bIipqSm9e/dmwYIFepk33ngDU1NT5s6dy4QJEzAzM6N27dqMGTPmocYYNmwY69at4/XXXzdol8lkLF68mJkzZxIREWGQuuBxqFevHj/99BMRERHMmjULFxcXZs6caZDIH3QGtRMnTjBjxgwsLS1ZsGAB7du3r7TPbt268d577/Huu+9SWlpK586dmTp1KtOnTwd0n3dmZiavvfYaqamp2Nvb06tXL2bMmAFAaGgob731Fv379yczM5Np06bpj32eEbTPIINkXl4eVlZW5ObmGiSBExERebbsP36MP04c1297VvPjepKuGtNRI2+SHQOI6XLvvDKPQ/rhy+zrPIfGM3vj3q4WkvLE6QqZLpzttseXtkRD0qybSF0EXN7VhfbhZMOwbWf55cwNJrYO4MOW/nArU59MrUzQMNf1PEPkjdi4/ygDcmzY1fcLAKSmCgYUrgIgcXkUB/73LQDB4zsRPLy1Xj+NRo1EImXEj6v56rc/QKplVcf+nP9sByF5lXgJSQS9zp6d62BkbUpBYia3Dl5iQlAeqcY63SJ6d0UqkfBeny6YawX2/3WRDzdsoql/dea92o+zX/7O1V9PYT6pBS4OdsRP2opEJsUqoBrNPxwAlrp+UtMyGDNjHnmFRVQzMqdRq4Zs2qUruT15YDeaH/wNbX4uiXXbsflaDhlv+pDcSnff7ZHpTuk3azgVc4oeXQfSoHFPvVff4fd/5Pq20/i/2ox6Ezoj3H45LikrZdOh/eR9e4qX571OkZERDT/4iFvZOXwxdCDDGjbil8bTAQidOwCXHiFs+WIJ3pqa5HzRjD3qOLKlJci0EubSEQvBmL5LovglTpf0dcb5eCJ2T4bENF1VS2C542UC4mD7NoG0abp8Fu6lpky7oSs2cbhQSbOVhwHoE+LOz0Oa6b4DSjXkFeqqX5rrQvbSrp8hPf4M3vbhmBpL2X8sh0NXcmnisQ5laTH+1dvi430nwWqGrIQEs2JqFVhhrL5jIPjQ4zSpihIEtYZ3d2aQfOMEAJYWLuTlJ1OmdKFrh7cRBIGi4ixOxm4grP+dl50XlSc9f0eeucHoTScNEvu7W5uysGc9eoW4V/l4IiIi/36OZEayImGMQWJ/e4U7w7w+p6ldr/scKSIi8k+IjNzH6NHzDRL7u7s7sXDhWHr1enYe1s+C77//nvfee49bt26J3p8vCKKhTERERM/x8+fYfvDOSqWNhSXZ+bowNiPPWgxq2Qx3s6oPIcs4doXim1m41XVHuCsU8u6cZRpAUs0OkjL1+1OMFLjM3w2AmVbLIWsFtaf0QJKYxjGzNNTADttbBJfZ0yfVDVVhKZEtPkJdrKT+9F7UGNVBl4DtajKJO89yYfVBMmKuU2dcJ2q+0RKloEEoKcHISOdd1nrmXPbHXqJLkQVZqjLejDNGZSZHXqym7uj2VGsVgEap5q9v9nJz7wUcm/lh5WZL6rGr5F5N5Q/bUiL9NAR4u3P4ss6Da2Sfzsx/uQ8y1Z3YfVVxGUen/Eyjab1Q3M7JpNKokUmklO43wmiZHbycB9113nOFRcV8uvg7Tl3U5fiSSAQcbG0YWduTuqcO6DoNrodq8DuM3/UD+aP8yFt0CtOjWRRnFVJYVEygnw/1awfg7VGNOrUCMJJJ0ShVSOR3HI/LPw+tVotGqUYj0SKXySksLuHX5Vup8XYYbLjEXzO3ARA652WMGxpx6ftDXK/hhOJ/dWiX48IhyzRqFlshWXcFzzfCSUrPY+Si73G1LaZfaintPv0AsvIByCafn6+vxe3qLSSOddnRxYNCWRltcpwZkOGNFigzM+ZmSg5L/0oGc1Pqm6loV8cH+0KlvmIpMim42XNo0ywoURLa5B0EQSApNY/tGd9jUrMGimPH2FbdD1mGwLeBfSiWqvnA8zQFUhWBxVaMTQrU5x+b6XSCRNNSZGUqhm1PIjMlFtBia+PD9VvFbN3fiO/n6yoRqTUqNv6+AZsar9Ku3bPNhfNPeRrzt1qj4eDVdJLzinGxNCGsusMT8SQTERH576DWqonNO0i2MhkbuQuBlmFPzZNMROS/jFqt5uDBGJKTM3BxsScsrM5z40n2NCgqKiI5OZlu3brRo0cPZs+e/axVEnlIxNBLEZF/KSq1mgvXruJgY4uz/cPla/t7osWgoBC27CmgRoZAuqnPEzGSAdg39oXG6IwjWfmoBA2nTbNoUGinlylIzuHvr+UOdha0dLPmj5s51I+9wbk9ZzDzsMO3R30aZmuRIOBZaIplLgiWIDc1osuv40CrxczVRleZ4LbhwyWsBgdGrgEgZt52ln9kSqFUzazEOjgrdeOVqdQYI6GNmStNfnoXSU4pdXy9yN1zDvvaOm8XLZAVm4RWpSb1j4sYda2LsrCU+h90p2tzf5b7OrH1RAw95n0JgFlJIWW56cjMbFEqS5DLjbn8y1GKUvOQmRkBoFGpkd32tDNyu234OWbMdsudnDp/kTGvD8Te0QZuF7Qb8Vp/Tp2/wGf7T/GxhRxPUznSZq2RyaRYXizi2tCdqK/kUHRbXwFIzcgkrFFdpFIpRrfHuttIpkZDmqIUF6UJgiAgVciQ3F5nMTMxRrPsJNdzS+kyrh8/HLyCS3VrzBpbci5mKyV+eVRr5Meid3OZFJXK9FGe1Oxrxe6N0RQXlODaL5B3nC4idZSgqOlg4KNvamGN360iSjVaSDnF8LMemNsH415milarJfHMVTzr+FLdwpgZDTwJnraCC0nn2WCk4Odv5qIoD9xTqdl/JpE4bRPebBrMrgOXuXi1AJemf3Gsuy7cUuEcisLKGIBdR3bjJrWnwEdXJOK6Mpkiq0BM7RwhLZeRKUHsKDtK/rE4MouvY23lgSBIycq+xvdbaiA3NtKfw5bd2SxcYUJ80nYmT23OqFE1HuKv4r+LVCKhlZ/Ts1ZDRETkX4RUkFLbqtWzVkNE5D+HVCqlVav6z1qNZ8acOXOYPXs2LVq0YPLkyc9aHZFHQDSUiYg8B+QXFpCZk4O7swvn4i6jVKmQyaT4VHPHysKCXYcOcjH+Gs3q1qdeQCCCIHDw1AlOxcaSV5CPFjAzNsHExJicvDysLCwoKS2jsLgIQRCwt7HB180DGysr6tYMMCiRfDf+Xt7sjT6KUqUiwKc61exqsuBnBTKtQMZxFQyu9LCqw9aCnaYJ7JUm0CGnGsJtI4eqpAxz54qJLaW3MonqFsxfhy5zdtGvABhZmYKlCUJWPghQTWtOqbYIADVatNXMMNfcZfC7HaapNpdh3qUmBdsuYtm3Fv9L9cenxIKj5uk4K03IjU/ns0G9cbO1Je3YFd7cs5GjQ99DXqzUG8kAMDfGvr4PhTdPYlvLjWaf9kfqZg9pOXqRbg3qsPLtodzKzKF7DRNMzWwB9Ll/3FsG4dujEZLbRrzcq2ko/s/eeYdHUXVx+N2WZDe99wIhPZDQS+hFeq+CFGkWBEFFFBURFFRQiiAfSgAVqYI0ld57hxACISEhvfdkk23z/bGwEBOaBOu+PHnYnblz59zZqWfO+R17c8ztreCcGSh05DVP54fNv1BUUkqIX21eHNQbD1dnUtOz6NK2BRt27KFYEDGxyAxbkRW6pT/iam/PoD7Pcf2bNZTecZGZisuRmtjQrV1LClMv4uVf/c1MmUjLB16XaPrzBcaEvIJYIqYwLhOFizVxG0+j0VQgci9gf1oKX4X60fGaHXw7ivzc20hlZtQlkF9+1O93Mxcn4nxmFwWn43Fo7se+xvPQlquwGCHDZ3x9uKOHhliEqY0FoW1Gcv7XhQCkXviN9q3vVLoUgXf4Pc28awVl2JbqIw41FSo+3XuWGf3aUlBawEHzLGbsT+ZqjIrivGTefi0drRY69nHFu4d+eROZCSoAQcBRJSPUvQFDMlM4pYvF+0wUmbbm1Grdj3X78ilMzOfqdXtSYlbx8jgvCgqT0Olg4twm3EqxYuZrGUBdNBqBoW9co0LlgEgkcONGUfX7vhEjRowYMWLEiJF/FTNnzvxH6HEZqYrRUWbEyF9ITkE+x86f51p8HGqtBlMTEypUKsN8hZkZXq7uXL9T+fDXo4fZdewIWp2uSl+l5UpKy/W6PrkFBYbpgiCQnZdHdl4eANdvxdO6URPcHB2RyfQOo9tpqRy9cB6tVoupzISGwaF0at6C4txS1OYypCUiFE5/TupTqZmIPEGF9L4hFsZnYR/iUW17iVhE3VYBWCx7EZlUjGe4J2QVVq6gKcAN6zJ0xeUE6fROKUxl6JQViMViCuIy+KZVLrE7Qmie0oJ2FX5YKPXbpkm+HVpTMRVFSiLC/NCqNCA2JcDUkuSCPPys7BHEIkQ6AZ3ClFNvr+P2tvPIrOW0+d+LSEykHPw1CXMrGTZnL6JWqggc0ZIRrVsAkB4bzc3Y/bi4hqDVarCx8UDhao3kTjSXIAiYOFmglkvQlKtQtUuh0DuLGF0+RSWliATwtHfEysKc3p3aoNZoKVVqGD+sHxt37EGr1ZGenUOZspzC4hISi9V8+/kMFsztTUZuCcnlTVCVl7P1121Em/1Cqw4TaN97GlLd77Ly72zOMLeOZHKbQnUuTta1+XTXBvqHNST2lWiES5swuf0dl1/by9qMRHK2laFu0ZSyfj2RKBoRBnV29gABAABJREFUtCKPmPgKFN3ULBxiyohBvTG/KUGr1O/z9poG+DbsxW+rpnE7sZgjNwcycLA/vXsHo7B2pqwwE62mgkvXfqZ+6AAEQAyIEJFTkMSGL/ozNKIn1oI1G6IU5JhASm4Uq31LSTQppcEogZsfQUaumrvBkyYqD4bgSRaldFLUYdutPVhk5OEu01ft61jsQUc8yHPzxdzcCYD3P4zm1q0S/LyKmPWSNSq1mlNKN/ysJfiH+iE2ScfbM4nLUZuQmVhjIYcKlSk2lho++CAUI0aMGDFixIgRI0aM/H0xapQZMfIXoSwvZ/53K9FV4/SqKSQSSZV0yrt4urgwuu8AAJasW1PJuQZgKjOhQq2ikUUo3c3bQhvAvko3NY4GHfFFyQRk6R1VWpWG4qQcrHwc7wn9V0NRTjFipQqNUo2ZkxVmNvqywzc3neb09E2IWrhRt2ND6g1vg06nQ5xoxvXNR0mNuULm6XjOZvQieHMePaT+uLb0R11agczclKKEbKxqOaLTaEnZH41WpcG7WxhiiQTBVIbI3kqfKigSQXoev/T6kvxrqQB03fI69nU9Wb4+jTo3L5L+vV5kX2phyuDzH+ujooCY7cfJu5CIf5+W2AS4ImgFTCxMEQQBRBgi647/ehSr2xVU2NpS4Fkbd8cCLrz3E6YpZShHNWTQi89hamJSSdsNYM3W31i39TcEE3P8vYbSv7M7ptKrfPLzasrTrJFqtHh6WbJbXIRcbs7GEa8R6u5JiTKfvLR4PHzqk2qiZK1bMj2ulPKhaiAaVDRweIUkv/YElFmRN3oA4iJ9tNS7n1xmi2cex0svoXV2BDN9OuOB2eDhU07GrbPE7YhFKpPwbf/X8dhzhvKcEiK+f4UrMWvZveodAA7dGMTZ5H7k5/dHVZTAhV2L0WpUeLo1Iiig+70fXyxm8bxOmJrJ8A7QVwCLUbsQbJqLoFOTU8uDQ53rgQ58jvkxvmVtXvt4H6nH03ipXRx9x01BZu9KPLnUwhYFJlw5fAovaydsLPS25xeq+Hb5/9CWrCZfHcL8zS8ye8IFGoYUAvBpaihnyt3wKBcYLT9PeO08tFrYc8KVxWtDAGgQXMj56Jf/0HHxd8F4/TZixIgRI0aMGDHyb8eojmvEyF9EqVL5xE4y6ROIX1pbWDzQSQaQmpnJ8YvnKVUqK0Wx3aVCrZ92vjQa+vGnOMkApIgJ0N1bWWFaPkW3sjjx9np0ag1addUx5UiUFKZlY+Fpj42/C7FrjnP0zbUU5JVxYc52AIQTaejylJz7dDvCbjm850BAXC+Ch7Qn4sthdJtbgHzcIfa/+A3px2PJPHMLQafDwlMfgSYSi5E522AR6I74zu8gqlDrq2ym50GJEgSBxu/3xqlJbUJf6YD9nZTMUf1csNRVAODVLYzO618zOMkQoKJZPey8fNk98Cs2NfyAq8v2UY4GkUhEUYV+vFllKgI6NKbuKx3x6VyPLmOuMPt/5QxcOZHA1zpxLPEy2jtppLo77z8EQAsIfp70nzyGPQm+LElYwXOzI/lwwWZ0uhBOB7ZAWq8J3xWmkFhUSExmGrP3bgWdQFlJGVOjRcy/mIKn2hyHNTfYH7sZjT5BkWu6y/rfTBDRZtjH1KrTnG59Z2Jh6YBjtBadgx3c2VaWahndnjfleo6Y8iS9UL9GreX16xdZM6o93c5/gk2oJzrtvX2xTGWFg4MpJiZibF39aD9qMSnWL9P2VRuGTrnG3fc8WQo14e0G4+Ufzt03Pz2aNUHQ6cXlvMqkdKQOr4sjeL91PVaLz2M1Q0vQLifMfDTkp9/kS46ygGPMEQ6wb80svl+1A59WR4iKOUtBYSofLTrJzZi1lBRkIis9wPqFsdQPygegXCchocKcUJMsmr1eQZ1AfaqvRALhgfmYSPW/YZsOvo93EBgxYsSIESNGjBgxYuQv44lTL5VKJefPn8fOzo7g4OBK88rLy9m4cSMjRoyoMQONGPm34mBrS9O69TgTFYVA9YGdFgoFJWVlKMzMKCsvR3Of40tuaoayohyAWu4eJKSmVFq2sKQEkUgfi9SuSTPEYhF7T54wzNcJAvtOnWTfqZMPtVPq4ElWuQYnsz8xU9vaHHQCCAJ2DlZoC8pwblKbTU0/pFbvhjR6r3el6DJ7rRnncnLwpDaqIiVWtR3w7dcIczsFfs+3IHbtcRq+0xOf3g0RAZIf9FFCoi6luD6nd16Ij5iQyQEAsi/extLbAZFYjEgMgk5AmVeCa7gXpekFJBy6Tq1O+igh1FqyLyRy4fOd2AS40vCD3pzs68Gh6CjOjtxBhH8dtr71GuFvdKU4MZuWXw5DLBLDVgsEpQhRsZjwg26Uilw5I9kN6mKsfBwolWgx00rZlZTH8fRCMsrUrGynF4G3MJcikYg4c72Ic1/8xq0fj1NrvD/vz1tK2+aNeK5NcxILilEVFaG1dcTerw7u7gkQfBykAq2aOlNSbs/zzhLqHZ9MmqYTovtk21r4+AHgZO9GnjaHaScSuNU4B+3z1lgviCUgry55ukycUkLJ6pFBdCto6dWELpP6G/pwKzDls6v+yCxtSbbWcsOsiEueeYR3ENGmWMzPaSrMyxJpkHmMyONz+LhbPSqSzpCdfA2/sJYo1XIGN+7GkBc7kpqXw5Ybm/BQFjFvfgBZSRrWJWVT9yUpog4VKEtyiChK5XJEMKm1XXAs0tLBrQemCmsKMuOoHd6N1rgZbJNxx9EpgI2dFy6+jUlmHwAZlFJensKtlNpE1C8hKc2UXYfPYW52m0tZ9XGyTMbB3R8LWar+dwQ++CGM4Z1u0dItG2EfXAnyo+HtUlQlaTjZq3h/mj0VuKHTwY0bRQQEGCOxjBgxYsSIESNGjBj5u/JEqZexsbE899xzJCUlIRKJaNmyJevXr8fVVV/uPjMzEzc3t4dGsYAxdeOZcuMi3IoCL38IafZXW2PkMSgrV1JcWsrOQwdJycp8rGVkUikBPrW5GheLh7ML6dlZ1eqW3aVLy9bE3IojKT2dxz3kxWIx680bkiixoY2zgl/bez56oWdBUhao9JUHo77ex+1fL9Ft2xuIJeJKKYaJ0mIUp3OQm1ljvq02Yq0EXi4Ax3vnI0P7TAmssEHXsBRxl3LDvKy0LI7vOk73UT3ZWH6VAeZ1kSOtvCygLqtAamaCTqNFYiJl95AlZJ9PBKDkg9a8+uv2SkM49fF0mtSpzZXrJdQNMEd00By+tdHPtNRCsd5x0yF2O1PqR9N1yfNIzEzQIVCh0SG/4xT86ZYNdaxVxBXJSTgajcbkOp8d3kSpyprugY2Y2qYWDeoFk56Vzesz56PT6RjSqzMHmv1AbtRtEg/XwcrXnuPRer26DnVq0/T6t+SqfIipCCdJoeal7t14p1sfAK7mltJk0wU0gob+M0wxtxaRsVvFpS7FDHA/wk0f/baz+aQltRq60eeygJMknKiUYrqFuRq2V66knGm1LgKgytHRdtlhcuO3ktq2KWU9u1ASrWOxXycWvxSIVqPG3tWHpl1G0qDLRExEpvxwcw8nw0EoLaH4dR3rV5pi7g7jz9lQ7lhG/QMX8IzPYNuLnVCb6j1+HVR12DO1hOJUgUULQ5Fpb2Pt6IOpwppiKjhKIs6FanxKJNi6+HGk/Br7dNms+SqP3BwlL5tfp61HMIfPOWAisyQmIRNHNznvv+eHs4cHVw+uJDPhPGq1jmnzA3jnpSSc7PRRg+eSXbiZ0oOvF/silkgpV1vg5raV8nItAQGWXL/e448fD38xxuu3ESNGjBgxYsSIkX87TxQiMm3aNEJDQzl37hwFBQVMnjyZiIgIDh06hJeX17Oy8V+PTqslKzkJOxdXTO5o+TxhB5CfA8e3w50II66dBU9/sLKrWWON1DgKMzkKMzml5eWPbGsik6FSq1FrNFyNi6Vdk2a4OTry4y87Hrrc0fNnKVUqn8iuoKB63E61AaBE/ex01B6JhRzy9Kl6oa90wLmpL2KJGE2ZCp2gw8Rcf8z4aCyhoSVst4AovT6Z8Js5ohFFev2wO44utUaD1ElA9F4uYiB+y1l8+zVGJBLh7O5M3zF9ESHCwtOe4qg85O56AXdBJ5B1/hZOjWsjU5gapgHYBXuQfT4RmaUZDu4OlcwP8XQnuLY3M5fc5qNFibRtas2+l5tyNx5OqFdO3BEte3MzOVBUymev90NiZgKAGJHBSQZgYQKHMmxwMFPTs6WKTl+uoVCuAnkxOX192dnYjYh8UzzdXHCwsyErJ4/LiWmUOeSgXdcYT0BlXohcJqNco8HP3QrzFHv8vWpTfMuJLe++jr2tDQCacjV1rOWsey6Ilq4WSLJFzJdd49APGlKxpMDFAdBHMUqySkiKmUKa5XgaKVrh5WDJrUIlta3lZKNkv00m8jIBpUJExilYvD6YdpFWlDQOB4kERWtQJpeh1ehTJcVSMyIGzoTScoS0HEZZNsP69F7OfP4y/taONJvShgGTPsXdxZ2inNucTz2OSiTBvKiUAke9/ftN4iibIrCljpq+zfdib56CqbkttRv0Jf7yfgKCmnHzzEayBQEzC3vKS3IpLgrndpYDIMPNXsXmXbdYtVUC5GMi09LObxlntnvRdew8MhMvAFBarKWb/ywunOtA507OaHWwcZMbUTcTGT/el7AwSwRBy13JuEpFJowYMWLEiBEjRowYMfK344kcZSdOnGDfvn04ODjg4ODAjh07ePXVV2nVqhUHDx7E3Nz8Wdn5r2bTwi+IOnoEJ08vXv1yEVKZ7NEL3aW4APZvBHVF1XmlRUZH2T8Ibzc38osKH9pGpVZX+n7swjmc7R0e0FqPWCR6bCdZgE8t3JyccLKzJ7BWbcRJxRzLKuMVf9vHWv6ZYGcJxWVwR5vMLlRf/VKqMCFh50VMLMxwax14T/PLVwUSAXQgqicCZ1tQq9HlFaMS6ZjnfY3aFRa4qRRssE9kcB8XagkCojui+XeF83vneRK9dT+2o1ohMzcFQcCxgU8lR4e2Qo3UTEaj93vh1aUuFp72FJnpC0QKgLutDZc++xCxVMLR88WYmoi4cqOU0vBSrCaKQClG1LaMKL9svvz8FiP7OtMgxOLe2HWgzCvm6Os/oCxWEt3ADL9GjejbrSmnz+dhq5KQYgISEwkOfo6U2IghXx9xOKjHcxy8fJHjpPIcfTnDDQC8Sr2QtzvBrIZfEO5YD6HXFI5ExVBw6n/8svswglSCl58nP589wawug+jsZYOZVH+pGHXAgyXbY1j4rjWyoqvEZigIqdueToH1mFwyA62pxmD6D5mJyEI0JJuUYZOeTcjFdLZscGb/amtqt7akuFlDQ1u3RIHClBuG73m5pXecZLkIOh1HDy6jXJmOg7UjIU07AbD1q8G88vlhFDob2rV8i9NReaR/moTzNChxLEcnErDwELHu60BsOIWgg4rSfH6c3RuxWEzWrdPYOLgAUF6SC0CY7Dqi0gjE5gKu0hLize5d01RqCQdvPE/n6M+QSGSgEYFEoKJIiqlMiWn5TtxDNvDtRm+ibt5CLhfTsuV+HOwEPn1tP0vntCQhryHDh9f6o0eCESNGjBgx8ocZNWoUBQUFbN269a82xYiRfyRt27YlPDychQsX1kh/M2fOZOvWrVy6dKlG+jNSszyRmL9SqUQqvedbE4lELFu2jJ49e9KmTRtiY2Nr3MB/OxVKJdfPnAYgKzmJkvS0Ry8UfQqO74RjO2HXD9U7yQBkJjVoqZFnTa+27Rndtz+vvzCS8QMGYaFQIBY//BBVazSkZGY8tM3jpFo62tryfNfuDO7SjdYNGxNYqzYA/bws+bKRM35Wf/G+5GYPYhEikQhNuRpBp6M4OZfjU37k4LhI9jy/lIK4O9shRAVfZMG8HOhtCgpTsJATb1bMa75nKJdo6Z/jRdsiZ75MbEQ7sQ/iO86v+7XixIio3bchSbuu6L9LJQZdtLutTK31kWsisRjnJr4oXKxx9XHn25dHEe7tycKRzyMRizl/8xZK119ZvEBK9ukWIFKTXy8XXdtikEC/zo7E7Axn9Vf1KCGfaNUpNIIaJjpy66UYss7cojgmHeWBOL7bvJaywmKaNqjLpHZdeN2jEavfnEQXp0BezvBHo1WRkFHMuj02OLu35IVGrfjm4A3GjRpEt+ZNabhXieWy3oQ71gNAq9Hy+Zf/A2DDb/vZuHMPq5etYv2tM5xP+AYT8zvRc4JAnUBH0k9EEOy0m9Rb+zEv24GnXSKv7sqk7FZrIjPWcUQZTeu5J/loTxbLVudTIWhpvvs8PrFJvFH/Av/7wJsuoYvu7Zc6Ad+ArRQdzEAn6PezI1caEB+dR0a2iqJS0KgrOHU+CpnJvYhbmQg6d9iCzPlXhr0Rw/A34lj7ZSELnfORvrMM30IpQzP9GNzemQb1+uLh0Y8mzV6jRBOEd93OBieZvXswniHtKVGa88svnlhvUqH4TsPR4044v29D22/Azk3vpA3wTKbLmHmYyC35fnU9lq4P4PWlbUgqmEHT53+kbquBtGnrilgMSqU+CjMnT8TYWe2Y+K5Av76u+PlZ1swxYaRGycjIYOLEidSuXRtTU1M8PT3p2bMn+/fvN7Tx8dE7ykUiEXK5HB8fHwYNGsSBAweq9Hf27Fk6dOiAjY0Ntra2dO7cmcuXL9eIraNGjTLYUd2fj4/PA5dVqVR8/vnnhIWFoVAocHBwICIiglWrVqG+8yLm/v5lMhnOzs506tSJlSurVmlu27ZtlfW//PK9yq6rV69+oJ1ZWVk1sj2exbjuIggCXbt2RSQSVXEuVDem9evXVzt2sViMq6srgwcPJikpqdp1BQYGYmpqSkbGw6/pRv4ZjBo1ij59+vzVZhgx8p/k9+f7WrVq8fbbb1P+GNk7AIcOHUIkElFQUFBp+pYtW5g9e/YzsPjP4UHjMlI9TxRRFhgYyLlz5wgKCqo0fcmSJQD06tWr5iz7j7D7u1WgUdMyyAdrczk2F3aDdX8ozAE7F72zSxDATP9ATkq8Pq3yYYjFENYaHNwe3s7I3wqRSISni17vz8bSkjdHjkalVpOVm0tmXg47Dx/6Q/3e7yYTiUSVHGfmcjm+Xt70bNPuiSpq/unIpODtBOVqzGq5gESMha8rLh1Dydh3lewLiWSeuYVNHb3zA2ctoIXb9x7E/GS2DC70RVqhw+zOqU8hSBEQKkWS3U/Cjotoy6tWBP19y7v6ZYJOQNBpGT12EHmClgmrfuR/+w5x7PpNKjQaLibfoqGdDc999TXFGhWLO3bmpVH99BdyuSllpblMyX+OXF0GrUz68Ob8pThecUQ0WsqW+rWI8pQTrkvF3EpBamY2Y5/vC4BWpUG4LSA1k6FUlxLY4SwqlYT9R0xIPtIeJwsr+oQ1hrYtOZNnxTc2m/k18xfaWHfi1vVEJIPPIQpJR7c/AN1hf2SWIj4NdkKtUqK2M0WVm4MyNRknxwBulSpx86yrHy9w0kNN3V/fIveyFdtCZlDUK4jLprsRUJByXeD28qtU2JpiotJgYiKnRWg0id+cJ/nrndh06Ujg4lgkKh0ZyZcRi/TbOrvEkwVr4lm2NAVzMxjV5iDbkgOZ80IIytJc8rNOsmO/Ffsu6SPY1u7IolE9vQPKVKamocwC940H6dCnDSjLKFN5EBqoP4c2aLuIm3HrsLXNQyI1o16HceRnJuKUL8LC1YmCwmwA1hwLYGCIGb4hUGuAQP5oJ6KizLmeXp8gIF1Wh0OHCwB4ed5rREQ4Mnv2VWbMiDLsF1KJDo1WDEgoLZezbXsG4fUdH3ev/8+i0+rIOnodZXoBclcbnFoFIpY8uyLdiYmJREREYGNjw7x586hbty5qtZrdu3czYcIErl+/bmg7a9Ysxo0bh0qlIjExkTVr1tCxY0dmz57Ne++9B0BJSQldunShV69efP3112g0Gj788EM6d+5McnIysmqixlevXs3q1as5dOjQI+1dtGgRn376qeG7q6srq1atokuXLgBIHnAuV6lUBofd7NmziYiIwMrKilOnTjF//nzq169PeHg4AF26dGHVqlVotVoyMzPZtWsXr7/+Oj/99BPbt2+v9NJ03LhxzJo1y/BdoVAYPg8ePNhg111GjRpFeXk5Tk5O1do5c+ZMEhMTWb169SO3xbMcF8DChQsfmi59/3YHsLGxqTTfysqKGzduIAgCCQkJvPrqqwwcOJDTp09Xanfs2DGUSiUDBgzgu+++Y9q0aQ8ds4+PD6tXr6Zt27aP3kBGANDq4PINyC0AexsIC4BneFr5T6NSqTAxMb6sN6JHp9WSeC2a4vx8LG1t8QkOMVSPf5bcPd+r1WrOnz/PyJEjEYlEfPbZZ3+4Tzs7Y6bWf4knukT07duXdevWVTtvyZIlPP/8848tFG5EjyDoeC7cny4NAmge4KWPDtuzFk7vgd++h+0rYMdKSE/UL5CV8tD+AL2If526z9RuI38OJjIZHi4uNAwOpVFI1d9U/JAb+N+TnS6iIKfyjUupUklxScnf20l2F4kEzM0Md7YiiYT2u96h0aIRNPj8efxe6VipeZVzkVpLJ50v7Ypc0Cjvc34J93/U/8sXlOwauJhL839FmVeKtkLD9R+OoioupyyryNBeo9E7anQafcSRWCJGXVJKaVYWL/fpSj+5O618a+Nlr7+wdvHxY9lbK8ivKEej1bE3NdXwEKbTaMnXZZGr00cT3NRcBLmAU9NamP7wKluaBXLT3RtNy25IJBKib8Qb7FAVlBlsSC0tR24uw9ZaytktDRCLRfTwq4tOp5+fVTsNnwH7+Eb8EoOS6/M/31cQN0pCJFdj3iWRxnVN6dJSgVOeOZdTfFj+1RrSsm5x5dpmEm+fwFoGLgGNcP5sBblL5pPauy25yxci+t879H7XnAynaF7rdKcicnEOdjHQuP54ClSlpCVeZePqiQAkf1nGD+FpHN9/mJsT6mMT4YLoThXJ/gO8yUjKQhAE2jVNotCmDW18R9Kv+3D69n6TmNwP2Zs6zDD+sHrmdPSZQM8G61gw7QLuHnbIpAIp+XHs3L2Gl945jPqOzt7NRBUfL6/H/NWBfB7pw6ENs1jyWn2+nPEVDhm98bK7pjc9TUzGMf0ycVt1xEdHER9fygcfRHHyZA6HThYAEBHhQESE3vl182axwaaXX67D9u2tEaHfR8QiDT16GF9ePIqkLWfY6jOJfe0+5vjQJexr9zFbfSaRtOXMM1vnq6++ikgk4syZM/Tv3x9/f39CQkJ44403OHXqVKW2lpaWuLi44OXlRevWrfnmm2/44IMPmDFjBjdu6NOHr1+/Tl5eHrNmzSIgIICQkBA+/PBDMjMzuX379lPba21tjYuLi+EP9A6au98dHat3xi5cuJAjR46wf/9+JkyYQHh4OLVr12bo0KGcPn0aPz8/Q1tTU1NcXFxwd3enQYMGTJ8+nW3btvHbb79VcWApFIpK9txf5EEul1eaJ5FIOHDgAGPGjHnq7fCsx3Xp0iW++OILVq5c+cB137/dXVxcMPudzqxIJMLFxQVXV1datGjBmDFjOHPmDEVFRZXaRUZGMnToUIYPH/7Q9Rn5Yxw+CwPegElz4aNl+v8HvKGf/mciCAJ16tRh/vz5laZfunQJkUhEXFwcoN9vli9fTo8ePVAoFAQFBXHy5Eni4uJo27Yt5ubmtGjRgvj4e/cBM2fOJDw8nOXLl+Pp6YlCoWDQoEEUFlaV9Jg/fz6urq7Y29szYcIEQ9RldTxOv3ej5z755BPc3NwICNBX6I6KiqJ9+/bI5XLs7e0ZP348JSUlhuU0Gg2TJk3CxsYGe3t7pk2bxsiRI42ReP8iok+eYP74Maz8YDqbvpzHyg+mM3/8GKJPnnjm6757vvf09KRPnz507NiRvXv3AqDT6Zg7dy61atVCLpcTFhbGTz/9BOhfnrVr1w4AW1tbRCIRo0aNAvRR1JMnTzaso6KigmnTpuHp6YmpqSl16tQhMjIS0L8A+/3Lk61btz705YtOp2PWrFl4eHhgampKeHg4u3btqtQmJSWF559/Hjs7O8zNzWnUqBGnT58mMTERsVjMuXPnKrVfuHAh3t7e3Lp164Hjetj2+C/zRI6yd999l19//fWB87/++usHhq8bqZ7OI0fjVcf3Ea0ESImD/Zsgs/qQfQOhzSGw4cPbGPlH0r11GyYMGcbEoS8wvGdvGgQFM7hrN8we863dxVNmxEZXnZ5bWFCzhv6JiCViAid1IXhqT8QO1mBrAXe0yu6/EAmCgE4EWCrA2xmRlcIw/f52IkT8apNKiamO1ktH0uH7l7Fv5kfyvqsk777Kxgbvk39dnx6t0+ooLtERu/YE2zp9hqZM73wzFSSYFKmoOHmTN1u3ZnLzllydP4u9773B4r59CM8EzzIxtjopbwzsiiAIFMZlIhKJcJf6MkA+ET9NPYYWv2Gwy9vd5u6wkJuasD42k6yoZM7sP0dxWRlyJyuOlsVxvCIZN1s7LvzUiG8/9sfNSZ82qdIWcPDIZ5y7fIrIE1fRFekf5mQ2haSW30CCPsIlwqQr4/oOx/yMNauu2rAoUcanF8vo1DeWGV/5YWpij4eVBfZmTnhWmGEiNdNHsIrFCBZ6bbWospvM6tUEs/NbGG9fyqbXx+MjtcPfow2HTp5BpdJvp7rOF+nktY96XkcY3MGR9hEv8+rbv5GmHcH5y2KCnM/QoWk6Y/vdZN++EH7Ylkuvl67qf3eRjo6hcXd+NIGZU3VYKkp56UUbvN30N+F5GbdZNrkx5/fP5tr12zTqd4E+L1/k5PmDaNRqMnLNiQjPQaPMx69BB1LyA5GI1QzusRy3hiUIOvi1rYp1bioyPsrjo1cvIxbrCK5Twf0Z0Z6eCq6d3MbqD7qiKY7DykpGx47O5OVV0K//CWQm+ggVRydzGja0/6O7+n+CpC1nODJgIWUpeZWml6XmcWTAwmfiLMvLy2PXrl1MmDChWp3V39/kVsfrr7+OIAhs27YNgICAAOzt7YmMjESlUqFUKomMjCQoKOihaZHPmh9//JGOHTtSv379KvNkMtkjdWbbt29PWFgYW7ZsqdKvg4MDoaGhvPvuu5SVlT2wj++//x6FQsGAAQP+2CCq4VmMq6ysjKFDh7J06VKDM7I6JkyYgIODA02aNGHlypUPfVmclZXFzz//jEQiqRT1V1xczKZNm3jhhRfo1KkThYWFHD169KE2G3l8Dp+F976C7MqnFbLz9NP/TGeZSCRi9OjRrFq1qtL0VatW0bp1a+rUqWOYNnv2bEaMGMGlS5cIDAxk6NChvPTSS7z77rucO3cOQRB47bXXKvUTFxfHxo0b2bFjB7t27eLixYu8+uqrldocPHiQ+Ph4Dh48yHfffWeIZn0Yj9Pv/v37uXHjBnv37mXnzp2UlpbSuXNnbG1tOXv2LJs2bWLfvn2VbP7ss8/48ccfWbVqFcePH6eoqMion/YvIvrkCdZ9Noei3JxK04tyc1j32Zw/xVl2l6tXr3LixAlDpOPcuXP5/vvv+d///kd0dDRTpkzhhRde4PDhw3h6erJ582YAbty4QXp6OosWLaq23xEjRrBu3ToWL15MTEwMy5cvx8LCotq2j8OiRYv44osvmD9/PleuXKFz58706tWLmzdvAvqI9TZt2pCamsr27du5fPkyb7/9NjqdDh8fHzp27Fjt+WXUqFF4e3s/cFwP2x7/ZZ4o9RL0Xta9e/eiUqlo06YNoaGhz8Ku/wxmCgXuA0bDjYsQexG098Sw71bqQyoDiRTyHqJbYWGtT9X0D3/mNhv563Cw1Yvq21nbUNvDE4DxA4eQmplBZl4uYpGYFmHhxKckk1tQwIEz+mgInQ4unzSjVZeqov4t6zf48wbwLBGJwN5KXyUzt4jjKfnEHrmBb3w64rR8bIM9qDWwKQp3OyQ6S4guRhSsP960Oh06QUAiEpOzqAD7Qa4onCQonKzRlFVw/O31aMrVtIsci3MLP37YmMz6Pfk0q29Ns5OXKUvNZ9fzS+j+82REYjFSRNgHu2Mf7G4wr0NdfZRVsxfb8835BOoMaYZvgD7SwdzDDgF9SmenmIEwLJsk4STR7zsRMrIVjZ2tONAvhLlnU1kbm8WxI1epc+0gpvsP0j6yHsXv12HW9R8A2NpsCr29GlLbSw5iERXlxcTG70etUXLz1nlUhSL4ogMjXm9NqVsiLlJvTqp308X5JULNW2MisiJT5cKuHWcok9/R07KD5Muw74cshr8dgEqtImH2xwzsP4Zz/a0pE2spiL1EkY0Ztpt3cb7/87z04ihaWNzzKMlrtWVVfkvedtwNInCzjkcn6L1/AcHtAXBxD2HQh5PZK0/hyrJiNFoxpUopadl6x+bxCwVM/fQi1vLDtAnYyy8pyYRb3eDs2hOYW9kDIiqUZcRdOU5BTjo6nZjkLDtC3U6gVF/GTpWIZ8svkMhzGNvjuCHtxtndk+zyYObt+Q7nCBHdTko5+Uki1/dcYkoDBxr5lVKqlCJGTc6NHyhPy+Onn54jJqaQCRP8+WqsA7kFYtYdGAGoOXcuj4KCym/oy8q0NbSj/zvRaXWce/37yrnid7lzcJyb/AMevRvVaBpmXFwcgiAQGBj4h/uws7PDycmJxMREQB91dujQIfr06WPQMvHz82P37t1VUvv+TG7evPnUqXqBgYFcuXLF8H3o0KF4e3vj5ubGlStXmDZtGjdu3KjiTLvL3cgpuVz+VHbcz7MY15QpU2jRogW9e/d+4DKzZs2iffv2KBQK9uzZw6uvvkpJSQmTJk0ytCksLMTCwgJBEAwOxEmTJlVy3q1fvx4/Pz9CQkIAGDJkCJGRkbRq1eqpxmREn2658MeHt1n0I7Rs+OelYY4aNYoZM2Zw5swZmjRpglqtZu3atVWizF588UUGDRoEwLRp02jevDkffPABnTt3BvQO+hdffLHSMuXl5Xz//fe4u+vvPb766iu6d+/OF198YXD42trasmTJEiQSCYGBgXTv3p39+/czbty4B9r8OP2am5uzYsUKgyPi22+/NSx3d39fsmQJPXv25LPPPsPZ2ZmvvvqKd999l759+xrmPywgw8g/B51Wyy8rvnlom18jvyGoSdNnloa5c+dOLCws0Gg0VFRUIBaLWbJkCRUVFcyZM4d9+/bRvHlzAGrXrs2xY8dYvnw5bdq0MaRYOjk5PfCFWWxsLBs3bmTv3r107NjR0M/TMH/+fKZNm8aQIUMAvTP54MGDLFy4kKVLl7J27Vqys7M5e/aswcb7Hexjx47l5Zdf5ssvv8TU1JQLFy4QFRXFtm3bkEgk1Y7rcbbHf5UnumM7ePAgPXr0QHmngp5UKmXlypW88MILz8S4/wyqCn1Kpbk1FOXem959FJQWg50z5KTCrWgQHhCx5+gOjTr8KeYa+Xtha2WFrZUV97usg331J81QP3+y8/Ko7eFB7LntOHgXVVk+PTv7T7L0T8JUBm721CtTkzD1R5IAaz9nWn4xjLLMQn0FTcogBMgQ8/6+Taw5dZrCMiVHZryNhbU1Cvm9i7ZUYUqb5aMNVTcBPOpYk7Uhm3KZCc2+fAGJTofcyQpBq0Mk1kem3XV83R+19uaxeBYqLGnsbM/nB2Oo3acRIpEIqZk+okun1pJx4qbBWXDx423Y+DrhFuGPXd4RHJUlgDeqkmgO+OjPw0JqAkVXE/C2ciBNmU90fjy93Rrya0oBM88n8XGQlLzyC0R7XUOaeifatMwU99K61FP0ZFRefdRUcCMpBs8T84jduROvOt6Uy+/bowpBjI6j7XOJ9r5ACWp80lvjmlKbl2+5cePmbm7cTCcz8QD1er9D66/2UaHR0blPGEWlmZSUZXM1JR0BEftLAmnvXECzjuPoH9SCS7s+51bSGXxrNUckQFcnZ8Jllsx85RKHWpqz0s2Bvj2uc+2qKyOHSFDFjoNCCVHiYERWGbRw0odJlhblgtiUk9HepN64zm9XppBX5groADEuttnYeJRx4LsE6s4x4VDXFjTbcwHzknIuxtiQXWQNQOZxgS1hapxaW4Ig4ofoDGJj/bl5S0Kz2jtpXutn9nz7M/vjJzP6zVdJS1OSWPIc9pIdOFplk13kSL16NmRllXP9uj4V08XFjJUrm9bcPv4vJOvo9SqRZJUQoCw5l6yj13FpG1xj660puYj7j3OlUsmYMWOIiIhg3bp1aLVa5s+fT/fu3Tl79ixyuZykpCSCg++NQ6PRoFarK72Jnj59OtOnT68R++7aWBN93B+FO378eMPnunXr4urqSocOHYiPj8fXt3K0/MmTJ4mJieGHH36oNP3o0aN07drV8F2lUiEIQqW0j+XLlzNs2DCqo6bHtX37dg4cOMDFixcfuswHH3xg+Fy/fn1KS0uZN29eJUeZpaUlFy5cQK1W89tvv/Hjjz/yySefVOrn9/fRL7zwAm3atOGrr77C0lL/suLll19mzZo1hjZlZWV07dq1UmTa/SltRvRcvlE1kuz3ZOXp2zUIeni7msLNzY3u3buzcuVKmjRpwo4dO6ioqGDgwIGV2tWrV8/w2dnZGdAfY/dPKy8vp6ioyJDu7OXlZXBmATRv3hydTseNGzcMDq2QkJBK+42rqytRUfe0NavjcfqtW7duJV2ymJgYwsLCKjmFIyIiDMuZmZmRmZlJkyZNDPMlEgkNGzY0Zif9C0i8Fl0lkuz3FObkkHgtmtp16z203R+lXbt2LFu2jNLSUhYsWIBUKqV///5ER0dTVlZGp06dKrVXqVTVRiY/iEuXLiGRSGrMkVRUVERaWhoRERGVpkdERBiKAV26dIn69es/UCutT58+TJgwgZ9//pkhQ4awevVq2rVr99Bo9ri4uBrZHv9GnshR9sEHH9CpUyeWLVuGmZkZ77//Pm+//bbRUfa03LoKuen6z7ZOkJ8NPoEgt9D/ATh5glstSI2vvg/vP/423Mi/l7tONIB1q/qRkJLC5n27KVXeiyy7eD2Gbq3bPrVOWbFax/9i8/EylzHYx+rRCzxjZDYKZFZy1EVKzN30kXhyp9/Z5aJDcT0XVUYRnTy9ub14L7rjSaQ7DcO1xT1dm/udZADtGlhxdnMDMJGC6v4o0HuvpHUISBDd0yADll1NQwecruUA9ayq6BSIZRK8u4URt+k0qkIl2nI1B1/8ltozGlPkepXnHWREBERwUd2Qb5JvAfC8XR4d6o/D3a85NwtuI5NqUFoq6LH1MAKwvjyO1p4VZMsyyQ5dQ7dh87GzsKdR4xC0WhUykSlqoYLsIjFJuw9ho1YTHxNHaF0brph6IxdpUDUVMSfpMJfdQtHJ9FV213ay58Cp2wyTxmBvGY+1Fdj2mIljvQ4MObuY7nbp1C5XcfzEERB0WJuYMWPcUHILChjR1puki1vJi9vOoLe+w1RhjdjEHF1iBiIB0guSMLt4gVeGJ7DBx5VlNm6onkvlVqotHScf4r0PE5BbOvL9DBOcyo5zbO17eIe0Ytq3PYi+VArc/8Sj/00y8h05cbmMT768xqkRLcgHDj/XksxX5OjE9vjYriMmvSWOthW81+sKYrHAnLi2JOUoqB++lO5dB3N8zz1tu7JSJS+9dA6xWECn649U3BONTn9JPXIkmybBt7GxsKdYacHnn4fTtatRn+xhKNMLarTd4+Ln54dIJKok2P+k5Obmkp2dTa1atQBYu3YtiYmJnDx50lC5eO3atdja2rJt2zaGDBmCm5tbpXLwW7ZsYfPmzfz4473wl5oWDfb393+qcYL+4ffuOKujaVO9QzguLq6Ko2zFihWEh4fTsGFleYhGjRpV2haLFy8mNTW1kuDyXUdBddT0uA4cOEB8fHyVKIL+/fvTqlWrBxZcaNq0KbNnz6aiogJTU33au1gsNrztDwoKIj4+nldeecXgLLx27RqnTp3izJkzlQT8tVot69evN0T5zJo1i7feesswv23btnz22WeG7W2kenILarZdTTF27FiGDx/OggULWLVqFYMHD65UBAOoVPTj7r1CddOe1Kn0+2IiIpGoRhxTj0pxNvLfojg/v0bb/RHMzc0N59+VK1cSFhZGZGSkIRvul19+qeQABgzn7sfhUZHRYrG4youch+kB1sQ6TUxMGDFiBKtWraJfv36sXbv2gWmjd7n7kuVpt8e/kSdylN3N73V11VfmmzdvHsuXLyc3Nxd7e6P2yh+irBjK7nsL6OgOHQbp08gqlHDjgl6XTKeDogecTBq20y9nxMgjqOXhwSuDhzJ/daRhmk4nMGXel7RtWA+tTkeLsPp4PEST5UFMv5jFyni9uKujmYT2Ln/tTZOZgxVdz35M7rlbeLQLAjMZIhMpFJdDyT1H4WsTBuHxSi5lt9UU2BdDXgkHxkbS99qnKMQi0D0kWkEmqeQoiz95kzot/AGQ/K42pkgmZXSQC0uPnEN87SCdz4s44uNMw1rehodpAAsPO9r+bzT7Ry7HxEqOMqsIc6knNqHOrE+wZ/axFBRya5736sW+sgJ+Fpsw1EUfmeJn443g5YhWIsHfyRJdUSqD7BOhzJaItKb8EniQRv3rMS++OxsylLzs8zWf2O3j88Nr+W6dD442hViX5VNiYkX0z26IBFB2kyJ2UWOm0ND6mgXfF1+lKCkfq+Mm/BbmjH/Fr3SxNEGHjpXnv2fdcz0Z4pAIQMy1X7ly/FfUKiV1GnaikX0ZUmsZ+bf1UYxadTlnds5HrSwmsMUQZq69hK2sBLOoz7BQVVDa9TnqmjiCADOW1ufyDTucVyeTmakB0gkPD+WFj6by3JCpALy0oLpiMwJikQ6dICErV8GP33nh3V2D1F7K5c1qMo+fIaOoFhKRD952UUQ0NyfARx952bVlKqu2+lFYZocQ/zrRqXPR6mSUaxREpbYCdOh0+t9Oo6usFXgjwZJVs/dSrLTlk49UKJUaxo/3+71xRu4gd7Wp0XaPi52dHZ07d2bp0qVVUuIACgoKHqlTtmjRIsRisUGAuqysDLFYXMkRfvf73QdSqVRaKV3CyckJuVxeaVpNM3ToUKZPn87FixervCVWq9WoVKqHPuweOHCAqKgopkyZ8sA2dx1ed+8T71JSUsLGjRuZO3dulWV+P247OzuKiooee1vU9Ljeeecdxo4dW6lN3bp1WbBgAT179nxgP5cuXcLW1vahDxbvvPMOvr6+TJkyhQYNGhAZGUnr1q1ZunRppXarVq0iMjLS4ChzcnKqVCVUKpXi7u7+TPeXfwP2NjXbrqbo1q0b5ubmLFu2jF27dnHkyJEa6TcpKYm0tDTc3PQvZk6dOoVYLDaI6/+Z/QYFBbF69WpKS0sNx9/x48cNy1lbW+Ps7MzZs2dp3bo1oHcQX7hwwVCl1sg/F8s7UjE11e5pEYvFTJ8+nTfeeIPY2FhMTU1JSkp6YDTY3ehIrfbBshl169ZFp9Nx+PBhQ+rl/Tg6OlJcXFzpGLj/pdDvsbKyws3NjePHj1ey6/jx44bIy3r16rFixQry8vIe+DJt7NixhIaGGqpu9+vX76HjCg4OfuT2+K/yRI6yoqIiHBwcDN8VCgVyuZzCwkKjo+xJib8CUaf0VS7vJ/aOVtmT4Prgt7tGjPwec7mckb368MOObegEAbFYhIO1nKibsfrIilvxTHh+GPY2T3bxuv995MN8S38mVv6uWPlXfmDDXA4VFpCWC2IRVs39GXH1K3QIqHNLiFt5CPtGtVHUcQO1BirU+lRIEykUlkKxUp/e6WQNGfec1zt7foFjcz+Do0yn029bAExliBytWdwzjNLrJ/kuWkeFBhb+ugeH3CImjhpCbS93lLkllOWWYFfPi04bJ5J6Jh6tSkvdka0RS8Tcvq5PMyzTCOS4uJCd48gvJkVMvRrHSB9Pvji1E61VIIHeARx7tR0dv9pGsUaEpVTAzqEOs4Jm8MKmNbgF6x2F0cVHyE4xYcN7DihjHHHuHkCwDBZUeCKX5lKa6kKjJovI0YQyeVx72hy9Sn+L8xQllVDrsC/10gWyXypnu8M51La5iEVtkEhl2LsHk5t6jStXCqhQ6l8EJFw+jHPn5wEBdUUpygozKrQSylUqXEwg9uJuMk9v4rZOQgtz/XlRdjsJeWAnlOpoYm7dSY3MLDds88BAK9asSSA42JoGDewIqG/JtVP3Kk8CmMnF1Ktry5kzBQAkxZpxsV4pdZtG45Z0gJYNLlGmsmDlibnczvPEKjYPtSYRkQhS03WEuB2jgdc+QKC4wpajcXdEyGXFDKy/iBupLbmS2va+NQrIZYU09L9Bap4b2w96ciPehJdeOkdYmC1NmzpgpCpOrQJReNhRlppXvU6ZCBQe9ji1qvno6aVLlxIREUGTJk2YNWsW9erVQ6PRsHfvXpYtW0ZMTIyhbXFxMRkZGajVahISElizZg0rVqxg7ty5BqdFp06dmDp1KhMmTGDixInodDo+/fRTpFKpoeLUX8HkyZP55Zdf6NChA7Nnz6Zly5ZYWlpy7tw5PvvsMyIjIw0PqBUVFWRkZKDVasnMzGTXrl3MnTuXHj16MGLECADi4+NZu3Yt3bp1w97enitXrjBlyhRat25dKW0MYMOGDWg0mmeSgVDT47q/muj9eHl5GaLOduzYQWZmJs2aNcPMzIy9e/cyZ86cSlFf1eHp6Unfvn2ZMWMGP//8Mz/88AOzZs2qovc7duxYvvzyS6Kjow3aZUaenLAAcLR7ePqlk52+3bOgsLCwyoOxvb09np6ejBo1infffRc/Pz+DLtDTYmZmxsiRI5k/fz5FRUVMmjSJQYMGPbQgxbPqd9iwYXz44YeMHDmSmTNnkp2dzcSJExk+fLghQnTixImGc2dgYCBfffUV+fn5D60KaOSfgU9wCFb2Dg9Nv7R2cMAn+M87vw0cOJCpU6eyfPly3nrrLaZMmYJOp6Nly5YUFhZy/PhxrKysGDlyJN7e3ohEInbu3Em3bt2Qy+VVRPp9fHwYOXIko0ePZvHixYSFhXH79m2ysrIYNGgQTZs2RaFQMH36dCZNmsTp06cfWThj6tSpfPjhh/j6+hIeHs6qVau4dOmSIdr8+eefZ86cOfTp04e5c+fi6urKxYsXcXNzM5xHgoKCaNasGdOmTWP06NGVotCqG5elpeUjt8d/lSdWld29ezfW1taG7zqdjv3793P16lXDtF69etWMdf9Gystg15qqDrI/gqUd1G8FcmO4s5Enw8fdgxf79uezlatxsNGf+O/emAhAflHxEzvK5oQ74i6X4mUuo6Pr33yfNJVBrco3eGJEmNpbEjL1vogBmVT/dxcnG/3f/fNVGtRlFWhVGmQOViTuvqJ/oO/ZUK8kLNFXhQQQm5lQLL73FmfzmYusnz6JCkcrxD4umIuzMHe0ArkJtp3Dse0cDjlFUKB3Ns3tEMiN/DJ87czJKsqEHLCwyGDheSsW7pgH5ZnAEfAaRNTNDJqaJ/DqkWQ8LWTMCBtFxdVEIvKknE4Lx1Sej8pGx2bNWFouF7P3o4Vc95bSvkMretn0R5Dnk7C1A86hlzi3+XUAjjiF89PU8ZSdy+fIwcWY5yn45s2+iMU9GTpwI98s+h8AjbpPYdP6KyzcdJihTc4jl5cgUldQlJeFpa0jF67Z8Oan+vSrVsMyGdcyhdJLR2kg11f1zbYMw8KqgjS7fmx6xY30hhK83MqJu63fr+bODaNTJxe++iqW775LQCYTc/VqV47s7MTU6Rcxk0q4VXKa/btyKc/y58yZAkIaptPc6iuy8tzYeeVlbOLO4u2qdzwqTEroVXcJP555n6ibdnz0pSUy/1i8zLfRKEx/k3c7N5AWvtuIK+6NmY01Xep+h0XRNZ7r2YvNx53ZtSsTgJYh5xDKUzhwuS+HonSE1rnnTC0sfLqQ+38zYomYRotGcGTAwjvifvfNvPPM1Gjh8BoV8r9L7dq1uXDhAp988glvvvkm6enpODo60rBhQ5YtW1ap7YwZM5gxYwYmJia4uLjQrFkz9u/fX8kBFhgYyI4dO/joo49o3rw5YrGY+vXrs2vXriqRVn8mpqam7N27lwULFhgeFBQKBUFBQUyaNKmSs+aurVKpFFtbW8LCwli8eDEjR440RMCamJiwb98+Fi5cSGlpKZ6envTv35/333+/yrojIyPp16/fY1UR/avH9TjIZDKWLl3KlClTEASBOnXq8OWXXz5UEP0uU6ZMoXnz5nz55Zfk5uYahMzvJygoiKCgICIjI/nyyy8f2y4jlZGIYfIwfXXLB/H6sGcn5H/o0KEqUY5jxoxhxYoVjBkzhjlz5lQR5H8a6tSpQ79+/ejWrRt5eXn06NGDr7/++i/pV6FQsHv3bl5//XUaN26MQqGgf//+lfbnadOmkZGRwYgRI5BIJIwfP57OnTtX0lAz8s9ELJHQfex41n0254Ftuo0Z/8yE/KtDKpXy2muv8fnnn5OQkICjoyNz587l1q1b2NjY0KBBA4MuqLu7Ox999BHvvPMOL774IiNGjKjWybVs2TKmT5/Oq6++Sm5uLl5eXoY+7OzsWLNmDVOnTuXbb7+lQ4cOzJw5s5K25++ZNGkShYWFvPnmm2RlZREcHMz27dvx89NnJJiYmLBnzx7efPNNunXrhkajITg4uEpU8pgxYzhx4gSjR4+uNP1B45o9e/ZDt8d/FZHwBCqoj3MTIRKJHhqmCPrINGtrawoLCw0ClP8ZLh2Fm5f+2LIKS4joAcoScPLQV8I0YuQpSM/O5at1P2Aqq7wvTe03FEVUBtT3AvsnK3MclV9O5M18rEzEDPKxIdTmX5zfrhOgrBxMZPqIs8dg+tLVfLpqo+H7vmVzaN84XB+5lnynsILcBNzvRB6VlkP6ndfhrnZgbsb55DyaLdiDRicgkSgxt8ygKPoKVOQAIvAcCDJLRrkks/rEHgDWT5qEddw25mX4c6DAC4A+vWcimOlLTu/YsAbdHY/Et3V/5njtfWjNrCkhhZPHJpGR2ojBdZ1Z2sUNe/dAbpdE8fHUfFZ/m8zk4deo55RLRPtB1O6sr2C5ZEksEyeeh3DwDjNlSb9iyqK3kiV0Z/IMc7RawAbMu6v5amwj7ItusePiSRwvzsfCoTVh9b0RiQTmrKjL8YvOhiLAAIcOdaBNGyc6dTrAvn16B9XXn1bgbHqU0FaDcK/TkFe/WM2hHakkXdKHq/t5xGArjSenxBNBEOgc8h02iiwEQUx2sQcWpoXczgtk2+VJNK+9jXYBG+5FRgpi1p55l+IKa2QmcrIK7GnSxJYpr/swfOQlNJp7l9H6PudQKtVcz9S/2ROJtAiC/kYwNbU3bm6VdWj+aTzr63fSljOce/37SsL+Ck97Gi0cjle/Jg9Z0ogRI0aq5/BZffXL+yPLnOz0TrI2jf8am44ePUqHDh1ITk5+qAbf4zJz5ky2bt360NSuv1O/1aHT6QgKCmLQoEGGisFG/tlEnzzBLyu+qRRZZu3gQLcx4wlp3uIvtOzfzezZs9m0aVOlas5Gnpwn8rQYq5A8BZnJCMd2UFZcgrn5Y5RF9wzQO8Tk5mBlCwEN4a7X3caYuvO3RKmG6+kQ6KJ3dPwDcHW0J9zfn5iEW4ZpVuZ1yB2wAUVxFoKbDaIdEx/7dWtskYpmu24bvn8RU0CwtQknu/ggFf8LQ+nFIrB4jOP5Pma9NJwdh08Tfes2ZiYm1PX10VdcM5Xpo9Uq1GBzX0SeuRl43dGmueOMi88pQXPHi6PVyhGVeYOTA+LCGOSmLpQqU7EWzOhQ249NKe5E1K1AbeFPgdgWD/NsKPBCLFFhhgthlsG4mfpS5u/C3thM6pgW4aayJCQnkBTr2pRZbaJRs0WUXm3Cc0UBnN0hRhPgxAqzz1C1qUOvuAl0aJoBQJ7qErXRO8qCgqwQBYLQBm5TwUFdXb54dyTDh59Eq00EQNIfSi1kjN92mcX2J7FLsmDF0fm0Co6iQSP9C5d+HW7TvoUGtUVbFiyMp2dPd9q00W+P994L4cCBTHQ6mDf/OrXss2iyuytyc0v695pDlxEalssyOXzWmZspQdwV+fe2u4qdeSbH43tx5OZABEGClVkOTWvtAMDHOd3w8wIg0lHH6RLmJgXsiHoFgAvn89iwybySk6xOHQvemmDF4sU3DNM8bG7gbhNP0wZq3Nyef6J95b+IV78mePRuRNbR6yjTC5C72uDUKvCZRJIZMWLkv0GbxtCyob66ZW6BXpMsLODZRZI9jIqKCrKzs5k5cyYDBw6sESfZP5Xbt2+zZ88e2rRpQ0VFBUuWLCEhIYGhQ4f+1aYZqSFCmrcgqElTEq9FU5yfj6WtLT7BIX9qJNl/iZKSEhITE1myZAkff/zxX23OP54aDUnS6XT8+uuv9OjRoya7/edTXADHd5KenI6bu9Mjm2NlB006GtK1jPwNSSuANzZAhQY+6gWf/AqxGfp0IVcrGNwEjsVBci7YKtA28UE0qSNi6d8vCnBQl27E3Irn6PlzyGRSomJb41ByAQAhvZBzFy7SuHHDR/SiJ6m0amrZtUIVg4+msDbCHVOpcZ+WSu/dHJSrVEz+Yjkb9h4hIiyYfcvmIrOqJuLod9Fqfet58ForP+KzSxhY3wuVRsPLm87TXNaN45p9kH+eQuDjI3mUSjtxNE7GnpiLiGiIQifmdfsUxM+doJ/NcEoOn+K35BTUmq0MdPJlkOUVBJGOI7EiyivceUP1Ee+eOsIlKxVnpCmsaOOOKisJvMDEO47h7yYjiTdFq63AzNSF2buv0iXQhXEnzmDRWkfxnaqTt3JL0Gp1hIXZsGWLBFtbE3IlFWjRoRMEBAvYdsCL7DxrthxrR4vGBwnx1xLsWwQUEdyyAXM/HVxpO+Tnq7j7/iYhJ4yEnDBMZaXU9zqErOQ8tnIRLvalhvZikRqdIKNE7UJU2RwOx3pxtypmUbk9wfXcicrRsO3SeLoEKgl0OYtGJ0GtNSUmoym+jldoH7iWi0kd0ApmBDpcQ0QAwp1LaVxcCV6NXqHzkEucnpsLQD2Po4R5HIYyyE65gaPHMxLD+RchlohxaRv8V5thxIiRfxESMTQIenS7Z826desYM2YM4eHhfP/993+1OX8pYrGY1atX89ZbbyEIAqGhoezbt4+goL/BD2WkxhBLJNSuW+/RDY08Na+99hrr1q2jT58+VdIujTw5T5R6+SDi4uJYuXIlq1evJjs7+5GlT/9zqZcXj0DcZZJup+Hl7VZZ5Psuds7QbgAU5YKFDUhl1XZl5K9DqSzn449XIpFI8LiWTeSvh/E3s+A9pzoEmunTEwVBqCRCWqrVUC7osJeakGJSgfXON7F0+vsVvlCr1Sxa8z2l5UqkEitKf2nM0Io9xAZriPIzZWi3Hvh5+zyyH0EQsFofS3Wxp3VtTDjVtXLhiSPnz5KZk0PbJk1xtK2+esu/jeLSMpqOnEJsUgrdI5qw8+hpgxzTlfVfE1rH54n7jMsuJmDOTkJVVlwpPgAFl/UzHCLo3KQVu69nV2pvphXTwNGOyfVzmHQwn4ziYtCUIC48w3MyKfHmpWSXmbNq1BuUdI3kw+5pSCJSyEuxZoZXKGs0XjwXegRHlQmFJwcjFXkzqq8lOgtnAlf8Rj1dLK4uLgyxTyCx3IJbFZYcLHZDsdeTixfysLUxITTUhqMxOfA8IAYvkxI89pVy4qIzIqmO9yefwItzePjq9YXqdRiHm1+zSuOYPv0yn38eg04nGNIyOwevpKH3PsJa9sDKzoncrBy+3yTgXduL5p06MHqivhiAk5MpUnJJy9Ifu3W9owl23MGGc+8AoDAppGmtX7iZ25bUHBeEOw41sUhAJ+iP8e51l5Nf5sCJ+P4Gm2QyUKtBoZBgZSUlzGk9Dd03ASImLr2MS626T/z7/p34z12/jRgxYsSIESNGjPzn+MPhLUqlkk2bNrFixQqOHz9Oq1atmDFjRrWipP95HFwh7jKxN25z5XIsdvbWtIi4I+7p6A4uXuAdqI8gs3H8a239m1FRoWLDhr20a9cItVrD9u2HuXEjiQ8/HIuLy70U1BMnrrB2xmoimoYyePYoYmIS2LzpAId3neLd90dz6XoCHTs24erVeBo0CCA4Q8WKb37mkLqIqTNeJCzMnytXbrL5/e/om6QmPDwAVr54X+4VLFiwjjlzVgMgEYnQCgJnlIX8VphFakgHTMUSRCIRakHHrqJsOls5Yi6Rsj43CSepKT2tnVF3/gpsLWBKJ+gZ9mdvzgdSrqqgtFxfCVGjLaLlWypuqsKJio0CwET2eKmkIpGICEc5R7OVVebd/l202e20VA6eOX1n/SqG9+z9NEP4RyDodGz5ajPXE5MxsVCRXZjPXfEtMxMZfl7uf6jfOo6WXJ7aleTzqXx6sB1qMxuuU0GpZQAf91OQuvkC6elBlBSbo9EJlEt0nMjLIfW8GRk6WzDXF27QFegQBq9keu2+yJBT28qXW7WdaNZnL6UhuaAV43u7Ea9l1censIKyslx+yUhiyTpz4tOkpDW4gij/Eq4VxxhXT6/RVde8gLrmBXg41EXcA+T9vsEi9ConX3sfilz0Om9iETlK8AuOhkJnBK2YaKc+WMfsorz0JM17T8bFtwl7Vk8nLz2eTqPmYO/qy7x5MWi1dzxk1klgncq19CbU99pP1InfkMi90CqTaNmoNdfKn+d2jhWmJpcIcDzMldR2mEjESERqTGQa2oRdRFqagLU8i0KlE56210nKC2b+Jw7MWmTDtWtF1KplTkLCvQi1MpUtap1Npd/i7nuisjItZWVaMjL60qJNCH36B/zjnWRGjBgxYsSIESNGjPwXeGJH2dmzZ1mxYgXr16/H19eXYcOGceLECb7++muCg42pEtWi0T85dXxO/+CoE6AisAmmzu56Uf7/GOnpOXz00bfUru3O22/ry7EXF5dyeP85GhZAtLKI41kZmJub8e67X6PRaCsJeQN8++1WfHxcCRcp6G3pzIsXj6NFQH4ljR92HWX3hag7wuQiDvacgoDeiSMIAnIzE/Z6NmTczZMARN9K5vz57+nQYQI5OQUskcjIFuSID92A9oGGdVpZ6XWjTEViasvNiSkrBqBE0Fay7bWUq1wuL6antV53IsTMktX5KfS0dkYqAHmlCB/8jObDrQgKGSZSKYxtBS/UTHnwP4KluQVisdigQ5iTn8Dz3Xrg7myLjaUV3m5uj93Xrx08sVwfW2W6l6Ly6cZCYY5ELEar02Ftafl0A/iHEP35TpTv/0KDt+Pw6BmHNi8KyfX6aFRiBnZqhanJH48kDXWzwVGl4nCQLYdSa9Nx62WG1vfhuWVHKS31xcwshQptLRBLCQjZTG3/XUSdHwUFEfc6iQqgh90gRllMA+D9kzfg8xcQ2e4BchFEEBg0GN+mgVRUhHDw6Dy0Or0zOatcxfGruykpvsUOsRsvqFTITfQO1jJpA95rq9+/hWWfseHYBzi2uIj90VZk7TOlzFXGuPq3KTb1gDtyeed/TKPbsY20rHDBTmzBzGlb+WqpM4EuiZy7MJIjSe9TP9ySs+eKqGV/BVeXC5w0laBWWHIzqz6ZhbUIbtycoRMa0LX3DSo08egEGSLExGU3BMSotApq2V1iVLfdVOReRiuB8a3eQq2VY2WhofXAaXj4O3H+/HPExhahUEjp1+8oyclltGigpKF6GjExOWRbppGtNqG0vPrCFW0HjKde67+u2qERI0aMGDFixIgRI0YenydylNWrV4+ioiKGDh3KiRMnCAkJAeCdd955Jsb9a8jLuPfZ0w9xaHNMLaz/Onv+Im7eTOLrr3/i2LHLnDsXA8B77y3D3d2JpKR0BAGsRBKKBS2/zwf+fYKwVqsjPj6VDzzrsTvnFneXiC4v5lJsFhHc5hReqJEg6N1k3M0yVparyBKpMRdLKNVpcXXVR6bddRLpEBBEIvCvLLA6YcJArKzMcUstodHaKCJzk7lUXsgQazfM7hOlvK1ScrqsgLmZcbSxsGdeVjzvO+vL+oruVBUUIUKmA0rUgBrm74H1Z2DrRPiLdLy6RLTi16OHAUjLykQiFtMk9Mk1BcQiETIRqH/3m10tVJNcqsbTXO8MsrexYdyAQeTk5xNYq/ZT2/9PQJmej4VWTGC9TEoAiV02CqcSilKsSL+/HNcfpMhcTp3Pf6NEraWFjwPNfRz44ZwnVOSiij0FwglweQ6/oO1IJBqCw9ZSy28XJmbFJJ6sQ65LONfOB8Id/32ZWsqCszexthqHR+195GYF4dLTBwCdIGf11jqobDz4bGotXhvuTtfv9nEkH9Q6mBltzev15Pz2WyAHT1qyauL7uHU9gIX1NFQ3HBjukE+zD05RVCLjo+VNiOiRTaaZHLFYQKcT4RdYzEmLRH65cISkGd8Tc/ZtypROnEroiUyyibNx+TT13cvEdlsxNy0go9CH5OSPqCjKwjTwKq38NiO29kciVvNau9f56fwbJOTWQ0CMVHwvujEhL5zk9MM4mejrpYjRIpMUo1HBnu8/Ye3ZdyhS5/K/b1ry/PM+XLnSDYDdu9Pp0uUQAANtg8muk8mhiypAoI5nLtqyZMpU1gQ4nyPQJxwwOsqMGDFixIgRI0aMGPkn8EQaZaampgwePJjhw4fTsWNHgxaTTCbj8uXLjx1R9p/TOCkpgLP7wcRML9Ivqz7q4N/MwYPn6NNnKkVFpY9ufIffR5FVx/M2bnzo7Ee7+FM4SU0Y7uCJy6z+/Dx+OGUayMACS/sQzimVSGuZUZRXgshBRsJn8yg6dYszdmIGvtgNKysLzp+PYdPaPfS3cKbxsLbg71L9SguVMPQbSC2ABl4Q6g4edrD8EOSWcr28hA8yblA31JcZ7dvCrWxutnLi4JHDNL+mpa6gT3MTEAyOMwNiEWx7DTz/fL2umFtxbNy9y/C9WVg4nVu0/EN9HcgooefB1CrT7UzEdHGz4H9NXZD8G6tgPoKK3GJ2vBnJIueNFFhmknPTjsxr9rjY2fPr4lmEB/g+9Tr23cjgbFIuY5v7Mmb9aXZcTYH8K5B/HgCpbSg9nr+KxuIICCCRagzLXj4/Akf7GJqJBiCUB3Nc9gXWdvEkxw4iPqEBIPBh67P4Jw5i0uwUcgs0rIkMYVhrvbM5R6JjwbE9mMntsHUOppG5Hc0b7gVA7pLNc1smozxTi5CdGTRu3RpbR32kon/EWK5FHyY6NYfDu5xAJMHjJ1d0VqYo1m7Ccs0GtsTO4Xq8D+ZmuZRWKECQ0S7gJ8QiDX5OF0gubsIvF4cA4GZzE1OJksTcEPq2Pk2g+RIKy+woqnDgZHxPUvProBWZo1Lr3xW5WMUxOmKGfiOIJMhkMtSqcq6lNWXr5dcBsLKSUlg4EICrJ/Yw+835bDw1ChDRwdeZ87l5FBToHXDvjNjFiZPFHLmpb791awt69/Z+6t/278B/7vptxIgRI0aMGDFi5D/HE0WU3bp1i9WrV/PKK6+gVCp5/vnnGTZsWCXxciN6ygoLiT9zFt+mTVBY2UC7/o9c5t/IwoXr+PzzH0hPz3loO4lEjE6rI9TShqjiAhCLGDW6B5s3HsDMzJQPPxzLzp3H2LXrJIIgYGtriZeXCycKSrj6YgPSxn6or0DpZAVSMfU8fuLXLxYR3r0rnSe+CkBM8m2+2rmV9vXq4x3RBLo24X7FoIYNg2jY8DEq7VjLYcsEvcPM6b6UwQo1fLGHQDMLNoW0gGUvQF0PBEHg644DUZVXEKUQsbCsARLhAceMToAXvoU5/SGizqNtqSG0Wi23klP0nsk7x/Opy5cor6igWXAIdnb2yGSPnxbY3sWCtP51cNscV2l6nkrH2sQihte2prVzNdUdq6FMo2NtQhH+ViaPvczfFVN7Sza6lHF8nw1gY5iu1mjwcauZEvEdA1zoGKB38rbwdmDH1TQwrwXFN0DQMqpja85cbcaVlDGEhK2hTuBv9+xQWRIX1w23jtNQVcjxMtVrzdVve4hrtiLk4gvUL/Zk5S855BboHWxyG1vwdASNFgeFKZ/UuldlR6nUEBRkRUxMEe5Nr4Mg4Jt5C3MzKcmxl1FYWGPjUgef4MaI3Ooy4ovd5AeqeLNuAMcmJeDufQynsxsA6OP3HkeE/pRIW3MlVo6ZTImHTQyXU9qy//oLmEpLMZMVU662xMbBmWtxeifOkajGNO9dCzITsFbkYR26ij23PmH+bBW9RogBMRlFtdHqJMhk4OodROqtqwC42cTCnYhUgIKcDBRWjnTtG09K1os4WCTTvaOGur5n6agV8/nKYHSCjJZdurD30B7Ddigo0NbIb2vEiBEjRowYMWLEiJFnzxM5ytzd3Xnvvfd47733OHDgACtXriQiIgKNRsPq1asZO3Ys/v7+z8rWfxSzWnUgOeoq3uFhzLl4+q825y9h4sT5LFmy8aFt5HJTZswYw9Spw5HcSV/cuusoIz5ZwHeXTvHdug94oVt7AJo2DeG3304AeqfW3r1LHthv3U4dqdupY6VpQZ7efP3K608zpHuYSis7yQAaeOunqzQwvRvU1eeviUQi7FycyEhMxtrZAVH/zjBvT9VosrsUlsOEH9HJxKS93Ajn4R2RPYV21ePw67EjXLgWDb+z6fL1GLb9sBIvL2/ef38WUunjnzKsTSTYyyC3miK4x7NLUesEtqUUM6yWNU0d5FXaaHUCi67nsfF2MVEFFYhFcKyzN2G2Zk86vL8NKrUaQVc1TDK3sJicgiJsLC1qbF1JZdFEiz8ABoKJNXgNBgT25x0iIbkZiEREX34Bz1pHkMnKuB7dj9Sk5gSGbkSlUmBiWoZOJ0Ys1hFq3ZovR3yOTquBCjVnL0ex/UAJMpkYX18LMJXp/36HXC7l/PnOJCeX4VarK7vXi8gsPUP79z/EN7wDMtN7v3stewvi3utBvlKFr4Ml52tfJ+F8AhfvzBeLBJydxJw4pa8aW66WU66xoFytPw4rNOZ0DPoR/2AfXv3oExo23EVFhY6x40PwsG1KfnYa6CrILvakf6cUJMpSOgTGklviip/zBSRiLaZmVpgq7v0GMektEKFBQEZRkYZ+LcfRtYOIlKznAcgp8cTVch8hd3zafdvewKr0azb/uo5fzyxm1uzr2NubMWyYT439rkaMGDFixIgRI0aMGHm2/OGql+3bt6d9+/YUFhby448/snLlSubPn09oaChXrlypSRv/cWhUKlKv6TW4Uq5Go9NqEd+nYfVfYO3aXdU6yTw8nGjWLJSXX+7H7duZ9OnTGju7ynptF2/eokRZDsCek+cNjrKGDYOIjHyf8+evM3XqC89+EE9KiBtsnwjlavC2rzRr8pI53Dh3mTrhoYgd7aGBD3x/An7TR66gMIEyVaVlxGod275ZQ/nObUzZ/DVi8bPTLissLtJ/EOldZXeLH5RkpAOQlHSbwsIC7O0dHthHdehEYkBXKVINQeDjqDwkojy0AmxJKialv1+VZdckFPLB5XuRiDoBIg8m41J8Emc7WzLcGzAm0BEXxeNV5Pw78Py7n/LzIX0RCRHgYG5OgI8nvTpGUMfz8QsmPA6bUz+lSL4VH18b8nICUVikk5HahISE5lCRBaaOoExG0KoQmwo4Ol5D6W2PjV0iJiZlAIjFOnzNGzDKe57+u0QKCimzv2hMq86eeHgoCAl5uN6iXC7F318f3dV/+FIY/uC2duam2JnrU9NrBTckN/EoxaYDKMk6h6NlMum5Ntx15rpYJ+NjH41YpCEhtz4KCzPmfv8djRrpj73bt3tRWKhGk3OAHz9eD4BTrSYMeOcjfPx8qSgvJ+LXJmhU+nNNdrEbdro0sorciSvqT0yiA1GprQGwlmdSXG5Han4dChIWEhHsR2lxIVdTW3Ii2o9WzW6CIFBLsQmluoS4mztxcu7BkiWNn/yHM2LEiBEjRowYMWLEyF/KUz95W1tb8+qrr3Lu3DkuXLhA27Zta8CsfyhaLVw6gvTSYV5avhi/Fs0YvXzJf8pJtmjRekSiJgwbNqPKPA8PJy5c+IFNmz6lQ4cmjB7ds4qTbM+eU8x+838IxWqcbayZOKR3pfmjR/di6dK38fGpWadCjeFsVcVJBmBpa0OjTm2wcbwzL8gV2gTon/lNJND8PjF7e31ES4FIhZmZCS8mOZDS+F1OTfv6mZndJaI1QbV9kUmlhkIKclNTurZpi62tHe3adXxiJ5laJ5Cv0hdIqF+RVGW+9k5kVX6FlhVRyVXmyyX3Tk/ugpKmmiJuFsSiLisiJeU2+y9H4bctgfQyTZVl/64cv3zN8FkAsktLKT2XyP827WTYe5+h1tTcWAIsmyESQVij1bTr8g6OzvfWTWk8JKyCzH2GyEZHlxgaNvsGraayhmJ86QWmRVWuyCoSiejc2fWRTrKnwc4tgPYjF7Bg4xp23vyCz3f/wKmbbRnY34XnOlqzaWNTWvYaz1sLvkFZMZSCggEGJxmAs7Mcf38rnH1CMZHrj6m6ET2o37oLtq5+uNSqy3Mj5xrax2XXJ7OoNvsOKbmY1Jao1DaAiLb+6ygpt0MnyCipsAGgtdeXdAuNpHPIao5c8Gbshy3Y/FMUudkZJOYG4edd8My2y38CQYCyCigu0///+FKqf5iMjAwmTpxI7dq1MTU1xdPTk549e7J//35DGx8fH0QiESKRCLlcjo+PD4MGDeLAgQNV+jt79iwdOnTAxsYGW1tbOnfuzOXLl2vE1lGjRhnsqO7Px8fngcuqVCo+//xzwsLCUCgUODg4EBERwapVq1Cr1VX6l8lkODs706lTJ1auXGkoenOXtm3bVln/yy+/bJi/evXqB9qZlZVVI9vjWYzrLoIg0LVrV0QiEVu3bq00r7oxrV+/vtqxi8ViXF1dGTx4MElJVa+H0dHRDBo0CEdHR0xNTfH392fGjBmUlZXV2Db6r6PVarly4SqH9h7jyoWraLXPPiX+7j53/zFxlwkTJiASiRg1alSl6SdPnkQikdC9e/cqyyQmJiISibh06RIzZ8586HnAKItj5O+CTtCRUZBGQlYcGQVp6ITqz7c1waOOiZkzZz6zdRv59/GHI8qqIzw8nMWLF9dkl/8ohMQYRDf1N8It69el5fFDf61BfzI3btxm8uQvK00zMzPBycmWpKRMUlKy2LHjKC++2POBF/CoqHgEtRZiC3m+ezcah/yLU3m7hEKwmz5d00oOQafARgG9wmDxPk4e2EdEkRN2Whl2yPDcnUV85iLSe/tRq24Q7nVq1ZgpDra2DOrclXmrVhicNWYmprRr15F27To+YunqkYlFeCqkJJdpkCJgqlNRITa5F1l23/8zoovo56/BzvTeKWmQjxVXCyqIuXmd4JwrnDH1JltiTqLUjqsmbhSIzBAEaLo+gR+vu9HqA3OwrMaQvxHNgrzZfkIfcSsWgaOZhIuUQ1o5t9IyGdmzE881a1Aj6+rmMoFdGctJUl5FgpRadfZSXgTxcX3RWQaAIBDa7CymisqRjIX5Ppia5WPvGEdmeigSsRbB6Sz9jtvxfvBaGth2qRH7HgepTJ9mu3hxQ+bPv07fvh68917IvQbPtXlkH/ZudZi8/DrFeWl4+FeO8Gra41XWrD5HQlwWJ+L74Gx5myK1N+s2tGFA759Jy3PHwSIDraBPKzWRVmBmYUN5SQEAclkJADn5YmwUBbg4eeKkUTHiw7drYPT/UUqUkF0I2vtupCVicLQGi6op2jVBYmIiERER2NjYMG/ePOrWrYtarWb37t1MmDCB69evG9rOmjWLcePGoVKpSExMZM2aNXTs2JHZs2fz3nvv6YdQUkKXLl3o1asXX3/9NRqNhg8//JDOnTuTnJxcrd7j6tWrWb16NYcOHXqkvYsWLeLTTz81fHd1dWXVqlV06aI/NiUPeDmnUqkMDrvZs2cTERGBlZUVp06dYv78+dSvX5/w8HAAunTpwqpVq9BqtWRmZrJr1y5ef/11fvrpJ7Zv314pDX/cuHHMmjXL8F2huKclOXjwYINddxk1ahTl5eU4OTlVa+fMmTNJTExk9erVj9wWz3JcAAsXLnyow+H+7Q5gY2NTab6VlRU3btxAEAQSEhJ49dVXGThwIKdP35PkOHXqFB07dqRjx4788ssvODs7c+bMGd58803279/PwYMHMTGpPnJaJBKRkJDwUOeoETh++BTfLFxFTnauYZqDoz3jJ79IRJtmz3Tdnp6erF+/ngULFiCX689h5eXlrF27Fi8vryrtIyMjmThxIpGRkaSlpeHmVv2L4bfeequSA65x48aMHz+ecePGPZuBGDHyB7idk8DZ+BOUqe4Vc1OYmNPYtwXeDjX3HHOX9PR0w+cNGzYwY8YMbty4YZhmYfF4EicqleqB510j/x2eyFHWvn37R7YRiUSV3sD+V1j/zvuoMuMZ0a0FAKVaMP+LbfozmTDhc77++qcq0/fuXUJqajbDhs3A1taS48cvM27cHIYO7cwPP3xUpf3Ysb05e/YapaVK3nrrb5heWdN43Vfdcmyre5/f6kK719ry26B3CCzRP3SIEOF7qYDEqzuYb76C91ctxr62R42a83y3Hqz79RfKypUE1qr96AUewcfhjow9mc45Uy+EB2myCQKFSPHcEo+fuYx5DZ04lVnBopu5KHUCjcqV+CHmlKk3KrEJMTLXe042IFeuY4xvBvv3eOHZ/9lquT0taWn3Igl0ArTyNmd7bBEqHViZKwipXfWm+WmYG3qU6KLDeCvqEl9ykc90Q0jL6AyAR/00vPyj7tmjE1Fc6ImtQyz2jnGkpzTgzPE3qd9kOQ6iGHSiAube6MfaJvnIxH9u5d4hQ7wZMuSPV420dnDH2sG9ynSpzISZ33zL/PnXeW54IY3rjKBumyHYOHpy7ZYn5aUFxF0UKJi2h5QsG1r7bcS/YRd2H7UnIzGGY/F9advKkkVf1KNe45tPM0QjoHeSZeRXna7V6ae78EycZa+++ioikYgzZ85gbn7vyh0SEsLo0aMrtbW0tMTFRV8sw8vLi9atW+Pq6sqMGTMYMGAAAQEBXL9+nby8PGbNmoWnpycAH374IfXq1eP27dvUqfN0hVqsra2xtq4czWljY2Ow60EsXLiQI0eOcO7cOerXr2+YXrt2bQYOHIhKdc9pbmpqaujP3d2dBg0a0KxZMzp06GDQpL2LQqF44LrlcrnBOQCQnZ3NgQMHiIyMfPwBP4JnNa5Lly7xxRdfcO7cOVxdXatd96O2u0gkMsx3dXVlzJgxTJo0iaKiIqysrBAEgTFjxhAUFMSWLVsMEgve3t74+/tTv359FixYwLRp0/74BvqPc/zwKea8N7/K9JzsXOa8N5/pn7z1TJ1lDRo0ID4+ni1btjBs2DAAtmzZgpeXF7VqVXYUlJSUsGHDBs6dO0dGRgarV69m+vTp1fZrYWFR6aFfIpFUOj8ZMfJXczsngcMxe6tML1OVcjhmL22COtW4s+z+/d/a2rrSOfhh+Pj4MGbMGG7evMnWrVvp168fq1ev5tixY7z77rucO3cOBwcH+vbty9y5cw33Cunp6YwdO5YDBw7g4uLCJ598wvTp05k8eTKTJ0+u0bEZ+fN5otTLQ4cOkZCQQHBwMGFhYdX+1atX71nZ+rfj9uUr/DD5LXZ8Pp8dn83ndlYe3+45zZpDF0jNK/6rzftT0Gg0dO8+uVonGYCdnRWDB3ciK2sXSUnbWbNmFzqdjjVrfqOwsKRKe2trC9av/4QdO77Ezc3xWZv/t8bMzIyIFe/yW4gGFfeiK9pqnJlfWA+7AZGw+2qNrtPD2YVRvfsgEok4cfkikVuq/10flwHeVuQN9ucFRx3uIiV34xwkgInujsr/fU6vm6VqXjiSzqc3clDeSc08Z+bNYqu2qMQmVdrfJdVKw0fm2ZWmXcgtZ0dKMbo/IW3rcXmlX3cUogpsTUU0cDGjqEJn+GWnDOuLu9OTpbc+CnOpNU3seuFsVov0TB9EEi1NIhbSuuOHBIb+jMxEaWgrEglY2ybh4nYZnVZKebktAGkpjdHp9JcKEWIE/j7bsyZwdpYzb1593ninLa0GTMXGUe/YkFvYYOvsQ+MuY9l7eRV7Dg5h7PSP6Pv6CiJ3fEXd7vN569027D/UnXqNQx6xFiOPRBD0kWQPI6ewxtMw8/Ly2LVrFxMmTKjkJLvL7yOEquP1119HEAS2bdsGQEBAAPb29kRGRqJSqVAqlURGRhIUFPSXRv78+OOPdOzYsZIz6S4ymaza8d9P+/btCQsLY8uWLVX6dXBwIDQ0lHffffeh6YLff/89CoWCAQMG/LFBVMOzGFdZWRlDhw5l6dKlD33ImjBhAg4ODjRp0oSVK1ciPGT/zMrK4ueff0YikRii/i5dusS1a9d44403quiQhoWF0bFjR9atW/dQ+408GK1WyzcLVz20zTeLVj3zNMzRo0ezatU9O1auXMmLL75Ypd3GjRsJDAwkICCAF1544ZH7lBEjf1d0go6z8Sce2ubsrRPPNA3zSZk/fz5hYWFcvHiRDz74gPj4eLp06UL//v25cuUKGzZs4NixY7z22muGZUaMGEFaWhqHDh1i8+bNfPPNNzUqK2Dkr+WJIso+++wzVq1axaZNmxg2bBijR48mNDT0Wdn2t+VQ5CpunjzN2S1bKc0vMExPPH2FkvBAGob4Uqde3b/OwD8JrVbLSy/N5dc9lU+EIpEIQRAwMZGhUOhTp+5qkY0c2Z1vv91K796tsbauuQp//1acnJzpsmYWp3fuR/LRdhpr7JHcjczSgfa3KCSda/YYvJ2eZrgxS8vKfOr+xCIR/+ukdySkl2m4XlRBKycFgdviSS+venNaQtWLpvAYhQzOqMsNn8/nKmm7NwmdAFOD7ZgZ9vdwun753S7KBBPKKgTKsivQ6MrR3rkH9nR+djauPn2LF9fdwN37ZQpyQoho/wFQWqVdyu2GyBXFxF3vQUj4j9QJ3EF5uTW2mV/Tuv51IhwGYiL+51YdfRo8A5viGdjU8P2zz6o+lBt5CpSqyumW1aHR6dspai6iMS4uDkEQCAwM/MN92NnZ4eTkRGJiIqCPOjt06BB9+vRh9uzZAPj5+bF79+4nqhxc09y8efOpdWQDAwMrFWwaOnQo3t7euLm5ceXKFaZNm8aNGzeqONPuEhkZydChQytFmT0tz2JcU6ZMoUWLFvTu3fuBy8yaNYv27dujUCjYs2cPr776KiUlJUyaNMnQprCwEAsLCwRBMDgQJ02aZHDexcbGAhAUFFTtOoKCgjh27NhTje2/TPTlmErpltWRk5VL9OUY6jV4ds8zL7zwAu+++y63b98G4Pjx46xfv75KqnVkZCQvvKDPpujSpQuFhYUcPnz4v63/bOQfSVZhRqV0y+ooqyglqzADF5u/h+50+/btefPNNw3fx44dy7BhwwyRYX5+fixevJg2bdqwbNkyEhMT2bdvH2fPnqVRo0YArFixAj+/qgXKjPwzeaI7tqlTpzJ16lROnjzJypUriYiIICAggNGjRzN06FCsrKyelZ3PjNL8fKL27sc/ojl27lVTc35PwvkLfDv2lWrn2Yb6IbMwJzopk66mVn93uaSnQq1W4+PTm7S0nCrzAhr68NILfWjaJKSK6P4330xnwYIpmJs/G62ZfyMikYhmPTuibRtBRZcvMS3Va4ip0FLc2oeqpQP+OCq1mqtxcYbvOkEgPTsbV8eaceK4KqS4KvSnneG+1nwenUdTezMqtAKXCipwx4RUVI/opXq8zO+lXSaVargTkEZiqfqp7a4pSlQV3K3aWKG995bYRCrl5TlfsWr7Hn5bPBuLGj4+bufrb1ZSb7cEICWpGX6Bv1VqIxKBu9d5Em40pajQg1OHp+Pocom87ACkzmGMqTW+Rm0yYqQSjxvRUcORHzUVrSEIgkHLSqlUMmbMGCIiIli3bh1arZb58+fTvXt3zp49i1wuJykpieDgYMPyGo0GtVpdKZVq+vTpD0y7+qM21kQf92t2jR9/77xQt25dXF1d6dChA/Hx8fj6+lZa9uTJk8TExPDDDz9Umn706FG6du1q+K5SqRAEgZ9+uhfRvHz5ckPaWnU2PS33j2v79u0cOHCAixcvPnSZDz74wPC5fv36lJaWMm/evEqOMktLSy5cuIBarea3337jxx9/5JNPPvnDY+jatStHjx6tNC0kJMRgu7e3N9HR0Y/V13+BvNyCGm33R3F0dKR79+6sXr0aQRDo3r07Dg6VI8hv3LjBmTNn+PnnnwGQSqUMHjyYyMhIo6PMyD8OperxCpE8brs/g7vOrrtcvnyZK1eu8OOPPxqmCYKATqcjISGB2NhYpFIpDRrc0xauU6cOtra2f5rNRp4tf+jVZvPmzWnevDmLFi1i06ZNLF26lLfeeou0tLR/lLNMXVHBtNAG5KelIzUxwc7DHUEQMLOwYPiiLwhu27qKiKvJfSK1v6c0JQMzGys0Wi2bP5zNqK8WPOsh/GWMHDmrWicZwPVzCVzsextXjQtNtNoqwsJGJ9kfQ2IpR7JzMj90m0SKUEKKpIzPO059qj5vpSSTlpVFg6BgFHI5NxITuJ2WWqnNNz9tIMCnFkO6Vq3A9DR8WM+RN4LssZDqK9Hklqtp/GsiVFRuJwUa2puhFQQu5lWgFXSIBAFBfG+/MpPA8mb30mN6eVgwOdCW5DINH9X7e0STAXz/yduM+vALEvIrp5ip7hRQOH75Gq3HTeXC2iU1ut4pbQNJK1RSptKwKzYBiaSy87BCKcFUrkUkgloBp/HxP00H0QGmbnZCqxPoGlS9Po8RIzXG41aHruEq0n5+fohEokqC/U9Kbm4u2dnZBr2htWvXkpiYyMmTJw3pdGvXrsXW1pZt27YxZMgQ3NzcuHTpkqGPLVu2sHnz5ko35HZ2dtQk/v7+TzVOgJiYmCq6SvfTtKk+6jIuLq6Ko2zFihWEh4fTsGHDStMbNWpUaVssXryY1NRUPvvsM8M0Z2fnB66zpsd14MAB4uPjq6Td9u/fn1atWj2w4ELTpk2ZPXs2FRUVmJrqox7FYrFBky4oKIj4+HheeeUVg7PQ39/fsP7qUkdjYmIMbUC/DZXKeynzfn5+/Prrr7jfedFbXaGI/zJ29jY12u5pGD16tCFla+nSpVXmR0ZGotFoKon3C4KAqakpS5YsqaJLaMTI3xm5yYOfl/9Iuz+D36fpl5SU8NJLL1V6+XEXLy8vQ0SwkX8vT5UDcOHCBQ4fPkxMTAyhoaF/2wt0zJGjSE1MkFtZ8b8Ro8mIjUNhY426ooKiLL2ukUalIutWgmGZOe0702rEMF7+rrLgrHtQIA379OLCth24+PuRHnvToJliamNFeV4hRQnJNGjY4s8b4F/A2bMPeWNpJ+H7U/v4/tQ+3huUwMcvjH5wWyOPRV5qBqqpG3GKLWS4xosocQEJ0lJMn0BmcPXpW7y2+TzNfOzZOa4NpaVFrNm5HUEQSMpI4/muPXBzdEQsElXR9bqRmIBOp6uiofK0WMru9WdvJuNWPz9+SSkmqqCClo5ylFqBlk4K5FJ9O50gsCetlCK1lm9uFqKQiujvZUkHF3PcFffOPxKxiE/qV19R7a+kZfOGSEzNgDuOMgF+X+PgUuwtitVKLGU151C2MpOxfHATADS6xky/upzY+yLitWoJ5VoJZhYqRCJ9dNlNswnEvX8GlUZHHcd/c3yskb8FchN9dcuHpV9Kxfp2NYidnR2dO3dm6dKllVLi7lJQUPBInbJFixYhFovp06cPoNe3EovFlV603f2u0+nHJ5VKK4n6Ozk5IZfLn1ro/2EMHTqU6dOnc/HixSpOGbVajUqleqie14EDB4iKimLKlCkPbHPX4fV78fuSkhI2btzI3Llzqyzz+3Hb2dlRVFT02Nuipsf1zjvvVBL1B3203IIFC+jZs+cD+7l06RK2trYGJ1l1vPPOO/j6+jJlyhQaNGhAeHg4gYGBLFiwgCFDhlS6xl6+fJl9+/ZV2mbu1WQ+eHt7G6tePoCQsCAcHO0fmn7p4GRPSFj1qa81SZcuXVCpVIhEIjp37lxpnkaj4fvvv+eLL77gueeeqzSvT58+rFu3rlKFSyNG/u44WbugMDF/aPqlwtQcJ+u/b/GJBg0acO3atQdeiwICAtBoNFy8eNHwAiguLo78/GqKEhn5R/LET71paWnMmTMHf39/BgwYgJ2dHadPn+bUqVM1qjnxtOSlprLq1UnM6diVj9t0YmbzNrxXvykJ5y+iLC4mNznF4CR7ECc3/FRtOPwbP2/km4JM0m/EgiBgameNQ4MQLDxcUBUVU5qSQVlBwTMa2d+Djz9+BSur6m88vULvvQ1Ly324NsTTcvPSVa4eP0thbj571vzEgfVb0T1jUda/gp9enoXLtXzEGv1DVl2dDb1U7kg7LYRraRCVAnkP1wJYdOQGpSoN+2MzuZCSh1anM+zfJaVlfLbyW77bvhVfz3vVBe/OF4lEVKj/WErkk9Ldw5J3Qh1o6WxOJzcLg5MM9HpnXdwtGORjzb5OXmxv58lIXxs8zP+eTvrfU16h4lbGg3Xf7OxteLl2Hb76YhG31XnPxAapWMbn9Y4wK3gfojteOoWVCjOLyr9vSnkMHjZyo5PMyJ+DSASOj4iYcLCutpjH07J06VK0Wi1NmjRh8+bN3Lx5k5iYGBYvXkzz5s0rtS0uLiYjI4Pk5GSOHDnC+PHj+fjjj/nkk08MN9OdOnUiPz+fCRMmEBMTQ3R0NC+++CJSqZR27drVuP2Py+TJk4mIiKBDhw4sXbqUy5cvc+vWLTZu3EizZs24efNe5daKigoyMjJITU3lwoULzJkzh969e9OjRw9GjBgBQHx8PLNnz+b8+fMkJiayfft2RowYQevWrasUdtqwYQMajcagv/R3HpeLiwuhoaGV/oBKVQp37NjBihUruHr1KnFxcSxbtow5c+YwceLEh9rq6elJ3759mTFjBqC/tkZGRnLt2jX69+/PmTNnSEpKYtOmTfTs2ZPmzZsbK6c9BRKJhPGTq4rm38/411+skvnwrGyJiYnh2rVrVda3c+dO8vPzGTNmTJV9r3///jVaJdaIkT8DsUhMY9+HB400rt0CsahmX8DXJNOmTePEiRO89tprXLp0iZs3b7Jt2zZDZGhgYCAdO3Zk/PjxnDlzhosXLzJ+/HjkcnmVjDQj/0yeKKKsW7duHDx4kOeee4558+bRvXv3v1SY9mF8P+lNzm7ZWmmaRvV4D/pmFhaUl5Sgqajg+pGjBLVpXaWN3NKSkPZtiT5wCAc3d+zq1KGkqJCCWH1U2rWDh596DH9n+vZtyyefrCIqKq7KvOZugQzv7ktabi6fDH920WTHtu1i3edVw9d//noVYW1a0GFIH2qFBDyz9f9ZFK45gmeGlp9kSfRXexqcGwBUaGDyesgqBjtz+OkV/f/V0NbfkkupBQQ7W1HX1QZLMxkDOnUmJSuTMqUSr8Nu+KZ4EdXiBr8X2BMEgZKyMuSm/00h9z+KUqOr5OiTm5nySrOWrDt8HCutmCKJlrz7gg/aFStosScHNuXwS+Q7PH/xC2wtno2jqp51e74OjyWx9DLn0m6xv/TtKm3+zjcwRv6FWMjBBX31y/sjy6RivZPM4tm8jKtduzYXLlzgk08+4c033yQ9PR1HR0caNmzIsmXLKrWdMWMGM2bMwMTEBBcXF5o1a8b+/fsrOcACAwPZsWMHH330Ec2bN0csFlO/fn127dpVJdLqz8TU1JS9e/eyYMECli9fzltvvYVCoSAoKIhJkyZVKs5011apVIqtrS1hYWEsXryYkSNHGqKeTExM2LdvHwsXLqS0tBRPT0/69+/P+++/X2XdkZGR9OvX77GqiP7V43ocZDIZS5cuZcqUKQiCQJ06dfjyyy8ZN27cI5edMmUKzZs358yZMzRp0oQWLVpw6tQpPvroI7p27UpxcTFeXl6MHDmSd99996ERakYeTUSbZkz/5C2+WbiqUmSZg5M9419/kYg2zf40Wx4kTxMZGUnHjh2rTa/s378/n3/+OVeuXPlHydsYMeLtUIs2QZ04G3+iUmSZwtScxrVb4O3w4DT+vwP16tXj8OHDvPfee7Rq1QpBEPD19WXw4MGGNt9//z1jxoyhdevWuLi4MHfuXKKjozEzMz4v/RsQCU+ggioWi3F1dcXJyemhntILFy48tJ+ioiKsra0pLCx8Zif9b8a8xOGV3z12e9fAAHKTk1GVluHToD6JFy5iIpfz2dXzONWuXe0yGpWKSV5+FGZm4uxbm7d+2crMZq2pUCp5/ad1NOjRraaG87cjNjaJgIDqy7uHh/tz8eKaZ27D5sUrOLBh20PbTA7rivW03iRev4m1gx1J12/S+Lm22DjaU5SXj04noFKWU5Sbj9zSnOyUdOpGNEEiffZvFx/G5SMnWf3RF9g6OxIWr2WPNB2A90qDceMh+fzfjYYwzyqTr+UkUv+7l1CpRbzeqBcLO75qmLf95nHmfbse60tWvF06mGC5J0v7/4hOpaYsJhETF3vqhYYweED/Gh/nvxGNTkAnQPeDyZzIVjI91J736upFe6/GJdJg2EQ0Wm21aZcds0wYkXzv990xzYcNn875U+yecvhDboq+QCrTC6uaiszZ0Kz4T1m3kX8Of8b1G0G4UwVTq9ckk5s8k0gyI0aM/HfQarVEX44hL7cAO3sbQsKC/pRIMiNG/uvoBB1ZhRkoVWXITRQ4Wbv8a1/EpqSk4Onpyb59++jQocNfbY6Rp+SJwsFmzJjxjwglzElO5uyWhztQfk9WfDxatV5QOyX6Gm/u2IKrv98DnWSgj7K5m2KZk5TMtJD6RAwbUkXX7N/E9euJTJw4n1u3Uh/YplmzZ1di+346DuvPjXOXSI2//cA2Sy/+hm7obrTci0449dt+gps25ODGbQh3SiP6aSxw0JlwRVqIvYU1b3zyAbrfovjm4FYyzDQ06N6BZt3a4+7r86yHBcDx7XtQlVeQeTuFBO5VQVsgv0EXtSsSRJyS5DBQ7YWvxAa87KGBF9T1qLa/20WZqLRqEEN8YYr+IfREPAS5MnzzpxRdV2JqIeW2IoMNyjfJ33oCRbmcMiEXuVJLn2n6aKNj16K4lZGOUqWib7MInGyMlV3uZ/SJNDbcLqa/lwUnsvWCy2sT/s/eeUdHVbRx+Lnbspvee0JICAk99N6rdASRpjQFld4VBASUroJ0KQICggJSBaR3SOi9JBAgpPe+/ftjySZLQgcVvn3OyYG9M3fuzOzdW37zlnSjUPYwIckgkkEhkUwqkbDfRYVGAEuNQMUcMTG6LPaeP0vD8iFI3vAD/Y/1J6HXf8PsW12JV0YyquTvb/R4Zsw8EUEAS7MVjRkzZl4fYrGY8pX+medTM2bM5CMSRLjbez674lvIgQMHyMzMpFy5csTExDB69Gj8/PyoV6+wN5qZt48Xsih7XbzpFem+ti7kZjzZEsLW1ZX6fT5Gp9Fw/+JlstMziAgNMwblF8QiJp06SkCVyk9sQ6vRsLBHby7v3Y9XqSDCT4UaY2Mtz0hEXiDF+8ugVirZOXsOl//eR9MB/QmoVgWX/0CwVn//9ty9G/3UOgMGfMD8+a+WjfF50Wo0jOvQh4zkZwRO1INIDx8pi7FOfh+18PTTvnducXToWSWPNNlevXE9okOvUtWhGMdV0VQoVYa2dsEIlYpB45cLBqu6+ZDfh00nR6zjgwXjsfd15/rCP7m/8m+uu+uxLu/Hvas3SY5PRCwR06ZvD7YsMVhL+rt502vsEJyqBBdqd+eK37h++hxujauSrMoh3iabwGNWdHrgiJXqHsKdRLBX0OjDSK6djKFP1XrIxBJEagGP7b5EaVNoLiuN3UIHygSUYP2Rg3SdnZ/WvkqJkoT9sPClxvwukqXR4fqHIRaOCGjkbsnBuGy+Ke/M8NJOgEFc7zjqW7YcOmncTwa4i8WEVA5hW+hZAKQiER3alWbb6SvkZGro3LQu60aPNa9+m/nX+UcsysyYMWPGjBkzZv7j7NmzhxEjRnDnzh1sbGyoVasWc+bMoVixYs/e2cx/nhcSyhwcHIq0KLOzs6NkyZKMHDmSpk2bPrOdN/mgnZmaSn+Hp2fQGL1rGxVamGaVWdzrU46u+tX4uVhIBaaeP238rFGr+blPP67sO0BwvTo0G/QFU+oaTCq9y5YhoFoVDq9YRdX32zN00/qX7v/pfUdYtGAjMUf24Zh8BxEGD60sxFhY2eLt5URWUjIdJoyjxeABL32cl6VEiQ5ERDzZmgygXLkAWreuw8SJn2Jh8XozlBWFTqcj5s59QncfJCriLg9uRZCVmp5f4ZGLm7POgs9zSjDF6ikZO/PqY9hHphdQFSGqKfRi/LVWBOhsaK72QC8SSJj/PvaVSiB7kl/6pSj4/m9UxewRj2uD2MIQgP5I76lsuGUQTuqHVKPzlOHQ4kdQaUmygQm6M7j6eNF/+jgsLBXodDqm9RpMTobB318skTBk3ncElC9tPFRCVAzffNgPsbUCp/aGVY3aEZVoctgQWFOvnoqAGoBRkzphpb2EEGeI3fEwNYWlJw0x9joq6zJvQUvSE+/xydr9nLp3mxrWtthYyHH2L0Hf99pQr3KVt8LS9J+g5/FoNt7PoE+AHfOquaPX603mJkeZS2xiEpW6DSUtKz9egzMCieSfZx5uCtpXKc3Cv84g6AWkcoHuJe2pVq0mn3028B8dkxkzBTELZWbMmDFjxowZM2bedV7I9XLOnDlFbk9NTeXs2bO0bt2ajRs3PjV99ptEo1YzulSFIsscvLxIeWgQeGJu3TYRynIyMug57wccvDzYNnUmAM7FfFn0cR80KjVBdWohlko5vuY3AE7/vomoq9eQyuWoc3ON7pc/p8ZhVUQgzmdx7+Ilfhk4lMhL1/k13Qsf0qjNA2O5AFijRZuVyoFbYsQIqL+e9K8IZTt3zuHnn/9k7do9xD0SVlxc7EhISDPWuXw5gsuXI9iwYR8REX++8T6JRCK8SvjRYWB+ZqP7N8JZO30uUbcjjdtUaHHSW/Ch0pczkmQixJmFG3ssbpQKPehBJoiQ60RkCBr0AmjRc1WSzlXS8dNakouO7cMnkSJSYePthpWdLW0/+xiphQz/sgZrL93cfURcvobLJQt2XDhM1Yl9CKpcAdfSAQg3T6IXwK2UqauvKlcJMoh/8BALhRwHV4ML38TfFvP7D0s4d+AYWo2G6DPXCEiVQOViYGWBjYMd9i5OpCalIFFr0UjFnPA/x0PLOHrsacttqRta3VUuiFM49ess3Ov2oazsUZDbAuPXWGVycd9icnJ1KC6kU8XFhkC5Amf/QKycnDkUdhonO3uu3o2mQkl/gv0Kx0f7f2JVbU+W1tAjExsmsaBIlp2bw+Lf15ORlYWTvZWJUFZQJAOIicth0c6zxsQN6lw966+lEp91lJ49+6BQPCVOnRkzZsyYMWPGjBkzZsyYeWleq+vlDz/8wMaNGzlx4sRT672pFemMpCQ+c/YqtF0qlzMl7Bh/Tp6G3NqKj+f9iNzKkBnw9qnTTGvSEr1Ox5g925EqFGz+5luu7NuPRpmfJdPGxYWMhIRCbdu5u5EWGwfAsD9/58GVqxxevhK/ShXp/N0kPIMNWRejrl5jZst2iEQiRv21Fa9SBvFk7cgv+ev7OYBBo9mLP5aoqfNIKCuo21zDhQsYMmZVk8RxWv3k2FyvE71ez9ChPxAaepXp0wdSv34lVq3awYgRc5HLZTx8WHhe8ujUqRG//fbtv5YdNeLiNdbOnA/3M7C9noOvnS2Cl5yHgVbcCg+ndI3KZKSkEnn1JgCCHvRPMo4q8GXkWZpJ9AL2eim1NS40U3uQIqiYJr9Klkhr3E0mt8DB1RmnBDXXcuJR6MXI9CLSRGqaf/wBbft/zP1dp8gVtJRsUduw05lIOH2Hiw657Nj1F+XqVKNt/4/h3D1YeQJq+pNUypGwyb8Q6ybl40h7RDHpUMGH1HmdsLayIic9kyOHDnMu9gGIBHQ6Q5y2946HsC1nLSmxUcY+ap3d8WhhEJmViSncfqjFUnaT1iUssJGJyVXq+OXPLEQyPfZeUhx9/bB1N8QbWL/3HDfvxyKXSLixeRlHD+7i6JFDFHPxRucbRLZKRZcGVSlTuswLZRV713gYF8eyzX+g1er4duVu43YJoHnONgKdLWlbozyTRhuyupkx809jtigzY8aMGTNmzJgx867zWoWyW7duUaNGDZKTk59a700+aE9t3IKrBw4ZPxcLqUCdj7tTr2cPrB0dC9XfOHEyf042ZJVrM2YkGpWKXT/+VLhhQTDGMPMpV5aYW7fRKJWEtHqPCzt3YWFpyYRjBxhXKT/NtJWjI+8NH8TZP7eRk55B7O1wACq815z0hERSUtJIiginYNShE3gTiSNNCcdNouI+9nhqEhFhKpQFk0CPDrX5auPq1yY+fPvtcpYv30b//u/z5Zc9jdtPnrxErVqfAFC1amlCQ1cCBpfHjz/+hrVrdxfVnJF27eqxZcvs19LHl0WjVjOt1xBiIx8QWKkct89dBsDVx4uv18zn248GEn//IRKZFI1KjVgqRVBr0FDEz0MP5TR2PBBn46O15LIkjTG5pfDVGcTX2fLruOtrkCxK5Kboosl+jwdwr1O6Il3ty3HfU8JvV47g5OHGx+OHIXtSOvi28+D+o9+Xiw0kZICnPcSkotPr0cjFTOvpgIOVNal/h6H0sEPmnx9AU52UhvZODEFNaxO2bjMk5wKgs7AkvVQjpDI9jonnsalaCiuRmtLiWwRWakFqfAq3t9+nVZiOcGk2g+Kvk+Nmi10xF47duWNsf9mnXTl22nA+6PV6Vl1OBSDETc7wrm3p0aPXc31f7wIXLpwjNPQUderUo3Tpsuj1enYcPsiD2FgWbjrMtbsPsLO2om/rBvywfudztdmkuDXeNlKCy1Vk9LCRb3gEZswUxiyUmTFjxowZM2bMmHnXea1mPkqlEpnszcekKgpVbi5rho3CytGRj3/6AfeSJXAtXpyfOnVj7fDRHFi8lJnXLxYSlWp378qJdRvQqtUUCynPpb/3Fdm+jbMTGQmJgME6TBAELKys6PzdJNqNHY2FtRXqnFwcPD1JiTYEu89KTmbj15OMbUhkMiQyGRd3/02q3oK9BOBMMRpwDwEQy2T0rFOSkwdOUrlSMPI2vVkzaRn15RK8cmMJJgERegT0lCSJa39uJGx7F6q3a/3K86dUqhg/fgkAY8cuZOTI7kYrsOLFPXFysiMpKY3KlYNJT8/E1taafv2mPlMkAzhw4Mwr9+9VkUiljFr6PfH3H+Li68ncgWN5cDOCKs3qI5ZIGLd6HmlJKVjb25IUHYd7MW80Gg2zPxrCw6iHhQSuy5I0iuuscMICmciWndJoPlT5ck+URaQoiwcc4Sv1T8yUDkcpGLIf5rVhYalAmW3Y1jRCBsnX2G0Rzn1JKvdvhBNz5x4ffNCZwDQp1120WPq64l/uUaIAH0eDUGanIDItjl0WDymRYof3h7VZuv13tCKwuBJAKYUn79+w4S9bKTGP+qzZGUbnGEccdFZckEfigAIrnYgUlIhigzl5UsbFXDktSkn4LiMDn1SB1LK1KPHZ+4xs3oUWKY446N2pqrKjhYMPx93FBJQO4NgdQyy9ELFA9fKlSEiO5ObtG2Snq43zJRIEIiPzBbXn5fEYX28LKpWKhQvnotFouHjxHAsWLEMQBNo0aIRaoyElNZW7sV5kZSvZc/rSc7UpFYu5k6LEzUqC1ZPi4JkxY8aMGTNmzJgxY8aMmVfitQply5cvJyQk5HU2+dwc+3Ut+xcvBSAiNAx1Ti4ZSUnoH7mbxYZHoMrJQSQSkZGYiJOPD6sGD+fY6rWUblifmFu3mN/1Y6ydHBFEIuN+eeSJZAB6nQ49oMzK4ur+g0SeO8/xteuN+4mkUnRqtcn+IomEkTv/5Mr+g+yYPpt4rFAjJgY7TuNNfctk5sdEIre2Jv7OXZx8vKlSzRBz60iuC5NbVYXMNByTs7h0+TYCoEagRfsvWbXVlrZtn52G9uHDeO7ceUidOiGFxAcLCxn16lXkyJHzNGxY2cRV0t3dmcuXfyM09CqDB3/Pzz9vYdmycRw5cv65vpv/itAht1TgG1wCgNHLfiA3KxtLG0N2UolUipO7KwCe/oZMJTKxGLeyJUl4kI5Kr0Ek5KIT9CCAg07GkNwgpIgoo01jgfw2t8VXUQqG80aDmiwhHSU5hfqRJ5IBRGszcUaBv2DLRVIBiL0XxfzZP5jYsvWaOAIbB3tKTm2PKPQe+Dqx/vMRPFCmcYU0nC6qUaIFHZQLi6ehRoaLTkGvUJgqiaJs41qoUy6g0Ivx0VtyIewODbCiiToAgAwpTA+6z4RYJ65ZFadSpCF+lvP5WARBwNrOlkvpqdTTuKJ0tkTSMYQ6eh3Fvbz5qP0sMu/cp5iPB8FVQyhdozIn9xwgLuI+dWxtOXvpPP62Ijp37v7c31VuVgqh22ahzE6jYrMvcPYp89z7/hcQi8VYWVmTlpaKra29SVlMQjwavQ4fN4OF686T14xlbepVZ+fRUHQFDH193V2IiktErdVyJ1VLoI8tfXt/wvIte5i5+g/aN6jFd198THJyEi4urv+Z35sZM2bMmDFjxowZM2bMvI28kOvl8OHDi9yelpbGuXPnuHXrFkeOHKFy5cpPbedNuG5cPXiIqY1aFFkmiEQ0+aIfnT7txrnlP7Nlwy6wtSfudsSTGxQEKrdtzdmt200223l4kJmYiFatxs7dnUmnDjPMv1QhYS0PkUxG1XZt+XDaJJyLFaOnhS16nY5cxBwVBSBxcGZk1xp06P0BxStVNNl35codDB36A7VqlWfLllnIZIYsiY3q9iXi2BGqEI0MLaIa77H25NOD5kdFxVGuXDdSUzMYPPhD5s4dUaiOSqXm9u37lCxZDKlUwuLFm5g4cSnvvVeTX36ZwJYth3j//TEAVKtWmvDwKJKT0wu1U3gqBbTaU2/dC/zVk2f4duQUFOhRoEeFgOyRfOWqs2B8TllECGSgJlvQcFyayH5pHBK9iJK6ELKFTCJFt556DEsrS8qmynFW2JId6MSh62eLrCeSiNFptPgJdrRr2wbPXXdI16n4tUQGsbciUGk1CBiM1nQC2OqkjM0pzU6LGI7LEqniWIwO923JRINUL/CzPJz6GjfqaFxMjnNY60x05xZ0/XMt6PTQvTqMakFKXAJXTp6hVPlyiGwUzNtoSGzh4exCvw8+fOW5fpyo60e5cnil4RglqlOhSb/8wrxLVlQGRKaCuxUEOIIo7/xKxRD1y/m19+tFSExM4Nq1K5QrVwEHh3y3b6VKxcwVS9Hp9WTnKvlh/UG0WsP1QyQIJiKZhVTKqskj6PLVdOO29mXd2LzyF1wadyEpLR0B+LyON9npWWgsclg69zcsZE9w3TVj5hUxu16aMWPGjBkzZsyYedd5oeBW58+fL/IvMTGRpk2bcuXKlWeKZG+KMg0b0HXm1CLL9DodlzZuRHH9JLeu3kat0TxRJLO0twcgqE4thm/5g2F/bkB45K4piESoc3PQPrIWU+XmsKL/QCq2aYVEJkNWRHBtnUrF2T17+W30OPra5L+4+wYU4+zF34hOPMDweVMLiWQAvXq1JjX1AH/9NccokgH88usU3MhCjhYRYJXyoNC+jxMR8ZDU1AwAzp69UWQdmUxKmTIBSCRiJkxYwvDhc4iPT2bVqp1ERETRsGEVKlYsiVQqITT02nOJZCKRiC++6PjWiWQAIrEY6SORDEBawMYrXqRklcVdjkjisUSCm15Be5U3Er2ARtBxTXyuSJHMr3wpk8+KDA1+OmtapTnT8Qz4ai0R6UGuN/1p6jSG5ADR+iyUG0KxTlHhmQbtEx0pZ+/DlOzyuOvl6ACRXEaOmxV/WcVxVBKPTqdDm5SJrV6Kp16BWBAoVrIEWy2iOGabxo3azsRUKsktuTvrS7bBsk4AHBoFR8bAKIP47ODmQt327+Hs742jixMdGjelUqnSdGjS1NjHsL8PMazJB3z/+WiUObmvNPdO3qWwsLRHEElwD6iaXxCdAYvPwdLzsPkGnItFt+MmLDsPyTnAWcAb8AT+eqU+vCrOzi7Uq9fQRCQDsJDJGNO3H9XLV+JBotookgEmIhlAtbIlycrJxd3JAUuZBG8bCc3q1iJXqaJhlfIAhJTwITvdYAGoyxa4Ev58lp5mzJgxY8aMGTNmzJh5swiCwJYtW55ap1evXrRv3/4f6U9B/Pz8mDNnzj9+3LeBFxLKDh48WOTf1q1bmTlzJsWLF39T/Xwu1CrlE8s0ag2Rdx5ycP9pkpPSjNtFBVwMi1etzOwbF/nm5GG+/NsQXLtK+3bMun6R94YNRq/TkZ2Saqyfk5rGpT17uX7wEL/kpBoC/mP4MUiLB5PzKEx/dnoGYZu3oM7NRa/TUefj7nx/8zI+ZV/OnSw7R8k1XMhCghaBmw9SnrlP3bohDBz4AbVqlWfmzEFPrbt790mmTFlOTo5hPitUCCQ5OY1y5bpw/vwt1OrnzdFnCPgfFnaNLVsOPfc+/xVKVavI4G9G4ODlgSASPR6mjAuKDDbI7nNVnArAA1E2GuHJBpqChZTIS9cN/9dDQ5Uro3NKU0njAIAIAV+dJdOyQ5iZHYK3VmHc11InpoTWmoE5AWSh4i/pQzLRoH2QxOXke8xSXCNGlAsSMbpcFeqEVM7555/bHnUroBVAJQabGV3psXoa3x3YQO3D3xO8YAAeK7qiWtOfT6b40q4hYKsA2yfHwSpfMog2DRrhcigSPl8DOy9xZPNfqHJyuXPpOnevFC3GPi8KG2ca9JhFkz7zcSteQES+lQwqLeRoyDOGFYkkhs9rLoPyMJAFqIFnx8/7t5BJpbSoXYua5Uobtz1+fikcs+nYrCqfT5tPbFIK2SoNURkaRv7yF7b1OtK2fnUu/LaAhSP6IreyQKXNJV2ShKOdt0k7aWlppKQ8PcGKGTP/JXRaLXcuHeLiod+4c+kQOq322Tu9IrGxsQwaNAh/f38sLCzw8fGhTZs27N+/31jHz88PQRAQBAGFQoGfnx+dO3fmwIEDhdoLCwujcePG2Nvb4+DgQPPmzbl48WKhei9Dr169jP0o6s/Pz++J+6pUKmbOnEmFChWwtLTE2dmZ2rVr88svv6B+tAhYsH2pVIqbmxtNmzZlxYoVxuzJBTl58iSNGjXCysoKW1tb6tWrR05OfoiBc+fO0bRpU+zt7XFycqJfv35kZma+lrkoyKZNm2jQoAF2dnZYW1tTvnx5Jk+ebEwwtXLlSuO4xGIxDg4OVK9encmTJ5OWlvbEdqdPn44gCAwdOtRke4MGDQrN/WeffWYsj4yMNClzdHSkfv36HD16tMjj9O/fH7FYzB9//PHqk2GmMFodhEXCrsuGf7VFe4K8LvJ+RwXPiTwGDBiAIAj06tXLpP7jL8kbN25ELpfz/fffm2zv3bs3X3/9NcATrwPr169/7WMyY+Zl0Gq1nDl0gl2//cmZQyfQvsF7+tPujYIg8M0337yxYz+NmJgY3nvvPSD/3nDhwgWTOnPnzmXlypX/fOeewTfffGMyh3Z2dtStW5fDhw//211747yedIn/EWp3/dBo/WXl4GBSlpSUyrwff0WhMHVJqtbpfT5dvphZNy7xbehx7NzcCKxRHVmBYNkeJQNp8ElvpI8yEVo7OZm0oXpkPaNVGoQlvV5PjzEDicKWDKRIyb8ZyywtadSvLyKxmJdFp9PhRTpWaBCjx1ec9cx9RCIR8+aN4vjxZdSqVZ6rVyPo2fMbli7dUqiul5eLiQXYpUvh1KzZl6iohKceQ/yEMYWGXqNDh9EcPfr2WbpUaVqfb3//mflHtzLu1/km54VGrcZWL0EHXBWlsUR2G88AP5x9PAu1I3Gxw6FhJeNnZ50FHdU+WCPhmCSBacXuYN3pKJPrxSKIBcSICNY+cmvSQ09lcYblBiNFxK/ySHbKYlhvcY/T0kRU6EgXabDQCRi/NgFEno4Ua1SdHhOH8d60IYiPfons+FikzcoBILOwMPmey5aAyvm6zTPRHrwJk7bDyQgY9ydidTUEQcDVxwvfoBLP39ATEEQixBKp6cZAR6NdXyErRZ2ejF88eZhykuTMmZDT95X78CZ5EJvAxCW/Gj/rAR83ZwSR4XrhVTmW73/diuoxYTo7V4lGq+W7LyeRnX2XpckHyXVWEKuy4tR9DwLa9WPcglUAXLx4nuHDBzBixCAmTRqHRvP8IrcZM/8GV49vZlZvP5Z/2ZDfZ3Zj+ZcNmdXbj6vHN7+xY0ZGRlK5cmUOHDjArFmzuHz5Mrt376Zhw4YMGDDApO7kyZOJiYnh5s2brF69Gnt7e5o0acJ3331nrJOZmUmLFi3w9fXl9OnTHDt2DBsbG5o3b24Uox5n5cqVNGjQ4Ln6O3fuXGJiYox/AL/88ovxc1hYWJH7qVQqmjdvzvTp0+nXrx8nTpwgNDSUAQMGMG/ePK5evWqs26JFC2JiYoiMjGTXrl00bNiQIUOG0Lp1a5PryMmTJ2nRogXNmjUjNDSUsLAwBg4caEycFB0dTZMmTShRogSnT59m9+7dXL161UQgeJxDhw49VewrinHjxvHhhx9StWpVdu3axZUrV/j++++5ePEiv/6af521tbUlJiaGqKgoTpw4Qb9+/Vi9ejUhISFEP0rEVJCwsDCWLFlC+fLlizzup59+avJdzJw5s1Cdffv2ERMTw5EjR/D09KR169bExcWZ1MnOzmb9+vWMHj2aFStWPHO8vXr1+tde+N5K9l+HlnPh01Xw1WbDvy3nGra/QXx8fFi/fr2JcJybm8u6devw9fV96r7Lli2je/fuLFq0iBEj8sOlaLVaduzYQdu2bY3bCv7+8/5et2XKk65dZsw8jf2bd9LKryqfNuzI2G5f8GnDjrTyq8r+zc+X7f1FKfgbmDNnjvGan/c3cmR+xni9Xv+PPRe7u7tjYfH0sCh2dnbYP/Js+69RpkwZ4xyePHmSwMBAWrdu/dRFpneBd0ooc/X3Z+a1C3y6fDHOxYsVKk9ISDFaSeVh6+ZKgz698AwqWWSbSQ8eMLvN+2yfPouxB3Zj6+ZKSlIKFHhJl1kq2LtgMdoCP7ak+/ep6CzCBrXRUsSnfDlWZCYRVLvWK43TzUZKKfJFq+CaVZ9Su2h6957C6tV/0a/fVK5fv2tSVr58ILVrVzB+1uv16HRPtpSSSMQEBxd75gpBbq7qhfv5X0JhbYUq19SlsKHGjRCtA2V0dtTRuHI9NZ0f7zzktA6SC8yZJimDbq3b0cCmOLXUzozKLcVJcSLHxfHssIhmXvBDsmQ6brgq2eIWT6qg4qTFo4uPAHGiXK6IUsghf44zUGNRwEVTKehxV0ppPrAP5Tu9R9eOHRk95WtqNmtkqGBtAfLHhKdX4Pyp/Ac/PdDhciz9dO24LJvFpZtadv2ynisnin5hA8N5df1OBHeinuE6HJcJZ2IgQ1XI7KpgiEVBELBR+iM54UHyZ9VIGpWKas4RtPOOot56DWW2BjS6N76K/Lwcv3iN1AxTkTs5PZNeH5emSvdblC9ekuJuXoDJ5QZLtKDXc0thw09O97iSmENal/Kcf5BMSqrhnNl1+BgHD+5j//49RguQe/ci2XVoC/dinp59VK/XM2ZOf2p95M/m/Wtf44jfTrS5uVwf/DnnurxPwg3DS9X582dZtnQRCxbMYfPm343Xvjt3IoiNjXlac2aewtXjm1n3XSfSE6NMtqcnPmTdd53emFj2xRdfIAgCoaGhdOzYkZIlS1KmTBmGDx/OqVOnTOra2Njg7u6Or68v9erV4+eff2b8+PFMmDCBmzdvAnDjxg2Sk5OZPHkyQUFBlClThokTJxIXF8e9e/deub92dna4u7sb/wDs7e2Nn11cXIrcb86cORw5coT9+/czYMAAQkJC8Pf3p1u3bpw+fZrAwEBjXQsLC9zd3fHy8qJSpUqMHTuWrVu3smvXLpMV72HDhjF48GC+/PJLypQpQ1BQEJ07dza+EOzYsQOpVMqCBQsICgqiatWqLF68mE2bNhEeHv7KcwEQGhrK1KlT+f7775k1axa1atXCz8+Ppk2bsmnTJnr27GmsKwgC7u7ueHh4UKpUKfr27cuJEyfIzMxk9OjRJu1mZmbSvXt3li5disNji695WFpamnwXRcXtc3Jywt3dnbJlyzJ27FjS09M5ffq0SZ0//viD0qVL8+WXX3LkyBEePHh2SA0zz8n+6zDyd4h7LFxIfLph+xsUyypVqoSPjw+bN+dfuzZv3oyvry8VKxYOuZLHzJkzGTRoEOvXr6d3794mZSdOnEAqlVK1av6zf8Hff96f/CnZsQVBYNGiRbz33nsoFAr8/f3ZuHGjsTzP4mXDhg3Ur18fuVzO2rVr0el0TJ48GW9vbywsLAgJCWH3blPr/RMnThASEoJcLqdKlSps2bKlSOsZM+8++zfvZFSnT4mLMn0uin8Yy6hOn74Rsazgb8DOzs54zXd3d+fGjRvY2Niwa9cuKleujIWFBceOHSMiIoJ27drh5uaGtbU1VatWZd++fSbt+vn5MXXqVPr06YONjQ2+vr78/PPPxnKVSsXAgQPx8PBALpdTrFgxpk2bZiwv6HqZ54FXsWJFBEEwLpI9blWqVCoZPHgwrq6uyOVy6tSpY7IQdujQIQRBYP/+/VSpUgVLS0tq1aplfBYBnmtsz4NEIjHOY+nSpZk8eTKZmZncuvX0WNxvO++UUAbgGVSSBn160WXaFMTSZ4sCCXee/tK4bdoszu/4i2O/ruPk+t85GafnT0pxX+KMvYc7YqmUnLR0Vg82TXSwbepMMhOTTLb1mv/jK8fq0ul0LP3kc0SP7Gp0QMNRX75wO26PMu7J5RbY2loBcOvWPf74Yx/p6ZmEa+OeOyeqtbWCGzee/vD/xRedaNq0+gv387+Eg6szHQf1xdLW2rgtWmQQi3TouS/N5nJcIpk6HefU+YKWSCym/WcfI5NIOJRxlxPSRLZJo/hbEsM6+X0AAqINk22bKXAwK4pxlpfI0ueLcpstolikiGC51V3srG0Mx7ZQcVyaSJ63pwC41gihbdcO9B/6BeWr5VuwvQkeVCnPKpe6XLT05aR1AMVUSZTLjqKmxSFWLV3JjmVrWTx6CtF3ij43Tl68wO97dvHr9q3cjLxbZB1yNbDpBhx/ADtuQY7GqJVl5l7mwf1v0GgyTASzqEnXuLM+nnM/x6OOFyPWWSCNzES35Sb6BWfQzT/Dzb4nufJJGJqMf2+FtHnNSlQKDjDZplSpiLquQDjfmslN5vP7jLFMHdiLTTO/pkPDWtQrX5Jga7FROdvUbQuhP4ayo+d2Wpew5f0gO2xkYorLshj1/SLCLl9HrzeIX0nZGkYO/5QOTUuyb99mUlNTmDx5PF99NYL79yONffjr2GbW7vyZ+7F3mb1yvHG7Tqdj2eY5/PDrJHJys/+ROfovcGT6WKKWLSZp258caliTbwf1Y/68Hzhx8hhnz4axY8dWBg3qx8KFc/n22wmMHz+GM2dCOXXqBDk5/z/z9KrotFp2LBkCFLUoY9i2c8nQ1+6GmZyczO7duxkwYABWVlaFyp9ndXfIkCHo9Xq2bt0KQFBQEE5OTixfvhyVSkVOTg7Lly+nVKlSL2wp9TpZu3YtTZo0KfIFXSqVFjn+gjRq1IgKFSoYX/rj4+M5ffo0rq6u1KpVCzc3N+rXr8+xY8eM+yiVSmQymdHCDEChMIQVKFjvVVi7di3W1tZ88cUXRZY/6zt0dXWle/fubNu2zWTBb8CAAbRq1YomTZo89djOzs6ULVuWr776iuzsJ//mc3JyWL16NQAymcykbPny5fTo0QM7Ozvee++9/6T7zVuJVgczdz/tsmIof4MLaH369OGXX34xfl6xYkUh8asgY8aMYcqUKezYsYMOHToUKt+2bRtt2rR55feJ8ePH07FjRy5evEj37t3p0qUL16+bioZffvklQ4YM4fr16zRv3py5c+fy/fffM3v2bC5dukTz5s1p27Ytt2/fBgzJXtq0aUO5cuU4d+4cU6ZMYcyYMa/UTzNvJ1qtlllDxlNUzsC8bbOGTnijbphP4ssvv2T69Olcv36d8uXLk5mZScuWLdm/fz/nz5+nRYsWtGnThvv375vs9/3331OlShXOnz/PF198weeff24UpX766Se2bdvG77//zs2bN1m7du0T7/ehoaFAvrVxQSG9IKNHj2bTpk2sWrWKc+fOUaJECZo3b24MJ5DHuHHj+P777zlz5gwSiYQ+ffoYy553bC+CUqnkl19+wd7enqCgoJdu523gOaWQt4/yzZoy/fJZxpSp+NQH64S794i+eZMV/Qei1Wj4ZNkiPIOCjDcg7wJxxP6et4gyQEkSkaj1pL6A4YBMISe4bp2XHY6R6Os3uLB3P3nRqwSgRqOaL9zO2rWT+f33fVSpUhovL1diYhKpUqUXGRlZVK9fjljnLHCRQMyzTVJVqvw6EokYV1cHoqMTTeqcOnX5hfv4X6RRl/bE3X/Isa27EUvEeA9ox74rD0lPTyc124nS11OIRsBSLsdebRC6dFotZWpWYfeq343tHJOZzk/5O1JKPpDgKFKQrXlyIPwsnZruAz+jXJ3qzOg7jOy4BPQCVK5dg7rvtySwxpNXKF83bRuL2EIjjiVCSMx1NKvvEFZaQWale7jpxaTklkBzJ+KJGWHTs/Jj1Py+awc3dq+lWq3GVKzZhOrVa2JhITdk3tQ+usmqdGh8rNh2ZzvibB2RLul0b9uO+5cWIC7ZF9+bLgiAOs8FWgcateHYevQoEgzWWwIgT8vC2U1K7MDj2A4qh7yiIzLxP5twwsHWhjNr5lH1o8GcvR6Os70tHzSpy6KNhhW2T6fM5cKtO+QolVQtE0jY1dsm++u1etTZBqFPrdGh1YOVTERjdzm7bqeRq9VzLSGX3Efz56hPo7xYRnamnqU/TuZmpwzC70QgEQms37iG9acX4Orgzp2H+ccRRCJiEh8yb+lMYo8cpuWJi3hp4Le/j9Hn173/0Ez9s6SkJDNnzizi4+OwtFNw+eDPjMRw3tinpeG7fRt3GjYyMfPLzc0lfd2v1EpM5E4xP5bM/xGtSERgYEmaNm2Bj08x9MeOcH1gP0QBgSR+PpA6TZrj5ub+r43zv0bk1aOFLMlM0ZOW+IDIq0fxL9/gtR03PDwcvV5PcHDwS7fh6OiIq6srkZGRgMHq7NChQ7Rv354pU6YAEBgYyJ49e5BI/r3Hrtu3bz+3e+eTCA4O5tKlSwDcebTQ+M033zB79mxCQkJYvXo1jRs35sqVKwQGBtKoUSOGDx/OrFmzGDJkCFlZWXz5pWFxL89t9FW5ffs2/v7+SJ9jcfRJBAcHk5GRQVJSEq6urqxfv55z58490Y0VoFu3bhQrVgxPT08uXbrEmDFjuHnzZqGXnlq1aiESicjOzkav11O5cmUaN25s0v9Tp04Z9+vRowfDhw/n66+/fisTIf2nOHe/sCVZQfQYys/dh6p+b6QLPXr04KuvvjJakx4/fpz169dz6NChQnV37drF1q1b2b9/P40aNSqyva1bt/Ljjz+abOvatWuh8CfXrl17qnvnBx98wCeffALAlClT2Lt3L/PmzWPhwoXGOkOHDuX99983fp49ezZjxoyhS5cuAMyYMYODBw8yZ84cFixYwLp16xAEgaVLlyKXyyldujQPHz7k008/fcoMmXkXOX/0dCFLsoLo9XriHkRz/uhpqjR4NU+rF2Xy5Mk0bZqfjMzR0ZEKFfI9qaZMmcKff/7Jtm3bGDhwoHF7y5YtjQsyY8aM4ccff+TgwYMEBQVx//59AgMDqVOnDoIgUKxYYc+2PPKsvvOsjYsiKyuLRYsWsXLlSmNss6VLl7J3716WL1/OqFGjjHW/++476tevDxhEwFatWpGbm4tcLqdChQrPNbZncfnyZaytDYYi2dnZ2NjYsGHDhnc++/k7K5SBwbpscugxfmj/AckPDA/gpRrV5/qB/OBzMTdvMSo4/wQaXSoE77JlmHTqCJlJSZSsXRMbF2cyEvKFDWmRS1NF4+DliVatodeCOa8+IMCpmC8axEgeueDFYANFqPXPwtbWmk8+aW/8nJCQQsYjN7DUhHSwAVKfz287OzsXkUiETqdDo9ESF5eMQmGBp6czEREPAUhKenaGzLeFzsP7U7JyeVx9vPAp6W/cnp2eyZWTYcwrWwore1t2LFvLzbALlK1VFU//YrgV8y6yPbFUilatRq4WyMZUJBOJRAgigWotGnH1xBnsXZwoV6c6Ng52fDRuCAfWb6FMrarU69DyjY65yH6LoKPxPlOK0HJDWLX/Kq7aS4RdfZ8MXJF738PRx/RmkZyWyo7Dh5DJZLg4OJKQkowOAbGDOxeuR3DxZiSHDh1g2PDR2FjbQOtAsiLieeimxyLmATO3G2IBOTi5MmTqPJwbfEa6EhJ8o9AeXonXB0rsHGtj5y1D6ptODDeRlm6N/fV0JFodGqUOsYXApV8TUWfrsPz7CDkpWnzX1sSzlRs28n/2snjo55lcuBmBn7sLjfvnx044c/Um6kci4+Mi2eM4ysXo9HpiMzXYWQhoH10TVNr8a0OayA7LEg2wS79HmNqTPxZswN1aSqtAO8ITrhCfHEt8ciwikeFhW6cXc+6mA0Ht+1HTw4pPLkRi98gAz22fqTuaXq8nJT0JRztn3na2b9/CgweGlTZlvBLnwBZss4uh4bnr2GZn45iagkStRiOTgV6PRW4Oilwllc+dBcApMYHtbdsDcPPWDW7fNpilvx8WhkVaGpw7w9m1q7hw4xpTpsz4V8b4XyQj+flEk+et97wUtdr9su3kiRo5OTn07duX2rVr89tvv6HVapk9ezatWrUiLCwMhULB/fv3KV06PyikRqNBrVYbH0QBxo4dy9ixY19L//L6+DrayBtnnlt3//79jRYyFStWZP/+/axYsYJp06ZRpkwZVq1axfDhw/nqq68Qi8UMHjwYNzc3EyuzguPWarUolUqTbT169GDx4sVvdFxgcI958OABQ4YMYe/evU91X+vXr5/x/+XKlcPDw4PGjRsTERFBQEC+tfCGDRsIDg7mypUrjB49mpUrV5qIeitWrKB58+Y4Oxuuny1btqRv374cOHDAKKitXbuW/v37G/dRKpUIgsDs2bON23bt2kXdunVfcSbeMRIzXm+9l8DFxYVWrVqxcuVK9Ho9rVq1Mn7Xj1O+fHkSExOZOHEi1apVM/kNAFy/fp3o6GgToRXgxx9/LGT56OlZOF5uQWrWrFno8+PukVWqVDH+Pz09nejoaGrXrm1Sp3bt2sZEJTdv3qR8+fImv5tq1ao9tR9m3k0SYuKeXekF6r1OCp7XYLC6+uabb9i5cycxMTFoNBpycnIKWV0VjFWZ59IZHx8PGNwmmzZtSlBQEC1atKB169Y0a9bspfsYERGBWq02+b1JpVKqVatWyPKzYL88PDwAg8W3r6/vc4/tWQQFBbFt2zYAMjIy2LBhAx988AEHDx4sNJ/vEu+0UAZQvFJFei2Yyw9tOwJw6+iJ/EKRCG0RwSmjrlzl2Oq1rBk+GnVuLg0+6c2Rlb+ie4GAf1KFnEb9PuHjObOfXfkFsFAo0CCGR0KZBWq2z5hNu7GvZtpcvnwgs2YN5tixC3z9dR+adx9O8gt4pX34YRMOHDhDXFwyjRtXZdWqiSQnp1Onzqekp2cxbdoX6HQ6kwfjtxWxRELlxoUfRi1tranWvKHx8wdDTFfQWvbuwoObEcTcvU+15g3IycyieotGuHh7cPvCFaQWMvas+oPb5y9TvWVjipcJokqTesitLIvsR1DlCgRVrlBk2b9BtaZ2VGxYjd/+suFAqCsAKotiLPgNPvSPw+fmTWhSmqORF7n70CBc1wqpSE5SKprMbJLvh+PqZxhPTGICP6xeyaedOuPm68yy49tIvZ2Oj7sHbTr34dj+7fQakP8CaWsBtqW9obQhCxRdUyAuC8q7YmndCr0eYkopUVyIRp6WgypRjDrbYLqcm6olWcgmvccBLovAbYQndpclqLVi/BdWwc5LjugNLupbKeTUDilD71HjuPUwX5BXP8ESryiSc7Wsv2aIT2YhFmhS3IbIVBU5Gh2RaYYfsq2FCI1Oj6dPEA8uGI4Tl6VhzLiJdP2qAQDWljaM7/89B07/xdbDJ1BqXFBq9FxJyCXNxhb7R0E71TWrmPyee37dmgOhf9GhcXfmfbnmlefk3+Rxd0m51IZsb1viYtKwjQjHQqUi4O4dbgYZLJCUCkvEOj0asRiJVot1djaCTodeJEIk5F/vIkUCQUCGtTXJDo5I7kWy10EO7h5U3LkPZ39TN9z/N2wcPV5rveclMDAQQRC4cePlM/UmJSWRkJBgjDuybt06IiMjOXnypPE3sm7dOhwcHNi6dStdunTB09PT5KV08+bNbNq0ibVr8+MCOjo6vnSfiqJkyZKvNE4wvKjnjTPvgbyg4AdQqlQpk4fwbt260a1bN+Li4rCyskIQBH744Qf8/fMXmgrOxenTpxkzZoyJxc3TVq1LlizJsWPHUKvVL21Vdv36dWxtbXFycmLbtm3Ex8dTqVJ++AKtVsuRI0eYP38+SqWyyORF1asbwkuEh4ebCGU+Pj4EBgYSGBiIRqOhQ4cOXLlyBQsLC7RaLatWrSI2NtbE2lCr1bJixQqjINK2bVtj+2CwZvDy8mLw4MHGbV5eXi819ncaZ5vXW+8l6dOnj9F6Y8GCBU+s5+XlxcaNG2nYsCEtWrRg165d2Njk923btm00bdq0kIDr7u5OiRKvnkTpcZ7ljm3GzJNw8XB7rfVeJ4+f1yNHjmTv3r3Mnj2bEiVKoFAo6NSpEyqVaWztx+8vgiAYF4wqVarE3bt32bVrF/v27aNz5840adLEJPbfm6Jgvx5fyHresT0LmUxmco2pWLEiW7ZsYc6cOaxZ83Y/9z+Nd14oA/AuHYyFlRXKrCxTYUynQyyToX38ZBEEfvki/+EjdONmE5FMLJXiVsKf6Os3KYqmAz+n17wfiyx7VURiMYlYYYUKAUhHTnba67HWGjmyByNH9gDgw8YNWXRrk0m5lZWCFSvGU7lyMEFBndA+iung7+/Jpk0HUakMc3vixCU8PFri7e1KSkoGUqmY0aPn0a/fNP78cyZNmvx/ri4JgsBnM74usqxcbcOcBFcJQavRIpa8fFbUfxOpRELXluUIvQKXbxk8J7fv19J//irQ5JC75gxu85oC1xGJRFxbtpT+ZzyQCzK6D51BqG0Wfx/Yh1PxABAEbkZG4mBnR2qG4RyPT05i3PRlz+5IgIPh7xGCAJ6eFuBpeMFzq5RO7F8J5NzNRqvUk2KTjX+GIZutR5gWvwZWHP0uigcLb6H8shzutm/e/cXN3vrZlZ6DYCcL3KwkuFlJQKfjEFmotNDM3/CwrdFoeL+8F4fuJNOhXlVu3r9IzCOXt5CganRv+SndW35K5xP76Pb1YlLSs+nWuhnRqkDC/l5HpDYLrTiTI99+xg8TfiYzO4MDoX8BsP3QhrdOKEtPT2f9+l9xdnYlMzOD3McSduS5WN7xD6BERDg6kYgkRyeTsmwrK472+RSPA3uJ8/RCpNOhFYlQaXKQiOXodXoi/YpzpWw51FIpepEItU5HilyOw71I5vfrSYUBQ+nQodM/OfT/FH5l6mLr7E164kOKDigkYOfsjV+Z12sx4+joSPPmzVmwYAGDBw8u9ACdmpr6zBhXc+fORSQSGYPwZmdnG6yBC7jN5X3Oe3iVSCQmD52urq4oFIo38rKbR7du3Rg7diznz58vFKdMrVajUqme+mJ84MABLl++zLBhwwBDcGNPT0+TwMEAt27dMrqKFMTNzfBCtGLFCuRyuYnrS8FxR0VFFZqfZ43rp59+YuHChQwZMqRQ+bO+w/j4eNatW0f79u0RiUQ0btyYy5dNw0X07t2b4OBgxowZ88QM33liX56AWBSdOnViwoQJLFy4kGHDhvHXX3+RkZHB+fPnTdq9cuUKvXv3NvbdxsbGRDCxsbHB0dHxjZ4v7wSVfMHN1hC4v+jLCrjaGuq9QVq0aIFKpUIQBJo3b/7UusWKFePw4cNGsWz37t3G737r1q0mloyvwqlTp/j4449NPj8twYCtrS2enp4cP37c6OYFBlfSPKuxoKAg1qxZg1KpNCb0eJr7spl3l4p1q+Pm7UH8w9girX4FQcDV24OKdf/9+NXHjx+nV69expiAmZmZxlAKL4KtrS0ffvghH374IZ06daJFixYkJycXWvTKi1H5tPhsAQEByGQyjh8/bnTjVKvVhIWFMXTo0Ofu0+saW1GIxWKTjL7vIv8XQplbQAAzrpwl+sZNZrVsb/KDLSSSQSFXxuxU09SnjT/7hLZfjWZJr08RRCJK1qlFQsRd7pw9R3Dd2nw89/s3Mg6A/XtPUYwUBAz3/OIlfGn/9YsH83+cmJhEevacBMDKlRNYuHAMd+48ZM+efBcrBwdrnJ3tCAjwZu7c4QwcaLCWk8lkRpEMIDPT8KOJijKYo6rVWuP/V6/e+X8rlD0vb6tIlodUAvPHQnoWdBwK6hwQ6ww3A2VGLqfCitG2QSMc7ezZuXgj1oJBvHK6kcH707ugsLHlTHg4MpkFpQMCUFjIaVm3PtfvRFC1bLnX0kerIFtqXWmJNlfL1X5nSN2SQ5ZYhY1MhmtZS0RSgcBWDkStu0vmg1T4td5rOe7TmDh8CGKZnIU7jpGW9eQbj1gkQlvA2szbzZmouHxLNEtpAatNkYg2VV1JzgIKtHktKoGEdCU/7zjMsasR+HqUJDr+Dp2b5wcYbl6rCfd21CYlPRMfd0M8hSWBnqRuO4yV1IaUyEx++ul72rbtQPdW/dh2YAOtK3XjypVLlC2bbwb+XyQ9PY0//liPs7MzBw/vIz312YsNyY6OrO/cxXDtLcIyNjYjHcHTixivRy7Wej1SsZyIFBVnojIYbJuJysnJWF8vEqGRSsmRy4l3cWX79j9JTU2hQoWKVKhQ8Ykv4+8qIrGY1v3nsu67TmC8w+VhEJxa9Z+D6A3My4IFC6hduzbVqlVj8uTJlC9fHo1Gw969e1m0aJGJm0NGRgaxsbGo1Wru3r3LmjVrWLZsGdOmTTOKFk2bNmXUqFEMGDCAQYMGodPpmD59OhKJhIYNGz6pG2+coUOHsnPnTho3bsyUKVOoU6cONjY2nDlzhhkzZrB8+XJCQkIAg2tfbGwsWq2WuLg4du/ezbRp02jdurXx5VoQBEaNGsXEiROpUKECISEhrFq1ihs3bpisos+fP59atWphbW3N3r17GTVqFNOnT3+uRAnPQ/Xq1Rk9ejQjRozg4cOHdOjQAU9PT8LDw1m8eDF16tQxCmh6vZ7YWMOLW2pqKidPnmTq1KnY2dkxffp0wCBClS1b1uQYVlZWODk5GbdHRESwbt06WrZsiZOTE5cuXWLYsGHUq1fPxA3mcQRBYPDgwXzzzTf079+f5cuX06pVK5MYMmCw0hs2bBhr165lwIABr2We/i8Ri2B0C0N2y6IvK4Zy8Zv1dhCLxcbryPNc2318fDh06BANGzakefPm7N69m9zcXM6cOWN0fypIamoqsbGxJttsbGyeKnz/8ccfVKlShTp16rB27VpCQ0NZvnz5U/uV93sPCAggJCSEX375hQsXLhgtYbt168a4cePo168fX375Jffv3ze6B5vj7f1/IRaLGTV3CqM6fYogCIWy1AOMmjP5P/GsExgYyObNm41JMsaPH29c1HpefvjhBzw8PKhYsSIikYg//vgDd3f3Iu9zeQtju3fvxtvbG7lcjp2dnUkdKysrPv/8c0aNGoWjoyO+vr7MnDmT7Oxs+vbt+4+ODQyL7HnXmDzXy2vXrr3zyTr+L4QyABc/P2xdXZ87loVYKkGvB51GY1C9AwLQqlUE1a3Nh1OnILe25ss9O95wrwvj7umCFsMXJwDie9dR2Ly6yfjixZvZu9eQrnzRok1MmfIZ7dvXNxHKoqISaNt2BBUqlGT69AH07duWO3cecu3aEzIWFsHbnvnSzPNjawXzxsL4+WJG5nSnXtp1rquPkXXpB7apnNFr1Ng2DObWgXhcFI44fGwQo95r2oL3mpq2VbVsudcmkhVELBdTfnV1nFa7cX3YeewaO6Fv6EV6Yi43tj5Ap9KT/lscxX5SIXWQPbvBV0ChsOS7UcNI08lY+MeTU2YLgkDdimU4ev4qNcoFc+qyqSvV+bgcBAFyNTocLMQUE4lwtLImXaIGtRpBEEwSF9yPekj1kg0Z23Uc7Rt2NWnL2lKBtaUhdcjGvb+yat3PBDsYYhEICFy4cI4LF87RvkMnch7qSbqfxo8/zmTy5Ol4eRUdk+/fYNu2zZw/f5batetSzMePWdMmoXkkdmWp07GSFnbrkkqlqB93zReJnhyhUq8n3sXV5LMgElHC0YKzsTls0tlTV683WqG5xcQQHlCCe8X8jMLb0aOHOHr0EA0bNuGjj56cFe1dpUzt9+k2biM7lgwxCexv5+xNq/5zKFP7/afs/fL4+/tz7tw5vvvuO0aMGEFMTAwuLi5UrlyZRYsWmdSdMGECEyZMQCaT4e7uTo0aNdi/f7+JABYcHMz27duZNGkSNWvWRCQSUbFiRXbv3v1Ua6M3jYWFBXv37uXHH39kyZIljBw5EktLS0qVKsXgwYNNxKG8vkokEhwcHKhQoQI//fQTPXv2NAmhMHToUHJzcxk2bBjJyclUqFCBvXv3mrgehoaGMnHiRDIzMwkODmbJkiV89NFHr3VsM2bMoHLlyixYsIDFixej0+kICAigU6dO9OzZ01gvPT0dDw8PBEHA1taWoKAgevbsyZAhQ14oKLFMJmPfvn3MmTOHrKwsfHx86NixI19/XbTVeEF69uzJuHHjmDdvHjt37mTdunWF6ohEIjp06MDy5cvNQtmr0rgUzO5syG5ZMLC/q61BJGtc6h/pxosGvfb29jYRy7p06UK1atWKjG9WVBbNadOmGRNnFMWkSZNYv349X3zxBR4eHvz222+F3KgfZ/DgwaSlpTFixAji4+MpXbo027ZtIzAw0DjG7du38/nnnxMSEkK5cuWYMGEC3bp1e2q8PzPvJo3fb8WsjUuZNWS8SWB/V28PRs2ZTOP3W/2Lvcvnhx9+oE+fPtSqVQtnZ2fGjBlDevqLeWvZ2Ngwc+ZMbt++jVgspmrVqvz1119FhhySSCT89NNPTJ48mQkTJlC3bt0ik3tMnz4dnU7HRx99REZGBlWqVGHPnj04ODgUqvsmxwZw9epV4/OLpaUlAQEBLFq0yMQq9V1E0L+uSLYvQHp6OnZ2dqSlpf3j2RL2LfqZfYuXEnX1Gvo8k0dBQCQW0/On77l14hS+FcrTeuQwstPSOLR8JT7lylCu6ZPTg//TvCdxwVH7KPCo1ILhJ0+hUFiwbdtR2revT3Cw3wu3uXPnMdq2NQQS//nnr1iwYCMpKelERhYdOLl8+RJUrhzM3bvRHDp07rmPc+zYUmrX/u/E1TLz5jl+Hib+nI00/iqWd2dgXakk/pUNQWYv71jFxp3/HbP8dCWotZC+4x4JX18k9Y4SK185tW63RviHsmJGRsdR5aPBpKRnIhWLUT1y+7bSqimRk8YlGxdu/7kMNycH3h/1LXtPGX5/bo62xCWb3vxqe1sR6GgQ+B5maPCyMayNpGgk/HU9AXdrCVEZGvSAjUzER5U8+OqriUWKXHPWTGHLlk3425YpVJaSG49Wr8FZYfhev/lmKr6+T87486bIyckhOTkJLy9v9u7dzfHjRxCJxJy7fotjD7KRoaOLLIWUYn7GFc376bfRCRqCHIPJVRmEyGx1BrHKSPytDeKsLDcXlUwGjz/wFBC+0OtR5OSQY2mJSKPBLiWFFBcX0OvJ0ep5mK6mhKOFcVdrLxkJsQm4aW2wiIsn08YGv7t3uF66LBKRiOmz5uLo6MR/jX/i/q3Taom8epSM5BhsHD3wK1P3jViSmTFj5v8Irc6Q3TIxwxCTrJLvG7cke520bduWOnXqMHr06FduSxAE/vzzT6O7+Jtk7dq19O7dm7S0NBQKxRs/npn/HlqtlvNHT5MQE4eLhxsV61b/T1iSmTHzLP7vhLI8MhITeXjjJn4VQ1BmZqLT6XD4F1d6X4S2LQcRs2sTWUi5gyMqQYqdnQ2pqRm4uzsRHf3XS5k4HzlynnPnrhMXl8z06aufWlcQXjzZZkCANzt3/kBQkN8L983M2433tDF47K6MxLMVCGJUqkN4udtgH/UVq7ccIfz+Pc7fuE7ZEoGU+o8ENddmqkk/k4JNJQckti8XIPpV0Ol0hF69xdcTphMQdphOyZFcqd4IxxFf0bN1E1RqNfKa7Yz1a3jKORVtGl/Lx0ZKQz8rNDrYeycDXzsZ9nIRjSqXY+vJi4RG57tjSgToUc6BSpWq8GHXngyfs5z45FQWfjWQAG8P0rPSmLRwBDlxalwc3bh3+wEiQYRer+d84hEy1MkUsw6iSb2WjB383T82T3nEx8czY8YUUlKSCUhJIcLePl/EwuBypdFBaq4GZ0uJ8RoZmxXLlVvJlHZwxdPPsFIfkxXJjdSzVHdrhqXEhuIREaQ4OpDq4Ah6PdVPnSTB0YE7QaaWCAHht8m0sibuKfcSvV7P9ZQworLCAaihd6P/iTju+fhwunpNtI8CelcIDMLS2YUuXXqYxCb6t/kv3L/NmDFj5v+NmTNn0rVrV3x8fF65rTcplK1evRp/f3+8vLy4ePEiAwcOpEGDBu90wG8zZsy8m/zfCmVvMwd3HmRc6y6cwgc9htUwCwsZSqUKOztrkpP3mZh6Xr4czokTl/jgg8Y4Otpx9ux1rl27ywcfNEYuN1g4qNUaAgI68OBBHIGBPjx4EI9Wq2Xs2F6cPn2FffvCaNiwMmFh10lLy3zpdOz29jbMmzeSHj0KB/o18+7Sc/tsTi+sgrNLA5PtZQPUDPtYwub9P6NSqxGJRHzZtx9Syf+NV/gz0alU3PluEtrsLALGT0ZS4JpZssMnhD+Ixs5CRMsSNmy4msbjkQfyMnbq9AZ37RpeVkwdNZie3/yATqulprcVablaDt/LpEsZewRBID4+m79ilQD0atOUFROHmbTZ7LPqREY44G9vS5Y+l4Tso1SvVJs29TvzfuMeL5zd9sGD+6Snp1GmzNPda2Niolm3bjUWFhY0btycP/5Yx607d5Fb2SKosoyBUaVKJWoLC9Dp8LsXiWNyMucqG1xGLTIyybJUkJSjw14u5mxsEreSJYgATwdLsrKzsVNcQCxJp0vTnrSs1ZU9G9ZR8mwYlxwcSLSzp8GRQ1hlZ3MrsCTJjo4kODnDo9VR6/R0Mp9xX8tRZxGa8DcWYgUlbMpT+14aN0sVEN10OqP1mrOzCzNnznmh+XyTmO/fZsyYMfN28yaFspkzZ7Jw4UJiY2Px8PCgffv2fPfdd1haFp3B3YwZM2b+q5iFsreQmZ0+4tCm7ewiEBAQoUOCDp3EgvnzR5Keno1cLmPTpoNERDwkKSmVnBwl9etXYsmSryhXritqtYaePVuxcuVEADIysnBwaIJWq8XW1orVqycycOAs3N2d2bdvPnZ2BouGrKxsWrQYwrFjF1+6/1KphMzMQ8asH2beffR6PXvPRDJuhhViCwUScUELGT2Vyx7C0eYqtlZWDOnR84WFlv9XRs9dzuxfN9EywBoLsYgtt9ILxdCSiwXc7RRk68TEp2bgby/D28uTI1cjae5vjYe1wVpu391McjU6mvtbczU+h4sJKvTAoNb10CSEExAQyODBI0hOT6ROz5qExxiEHQe5mPdLOTBp0jQ8Pb2e2l+9Xs+lW2fx9SiOg63BrTAiIpxp0yah0+no0OED2rRpb7LPw1UrOL/oJ5wCg9mhzCTG2q5Qu7vCM6jgJsfTRoplVhZ2qSn5QfWBOkcPE1a1OkoLC8qHhfGjcwAPMkVYyUTUsdFxPF5Fpjj/eiTR6yjnZkllbxtGjvyKkiWDGTlyMMnJSQA02vc3hxs0QiuRoMjOJufRC4BIq6XDn5u5XTKQXJkF4SUC0YnFJpZteahRIsUib2KMdWwFgeKXL3PxUbwoqVRK2bIVqFmzNlWq/PuJUMz3bzNmzJgxY8aMGTPvOmazjbeQCvVrsn3T3+Sl7HEjk3rc44imGN98s4zY2KQi90tISCExMRW12hDzaPv2o3z00UR+/vkrbGysWLlyAhs27KVDhwZ07PgVWq2WqKgE2rcfhYODLXZ21tSoUdYokpUuXdwYyL958+rs2XP6ufovk0mRy+syaVI/xo9//swdZt5eBEGgWdXi9LnyLdaBjRBLLLBSFEcmcQQEQq9VA4viBFQ/aRbJXoCxfT4kPSubjOR4Tl+4XGSg+VytHrFWTXxaNgB3UlXkkgDA/TQ1HtZSstQ6knI05Gr0xGRpCHJRUF6ZRsVLF7FccJI/KtciLTObe/ciCbt9hKyceyikjoA75V3laLVaUlJS8PT04nb4DXYc/x0tWtQaFR0adSe4uEH0Gb9gMCu3zsfV0Z39S6/gYOtEdPRDYwae2NhoAFQqFRcvnsfXtxh/LvqJc6XLIFGr8X8YS0yQnYmwpNHpjf33tJGilkrRiURGqyyxRoNDaiohJ0/hlp7KUUcvUtVSQEuWSsf7p49w17sCt8QyRIKATq9HI4i4mJBLBXcFERG3SctWGUUygJtBwahEYu6lqLCTy0hJVnIzSUlFspBoNZS5dg2lTMatYIOYaJOejltcLOElAo39drRyJCMry9CgICBotciVShqePoVlXCzyrAwi/QNIcHPn/PkzXL58gZCQSkjM1pZmzJgxY8aMGTNmzLxRzE/cbyHNB33BzSs3Cf95DxnIKUs8YvR4ksGtrPyYQ3kxeHr3boNWq2XIkC5UrBjErFmDWbRoI3fuRLNmzS4aNapC795t6NHjPRITU+nb91uT4927F2sM2F/QADEpKY1ZswaTmprB1Km/FNnXx1MCA2Q96uOSJX+ahbL/Mzxtw4m4mEZQvakI2kz0ekNWWbHOCnKsiDjsQf0j0LgGjOv3VsXZ/Vewt7Fm8dhBAGw7cooOwycbxTIBjP/PUOc7ZDpbybC3dyA6NYvrSUoi01SotHq0evCyluBra7CsUthb4ZubQc/A+mQm6nHPzWKZlzcyq0Y42xWjvKMXHtYGy0AHBwdKly7Drl3b+WHFZEQiMTFZkSQr49iwewOrp+6nfGBxwq4cAyA+OZbI6AgcbJ04fHg/YEiF3b59JwCWLl3I2bNhyOVybB7F+9JIpTgnJeJ1IIojdeqifWSRGpuppkExK5wtDbcztUxGnIencbx64GSV6qQ9SOCiW0nqWGr4MOUhWxXuVM5KxEWj5JbcYKUmFouoUNyH87cj8bGVYm/vgHdAKep/MprmxWQopAb3yoc+vpyJVXE9PguxICASQK3Ts1dvwReIkKPlUrWKyOUKBJWSKmfCcI+P44OP+7IxLobo61dxuX2bjEeZwgD0YjFVw05jGWdIv+1//z5tv5/PT4f3ExcXi73982c5MmPGjBkzZsyYMWPGzMtjfg19S7mydSuNiKQdN5ChIQMZETiSkZFtrKPX61m+/GuWL/+alSsnUrFiEAAjR/Zg0KAPAZBIxJQp42/cZ/v2oybHsbW14pNPDAHDBUHgo4/eo3Xr2gDExSWTmppBeHjUEwP7i0RPTirQt2/bFx+4mbeav/+ex7K5LVk2LpZOZafzRf2f+HYw6NGiR4tYb4FWB3+fgKHT4O/DBsMgM8+mbb0a3PpzGV/1/pDxn3Rj4ZdfIAhgKZMwolcX6pbyJcRNTmKWimuRUZT09UIkCORoDCIZQKpSh0prmHCVWMJeB2+jS2JKrpYth0+TmqnnVnQ59tzRoH60Y2JSMmfOhHLr1k28rAPwsgogxLkeaq01VyJLEtJ1AHN/28KXfadRyr88H7X+jJCgqmg0Gu7evQNAVlYW586dITk5iYSEeDxiomn6xwZKJSUjUamQ5eai0+vQiEQGd8ZHeNvKjCJZHq6ublhaWgEg0umQ6rVIy/rTIyeapqeP88HN88x9EMakMQNJt1DQODUKQa9nXN+uLBvzCZ2C7Wjga0WJEiVJSMskNTuXP29mcPl6LE42toSEVMLd15B0QqvX46cwuK/6KDOxdnJE5uxMmUat8PcPoJedA+7xcQBYKRR88V4b2v65iYfej1xDdTpjZpTT1WsCIPPwpPzBk1wWCVRKTyfoTgSlcnL47LPefPPNOHJycjBjxowZM2bMmDFjxsybwRyj7C1lbMNW3Du0Hw0CZ/EkCjvkYkjTmr4wWllZULt2CFu3zjYG7s/jxIlLODnZERRUzLht9+6T9Okzhbi4ZHQ6He3a1ePYsYskJaXRpUszfvvtW6ZPX8XXXy9CLBaze/dcBEGgYcPPC/WxTBl/rK0tOX36SqEysVjEjh0/0qJFzdc0I2beBs5eg6lLwcsVpg8Fy0eZwu9Fw9aD8Puewvt0LQcffgLOZoOaFyY+ORWFhQwbK0v27PmLn1asZFdEJgDNalTi71PnjHVdLEV42Ui5l6amkpsCN2sJm26ko3wkhklFoNZBp8a12bj/OACdS9lhKRWh1uoRafR8+vlnrFy5zOBKKcChWCWRcQbxvlPj2swf0xdXR3eTPn733UQiIsKNn/VAMb/ihKxfh1XkXVQSCQc++JAUnc7goqjTIeh06PJcEPV6ZBYWqFQqYxuDBg1HqVRy4cJZzh87gvqR9ZlDchJN9+1FrNNhWbU6tQ+f4r1B49lz8ix+nm5c+2MJcgsZO3duJS4ujvbtO2Jv78DH73Xkyv1oPo27Qee169ihvMvGfVu5FC5giYqWFUtQYt9FgmQC9XbsISolmW+/nQCAv08xetg7gFhCyuEDKGOikbq4sNDBAf3jbsZ6PRVv3yLoymVOtu3APYnY6GYqVqvRSg2C3ODBIwgJqfQqp8ZLY75/mzFjxowZM2bMmHnXMQtlbyE3b96jTOnOtNNdQY4WHaBBhAg9F8S+3NbZFbLwqlQpmMGDO9OzZ+vnOsb163e5fDkchcKCtm1HGrd/+ml7li3bil6vp1QpP9avn8q5czewtLSgb99vycw0tXSoX78S58/fJD09q9AxRo3qwcyZg194/GbeXkb/ACcuGP4/eSA0eiw2eVQcLN8ER09AbgENQSrRMbLrbVo2KWl0KTbz4ty5E0HYzbuk5ajp3LQuDfoM49LdhwCUc7GgsodpVqpj97MIT1UhFwt0CLLldoqKMzE52FiI0Wp1SMUCJRxklHGRIxIEXF3d6NLlI376aTbxWWr+eiTKWSksqO6XSXp6BL0sPGkSUIPz1ZsQmZLGg/OHyM5MNx4zW61j791MJjrEUWp/GCdr1iSyWHGTfjXav5cDjZsaP3/0UW927txKcnIyYAiAr1arsbCwQKlUIlGr0UilBFjbIE1KxEWppPk3U/EsW45cpYrjF6/ham2BXqOkbNnyheLkKePiuDt9CnK/4qjav0ejT8oAEGxfBV+bkgDUPXIY7+iHBE6bTWrxABb9sQ61VIqvrx9ffz2Jv0YMRrF0EQCSxk05Xbsud65cwiv6Ifd8ixmzXJa7dJHga9f4vU17BCtFficKxGVr1+592rXr+BJnwKtjvn+bMWPGjBkzZsyYedcxC2VvIadPX6FGjT40IxxnsklFxjGKkY6cAJIQpArC1VaF9hOLxTx8uIOTJy9To0ZZ3N2dyc1VEh2diLOzHd27TyAuLpkFC0bh7e2Gh4czyclpBAZ2JDnZ8CLr7+/FnTsPX6i/gwZ1Zt6830222dlZExa2ksBA35efCDNvHVsOwOyVYG8DyyaBu3PR9aZOA+1J2GNHXs4KLLmI3NqPTKUdberDx23Byf4f6vg7SmxCIjU+GsT9xDTsLES0DLBBKhYQCQJanZ4tt9LQ6qBtSVvkEhE5ah1hMTncTVUZ45/V8ZQT4CRHEATs7OzIVeWgzFGRpdKx/14mZZwt0OqzKenogFdUFFXDQtnnW5L5UkOGzGAnC2p4GQS6OylKriUqSczR4mp7GA9VDiX9WmIly8906RYfR9nLl9nfuInJWNzc3Il7FN+rIOUuXST45g2y3NwJd3fnVkmDC3qxYsWZONEQjzEq6j6TJn2NVqvlvfda06lTF7Jzs7BSWBdqLy4phtofB5CryiHIvjLFbAzt1T98CM+YaFzadmBdViaJLi6g12NtY0uHDp3YNu9Hmu77G6lGw8lKIex30zL0cARx7h5kWlpyp1RpRHIF/ufOEJ6mIbfOI4sxsZTAYr7cvhNh0g9PT2+GDx+No6PTC37rr4b5/m3GjBkzZsyYMWPmXccco+wtpHr1ssybNxKv7p9h16wjuUhJRwEIROCMtToNoYj8d76+brR5byADOnxGSOkPsLKqh7V1fQICOtCu3Sh27DhGWNg16tTph5dXK5Yv38r+/WFGkUwul1GvXsgL9/dxkczZ2Z7IyK1mkez/kPaN4M858PvsJ4tkAGPGQNtZGEUygGwqkJxph0oNm/ZBx2Fw7vqb7vG7jbuLM5G7f8PV0Q4nhQSlVk+mSguAWCRgKRWTrdETl6VBr9cjlwhUdJebtHEhQWW08ktLS0OZY3CBtJFLaBdkT4CDBSUdDX6zWZaWHKlfn+uBJY376wqs1Si1OjLVOgLsZRRzcifNysJEJJNKpfQeM57gGrUIeUykychIN/msR0+mKh2v6GgkWi120Q+Jdvcwlufk5MdzTEhIQKs1jDs6+iHthtQiqK0N36/+ptCcuTl58NfCM3Rv2Y9SIUFUqlGJPr0/pcGQEZSYMp1r1jZkK/IswfRUrVoDGxsb0uztOVWtBhF+xTkrTyZXm82N4GBCq1XnWtlyaPV6Sp88RqCbO+l16qDRGebF0tKGZjExKDIzTfoRHR3Fxo0bCvXPzMsRGxvLoEGD8Pf3x8LCAh8fH9q0acP+/fuNdfz8/BAEAUEQUCgU+Pn50blzZw4cOFCovbCwMBo3boy9vT0ODg40b96cixcvvpa+9urVy9iPov78/PyeuK9KpWLmzJlUqFABS0tLnJ2dqV27Nr/88gtqtbpQ+1KpFDc3N5o2bcqKFSuMGWoLcvLkSRo1aoSVlRW2trbUq1fPJI7euXPnaNq0Kfb29jg5OdGvXz8yHzufXwebNm2iQYMG2NnZYW1tTfny5Zk8ebLR0nTlypXGcYnFYhwcHKhevTqTJ08mLS3tie1Onz4dQRAYOnSoyfYGDRoUmvvPPvvMWB4ZGWlS5ujoSP369Tl69CiPk5yczNChQylWrBgymQxPT0/69OnD/fv3X8/kmPlXyPstTZ8+3WT7li1bjPfNQ4cOIQgCqampxvLo6GjKlStHvXr1nnpumjFj5sUpeF22srIiMDCQXr16cfbs2UJ19Xo9P//8M9WrV8fa2hp7e3uqVKnCnDlzyM42PEcuXbqUunXr4uDggIODA02aNCE0NPSfHpaZN4BZKHtLGTiwMyvWTGXhnrUo3H2wQG0sk6CnFTfw87Q32Sc6OgHx+QMEk4A+JY7s7Fy0jwJ3X7hw01hPpVKj1+vZseMYHh5Oxpt5jRplWbly5yv3vVmz6tjb27xyO2beLhKSYfpymLgQNu8vus7andC8P0xfBuVLQjGPousBaLSwdkfRZfHJkGx+tnxuGlcNoZK7HFsLMbYW+XEOZWLDb//gvSwuxOUiCALZar2JDG8tlxXZpk6nQ//YS3W6szPZllb42Mqo6SHnk3qVaBDoaiwv5azgPX8tFT00tCzXhd2LzyGR5PenR49e+Nesza5y5bmQbiqM+fj4mrjlCghYy2y5Wro02QoF9719yLS2xkarxUqh4OOP8zPuVqhQkWbN3iMkpBJVa1fl3PVTAGzev6bIsZUsVpoZw5Ywf9xaBvYbQZ26DSg2eDg577Vin05DtrU1LjodwweN4KOPelGlSnUG9ulHndOnCIi8S7dzsbhZ+hJeIl8wtE9KJDA8HPmBfVS+eZ6YTDVxmWo6RoaTuHI5Uq2mUD+kUgmZKSmkHDtCbnR0kX19G9FqdRw6FMdvv0Vy6FCc8T71poiMjKRy5cocOHCAWbNmcfnyZXbv3k3Dhg0ZMGCASd3JkycTExPDzZs3Wb16Nfb29jRp0oTvvvvOWCczM5MWLVrg6+vL6dOnOXbsGDY2NjRv3twoRj3OypUradCgwXP1d+7cucTExBj/AH755Rfj57CwsCL3U6lUNG/enOnTp9OvXz9OnDhBaGgoAwYMYN68eVy9etVYt0WLFsTExBAZGcmuXbto2LAhQ4YMoXXr1mg0+efiyZMnadGiBc2aNSM0NJSwsDAGDhxodF+Ojo6mSZMmlChRgtOnT7N7926uXr1Kr169nji+Q4cOPVXsK4px48bx4YcfUrVqVXbt2sWVK1f4/vvvuXjxIr/++quxnq2tLTExMURFRXHixAn69evH6tWrCQkJIbqI31BYWBhLliyhfPnyRR73008/NfkuZs6cWajOvn37iImJ4ciRI3h6etK6dWvi4uKM5cnJydSoUYN9+/axePFiwsPDWb9+PeHh4VStWpU7d+48cdwNGjRg5cqVLzBT/7/odDpu3LjGqVMnuHHjWpGi75tALpczY8YMUlJSnqt+REQEderUoVixYuzZswc7O7tn72TGzH8YrU7Pkbhsfo9M50hcNlrdP+7MVoi8e+bVq1dZsGABmZmZVK9endWrV5vU++ijjxg6dCjt2rXj4MGDXLhwgfHjx7N161b+/vtvwHDP6tq1KwcPHuTkyZP4+PjQrFkzHj58MQ8sM/89JM+uYua/zo6YCyQnpzFmzHxOrVtPQHYyYvRkxsTSqlVjdu40BN5WKtWcxgc9IhzJwhA22/BimZpaeHX35s17NG06iDzv3EuX8gNu29tbG/cpXtyTzMxs0tIyUanyH6A//bQ969fvISMjf2W5bdu6rFo18XVPwb+GXq9HEATioqKZPmgcPgF+DJo2FumjoNtm8vn2Z0Mwf4BLt6BCEJQLNK2zYjMo1bDrGHzaCWaNhN5fQ1aB0HcWUkMdgIs3Da6ctjaQlQW1K0F6BkxeDBIJfDcIqpQFqflK91TGdm/FyMkXuJ6YjbuVhEy1jgyVjvis/Jf6iBQVZVzkJGZrCLCXkanW4qyQMGfsMNauXPxcx9HpdEjt7XHIyaFBjfLU7NwVGxtbrl27wtp1K9HrwFJmQ3z2A6xtrPFx96Nbt578+usKXF3dqVixClu3buLOnfBCbd++fQu7lGQck5K44x9gjOf1wLcYD3wNCUv8/QMYN25SoTh3IpGILl16AKDWqKlfpTnHz++nZ5svCvX/8fhleSQmJrB8ef48lGrQiLKVqqDT6dBqNZSvUIndgggLIFsvpXKVBjy4fht9XpZRWX6ylWQrS7xtDNeQXToROS1bk2Vjurgglco49fdubL/+EttHL2Dlft2Ae8fOT/8S/uNs3vyAIUPOEhWV/6P39lYwd25l3n/f540c84svvkAQBEJDQ7Gyyg9bUKZMGfr06WNS18bGBnd3Q0IKX19f6tWrh4eHBxMmTKBTp04EBQVx48YNkpOTmTx5Mj4+hj5PnDiR8uXLc+/ePUqUKPFK/bWzsyv08mxvb2/s15OYM2cOR44c4cyZM1SsWNG43d/fnw8++MAkIYaFhYWxPS8vLypVqkSNGjVo3LgxK1eu5JNPPgFg2LBhDB48mC+//NK4b1BQkPH/O3bsQCqVsmDBAuNvZ/HixZQvX57w8PBXnguA0NBQpk6dypw5cxgyZIhxu5+fH02bNjWx1BEEwTguDw8PSpUqRZs2bShTpgyjR49mzZp8cTwzM5Pu3buzdOlSvv322yKPbWlp+cx5d3Jywt3dHXd3d8aOHcv69es5ffo0bdsaMn+PGzeO6OhowsPDTc6tPXv2EBgYyIABA9i1a9dLzY0ZA2fPhrFu3WpSUpKN2xwcHOnW7WMqV676Ro/dpEkTwsPDmTZtWpFCakEuXbpE8+bNadSoEatWrTJZKDJj5m1k64MMRp2N52FO/vuhl0LCrMqutPN5c0YTOp2O2bNn8/PPP/PgwQPc3Nzo378/48aNA0zvmX5+fjRr1oyePXsycOBA2rRpg4ODA7///jtr165ly5YttGvXzti2n58fbdu2Jf3Rgu3atWtNjr1s2TI2bdrE/v37+fjjj9/YGM28ecwWZe8Ijo52LF06jhlzR5OBBbdxJFFvwe7dJ2jUqArTpg1EEED/6CtPxgowuB8UxMXF3vj/69cjyc3Nf3BOTk6nceOqjB/fl+LFPY3bHzyIo0GDyiYimUwm4dChs5Qtm/8QXL58Cf74Y/pbf+M/c+gEs4ZO4D3fKlQSedKmRA3alazFoS27+fX7xcz9agoD27dl5tBxRneuy6fP8fuiVWSmZ/zLvf/nmf8bfPoNJKbmbxOJwMEWtDpDAP8OQ6B+r3wBTCYFRzvwdAFXR9P2lAUMMnJVhrhnq7ca3DGHzzSIZDo9qNQw6gf4cCQkpWLmKfQZ9y17wtO4mqhk/70sTkfncCNRidJw+uIgF1HDS8GJqCzCYnK4k6qihpcVVT0tTUWy5wh5mZGbS4wgcCsnh2nTJjNjxrfUqFELTw9vAKQiGV7WAVy9fIWBAz/l1Knj/PTTEr77bibW1tbk5OQa27KwkBuvJzqdjlonjlM9LJSWf+1AnpNT5PGflQxCKpGydtpu7u5S0a/TcOP2S5cu8MUXfRk4+HOOhp3n99/X8fnnfVi7dhUAFy6cM1oM+PuXoGvXjzh27Aj9+vXks8/6cObqJeZUbMQql0DG+1Tm8tlrVK1S3dh+moMDh+rV51C9+jz09jG6BSTY2BlFMuHR9QTAIjmJNrt2YlPASiFu8x/PnP//Mps3P6BTp2MmIhnAw4c5dOp0jM2bH7z2YyYnJ7N7924GDBhgIpLlYW9v/8w2hgwZgl6vZ+vWrYBBKHJycmL58uWoVCpycnJYvnw5pUqVemFLqdfJ2rVradKkiYlIlodUKi1y/AVp1KgRFSpUYPPmzQDEx8dz+vRpXF1dqVWrFm5ubtSvX59jx44Z91EqlchkMhOBWfHINblgvVdh7dq1WFtb88UXXxRZ/qzv0NXVle7du7Nt2zbjPRtgwIABtGrViiZNmjxx37Vr1+Ls7EzZsmX56quvjK44RZGTk2O0VpA9ysSr0+lYv3493bt3LyS4KRQKvvjiC/bs2WN0HzXz4pw9G8aCBXNMRDKAlJRkFiyYw9mzRVtgvi7EYjFTp05l3rx5REVFPbHeiRMnqF+/Ph07dmTNmjVv/bOyGTNbH2TQ/Vi0iUgGEJ2jofuxaLY+eHPvRF999RXTp09n/PjxXLt2jXXr1uHm5vbUfYYNG0ZGRgZ79+4FDNf3oKAgE5Esj7y4vEWRnZ2NWq3G0dGxyHIzbw/mq/A7RstPPuJcrIrx45cAoNXqOXDgDEePXijyHbbgQyFAQkLqUwP2Hzp0lhEjujF16i/GbRqNtlBWS5VKw+3bD7h9+wF9+7ZFLBbz3XefI5P99y2tEmLiGNGhD5npaQS0SQCrOGqWGsONa8excRexZshFVMp8ATEq4p7J/hsWLqFcjyQuPPybY3/VJ6BMEP2bt8XSI4tTB/bwwx/rijzu2SMnyc7Mpm7Lxm90fP8ktyJh/aOFcIcCIaXKBcLuY7DzCCQU9EZ4lNlPEOCn1ZnoH86gWXBFciq/z8WbBguyZ/G4RXd8MgycCutmGI2MzDzGldjCWWlFIsjzTGlW3AaFVMTVBINIpYeiTecLZGYEyFLpiEpX8TBTQ1kXOa5W+bec6GjDNSYtLZXk5CQ++qgPS1csJPzBNRwsXB81p+fWrRv8/vs6bGxsCBJLUKxaDo+sdCwtLWnW7D02bDCs5qkfWXJa5uSgE4mwtLSidOkyKJVKcnNz6djxw+eek8cFtePHj6BSqVCpVHz69RRKOclwkIvZv/9vOnfuStmy5bG1tSUnJ4f27TtiYSFn586tRveerVs3Y+dtxzl5GQKtJNhaiHn4MIqG9Rpy4e9dFL96hajixfG5d49cmQXJTk5Gscw4vQUWNlwS4rF4ZAGkkkhJcXCgQre3d+VSq9UxZMjZIu9TeafV0KHnaNfOC7H49a3xhYeHo9frCQ4Ofuk2HB0dcXV1JTIyEjBYnR06dIj27dszZcoUAAIDA9mzZ8+/+vJ7+/bt53bvfBLBwcFcunQJwOgS+M033zB79mxCQkJYvXo1jRs35sqVKwQGBtKoUSOGDx/OrFmzGDJkCFlZWUbrszy30Vfl9u3b+Pv7v5Ild3BwMBkZGSQlJeHq6sr69es5d+7cE91YAbp160axYsXw9PTk0qVLjBkzhps3bxqFxDxq1aqFSCQiOzsbvV5P5cqVadzYcJ9PSEggNTWVUqVKFXmMUqVKodfrCQ8Pp1q1akXWMfNkdDod69atfmqd335bTcWKlZ9oLfw66NChAyEhIUycOJHly5c/sc6HH37I/Pnz31g/zJj5p9Dq9Iw6G19ExOx8f6bR5+Jp7WWNWPR6H84zMjKYO3cu8+fPp2fPngAEBARQp06dp+6X9xyQdy+/ffu2iYX08zJmzBg8PT2fushi5u3ALJS9g3z9dV8uXQrnjz/yA0Gp1YXj2zyJp2W1lMlkrFv3d6GYMUlJaYSFraJRo8/JyMhfUZVKJcycOQhHx7cnxsLu3/7k8ulzAEQ90CKzlpDYajy3d9gjd1CjUloW3knQ41s3E4lcz/0j1iTdkONdKwudhyMZaemU6hqL3F7L/bO7WDL5B7QaDWWqhhAXFU3kjXCEyiVZPnkOiogYRs6ZTPchn/7Do34zuDkZLMOS06BiMBw5a4gtdvGmnos3C98Y826eShVsPmiNLq0punWf0G98OS7eDCxU/3l5EAu/74boRAjyg+a14TW+a7/19GjVmKVb/sZSKiAXgbWFGHu5iIcZGpwVEmw0SjRSBfoC2RXSlVpKZqciVauJ83gUTO7Ri4ZerydNqcNCLBDkLKeEo56zsdkmQhnoEYlEODk54+DghLe3FR3afsCyZYsK9e/o0UMA3D97FtHDeGwkUjI83BGDQSR7pKQcaNgIq8xsdAjYennz5ZfjX1tWyBo1ahMaFkqWSktUupImVcqQHXOHkJBKSKUy3N09mD17niE2W3IyaWGhVKpUhV27DIH0QkIqERcXSw0vSzw8PEm4egvrPau5au1A1ehwnLQqguwd2FimLEE3b4BeS6qTC4G3b6EVi4kIKGEiQkZ5eRPvchfL7CxO1qiJb0IC++LjaBIfh6vr01dN/4scPZpQyJKsIHo9PHiQzdGjCTRo8PrG97oSf+e54YPBcqhv377Url2b3377Da1Wy+zZs2nVqhVhYWEoFAru379P6dKljftrNBrUajXW1vmZVseOHcvYsWNfS//y+vg62sgbZ54I3L9/f3r37g1AxYoV2b9/PytWrGDatGmUKVOGVatWMXz4cL766ivEYjGDBw/Gzc3NRJgoOG6tVotSqTTZ1qNHDxYvLtrF+3WNCwwC+YMHDxgyZAh79+5FLpc/cZ9+/foZ/1+uXDk8PDxo3LgxERERBAQEGMs2bNhAcHAwV65cYfTo0axcubKQqPe8Y5g6dSpTp041fs7JyeHUqVMMHDjQuO3atWv4+pqTJQHcunWjkCXZ4yQnJ3Pr1g2Cg0s/td6rMmPGDBo1asTIkSOLLG/Xrh1//vknR48epW7dum+0L2bMvGmOJ+QUsiQriB6IytZwPCGHem5FvFe9AtevX0epVBoXJJ6XgveBgp9fhOnTp7N+/XoOHTr01PuHmbcDs1D2jrJmzWSsrRX88ssTop2/JDk5uaxZUzhWxsWLt6hevTdly/obY5l5e7uyZMmXb41IptPpOLz9bxzdnJFbKlDm5qLOFKPOFBN7zgq74krOVu5ETm93Su3ZgqfoHpaOOpxFTbl29Qg+tfOscvRYOcNdz9Y0yrnKpy5+WDpA9DkFd/bKidg7y1gPBFIaluNep0BYPojiY3/ll+nzaNa5LS4ebly+sYPU1AfUqNKHv9dvZ+svG2jRrQPv9+32L83Si2FnA6u+g/sx4OcFB41JYAoEXRdAr84BiaLQ/iK7eggVTrD3bOGyF2Xeb/n/X7MDVkwGucWT6/8/8cOwT8m8fZrQh9lEpKpJVmq4/yhWflKOir73b+CRk8kJ13LEYpi028kqel88hqOg5UKFEB54+5AtliATixAEAXu52Ji5EcDb1uBqpFHnIJHIcUhNIdPKmoSEeL77biLu7u7ExsY+tZ877bw5KPXHKgXauepJzHsBevRQo5VISbe3w97envff/+C1iWQAFStW5svxU5m4ZA3DanszqX8PMjMzsSkQO0wikZAb9YCT1cqjSU3FZ8gI+vTpT8WKlbGysqJMmXJkZ2dTtWp1fi0TjEdKDKTEsL50VVzcbHBSqXCLi8VCqaT6mTPc9/GlwpXLAOhEYu76+xuPpbawYH/jJkhUKjyVSm77+JBx9CB3o6MYN+6b1zbuf4qYmCeLZC9T73kJDAxEEARu3Ljx0m0kJSWRkJBA8eLFAVi3bh2RkZGcPHnSKAatW7cOBwcHtm7dSpcuXfD09OTChQvGNjZv3symTZtMYp28breNkiVLvtI4wfACkjdOj0cCeUHBDwxWUAWzNXbr1o1u3boRFxeHlZUVgiDwww8/4F/gfC44F6dPn2bMmDEcOnTIuM32sSy3BSlZsiTHjh1DrVa/tFXZ9evXsbW1xcnJiW3bthEfH0+lSpWM5VqtliNHjjB//nyUSmWhsBUA1asbXKnDw8NNhDIfHx8CAwMJDAxEo9HQoUMHrly5goWFBS4uLtjb23P9etEpnK9fv44gCMZYbp999hmdO+fHIezevTsdO3bk/fffN27z9PQs1M7/KwXj072Oeq9CvXr1aN68OV999VWRySyWLFnC6NGjee+99/jrr7+oV6/eG++TGTNvitiniGQvU+9FUChe7p0h7zqcd4970Xvm7NmzmT59Ovv27XtiAhgzbxdmm4p3mB07jv9jx1Krteh0OmxtrShe3JMmTapx/frvtGz5dDPX/wLxibfZtmcsM8Z+yvD2vRn/8WBqt63N5z91R24nAkGP3EHDHVk54j5sQHrNYO73aYNn1Rxy08Qc2XCWpBtyNLmGl3WJYMflQ/7sqtgJgL/S4unVZS2uDmVMjutR1ZBQITfA8LIhzshBVtcW+5BwelRvys2IAyxZ3YYN275g+erujO85iLADx5jyyQiO7z7wj87Ry5CSDp8OPs+g/r9jo7uFnTW4FtAt8lZq9HpAbFh1KehmJhEbykVSJx7EPz12zotyPwYizcloANi5cyszZkwxClyPIwKi/Py4HRBIfRcJHhId9XwscbYUkySxQK5UUikslMM3kvj9Who5ah26R9+tRCSg0+vR6/V4WhteYCVSwwNMyPnzvLfrL2RqFbGxMVy4cB5p2Gne37yRhgf2I9aYPjxpdXoOZhnayNJAlvrJGctSU1NZuXLZ65geE4KK+7J++limfP4xIpEIW1vbQnOWdfMGmtRU0mxtWR4bzYoVS/h1xiTGtggkcv9GqlauSvTqX7BxcQFAKYjQeboQ7+bObS9vonx8OVulKnOCa6ArYJ0rU+UiejQnVlbWRgHGysWVFiO+JMvO3lBPVnQW0v86Hh7P92D7vPWeF0dHR5o3b86CBQvIyirsgvw8L9Bz585FJBLRvn17wBCfRCQy/T3lfc6zwpJIJJQoUcL45+rqikKhMNn2uoWybt26sW/fPs6fP1+oTK1WFzn+ghw4cIDLly/TsWNHwBDQ2NPTk5s3TX3ib926RbFixQrt7+bmhrW1NRs2bEAul9O0aVNjWcFxe3l5FTk/TxtXZmYmCxcuLLL8Wd9hfHw869ato3379ohEIho3bszly5e5cOGC8a9KlSp0796dCxcuFCmSQb7YlycgFkWnTp2QSCTGvopEIjp37sy6desKLRTk5OSwcOFCmjdvbjwXHB0dTeZFoVDg6upqss0c2yqf54kx+CL1XpXp06ezfft2Tp48WahMEAR+/vlnunfvTsuWLTl8+PA/0iczZt4E7ornuw49b70XITAwEIVCwf79+59duQBz5szB1tbW6DLZrVs3bt26ZYw/WhC9Xk9aWprx88yZM5kyZQq7d++mSpUqrzYAM/8ZzHfTdxS1WkNamiErpaOjLc2b1+C33/5+4XYE4bnicwMgkYj5+us+NG9e84WP82/y85r2xMZfQ6cDicIVTY6IKze2kls8g7qDfNn7rY7IA7YI3umIlGp0FlJcdA9JiZBx74g1er0evVrElfUOKBy0lK1UGVGNfYjnz0P1VxIWiEhbPZ8qFXtw+veZSKUSqjSqS6r1ZmLCBJw3nUDIVeG27jAikQ7LLmpic+OYM+pbroU5YumiQdt4E4LEFb3K8HJ86eRZardo9C/P3NOZ9GMs11MrgrQiX4+aybodo/m6H4z9CdRKJeKUY2TKqyNIrUEQEAtq9IjQ6Q0vIVYKAbUGvFwFbt8v3L5EbHDjfBnkMj1RkQkU83BE8QZu0m8LaWmpbNr0O2Cw8avmaYmlVERitpqYTC0SETTwtSLd1oFHBmaUUqjIUGlRavRM9KlM7Yw4LLVq0lU6tDK4HJ9LeQs1cmeDJalIEBCJ883YE7O13E9XUax4cRxTUvBwdefeI8uwoJs3sFCpcI+PwzkxkbgCwa3FIoEKbgrCU5QUszPEBwMQ9Hr0RQh8Xl5vJkPi08jKyWRh+B4yWocQkmaD9lG/jlwL5Yg2nLXbpiCPTkI/byHWgKRKDe5G3UdwskOk1SJWqdA8WgltkhbNHxJXxGUt0Uil3PUthu6ROJaVlUmvXp/i5eWNvb09U8YMo8KZMKzd3MkKqcTnn/chJKQS/fsPfFJX/3PUreuCt7eChw9zirznCAJ4e1tSt67Laz/2ggULqF27NtWqVWPy5MmUL18ejUbD3r17WbRokYm1T0ZGBrGxsajVau7evcuaNWtYtmwZ06ZNM1r9NG3alFGjRjFgwAAGDRqETqdj+nRDIpuGDRu+9v4/L0OHDmXnzp00btyYKVOmUKdOHWxsbDhz5gwzZsxg+fLlhISEAIYg/LGxsWi1WuLi4ti9ezfTpk2jdevWxixegiAwatQoJk6cSIUKFQgJCWHVqlXcuHGDjRs3Go87f/58atWqhbW1NXv37mXUqFFMnz79tYkT1atXZ/To0YwYMYKHDx/SoUMHPD09CQ8PZ/HixdSpU8eYDVOv1xMbG4teryc1NZWTJ08ydepU7OzsmD59OmCIMVe2bFmTY1hZWeHk5GTcHhERwbp162jZsiVOTk5cunSJYcOGUa9evadaEgiCwODBg/nmm2/o378/lpaWTJ06lf3799O0aVNmzpxJ2bJluXv3Ll9//TVqtZoFCxa8lnn6f6RkyWAcHByf6n7p6OhIyZIvH6PwRShXrhzdu3fnp59+KrJcEAQWL16MWCymZcuW7Ny585XjCpox829Q20WBl0JCdI6myDhlAuBlKaG2y+td/AKQy+WMGTOG0aNHI5PJqF27NgkJCVy9epW+ffsChgWU2NhYlEolt27dYsmSJWzZsoXVq1cb702dO3fmzz//pGvXrnz99dc0a9YMFxcXLl++zI8//sigQYNo3749M2bMYMKECaxbtw4/Pz/jooe1tbVJCAEzbx//v2+I7zhWVgo2bpzOxo376dOnLQ4ONmzadACVSkOZMv74+rqTkJDCmTOFzf3r1Anh+PGLj2KRiHBxsSU+PvWJx2ratDoNGlSiT582uLs7v8FRvX7io2NJe5QSseDLWV4spoSHiYDB5cMiKolqU2bh1F6Ob8Jl0pCiyTG8uAoiPQHN09AqxahcDuEgVSJacA9xlgQNMLJjX6MFlUqpIisrnrhwBd41M0h7oESx+QAanQi9TuD6Zgc02SJO/XkdkJEeJcMpKJey3ZKJ+MuZkiWro1Kp+KBcQ7oM6kPHfh896r8eZW4u8kcv2ukpqRzZsZeroRe4fu4y/SYMo1bzN/eSptXB73sM8cU+aAbhl2+ApUHosJTrSM+EbxZCRhY0q2XB3ycaGx0wnS2TSMw2mJtJRKDRwSOdl/D7EOADEY8lvHtZkQwgVyXwfpeLVAgSOHr0/zfYpqWlFa6ubsTHxwEgEwtUclcApg8uBeMS2cvF+NoZrJauinVcxpk2lrmU83DhXpqaO6lKqpa2L/J4giDgYiXhXpqKdBtb7hX3hwIvMA+8fXBJTCTDypoUB4dC+1d0V1DR/bG+FXEckUjEyJFfPecsvD4WbpjBko3fAxD8xU80ybEjNjaafX/tAwF0Apw4vBdLB7jgALYpZ6iapqHNjm3cDihBqJMXNW7dQqFRE3j7FlcDKvHA25tshQJLpRJVAXeCVSuX8aGbO1Iba2r9tQOH1FS4dZO/LSxQOjtz+vRJOnTo/FRLnP8SYrGIuXMr06nTsUILNHk66Jw5lV5rIP88/P39OXfuHN999x0jRowgJiYGFxcXKleuzKJFpjHzJkyYwIQJE5DJZLi7u1OjRg32799vIoAFBwezfft2Jk2aRM2aNRGJRFSsWJHdu3c/1droTWNhYcHevXv58ccfWbJkCSNHjsTS0pJSpUoxePBgE3Eor68SiQQHBwcqVKjATz/9RM+ePU1iiw0dOpTc3FyGDRtGcnIyFSpUYO/evSauh6GhoUycOJHMzEyCg4NZsmQJH3300Wsd24wZM6hcuTILFixg8eLF6HQ6AgIC6NSpkzGYM0B6ejoeHh4IgoCtrS1BQUH07NmTIUOGPNW983FkMhn79u1jzpw5ZGVl4ePjQ8eOHfn666+fuW/Pnj0ZN24c8+fPZ/To0Tg5OXHq1CkmT55M//79iY2NxdHRkffee481a9aY4429AiKRiG7dPmbBgjlPrNO168dvNJD/40yePJkNGzY8sVwQBBYsWIBIJKJVq1bs2LHjXxXYzZh5GcQigVmVXel+LBoB02e1vGf/mZVcX3sg/zzGjx+PRCJhwoQJREdH4+HhwWeffWYsz4urKZfL8fLyok6dOoSGhpq43AuCwLp16/j5559ZsWIF3333HRKJhMDAQD7++GOaN28OwKJFi1CpVHTq1MmkDxMnTuSbb755I+Mz888g6F9XJNsXID09HTs7O9LS0l7owcTMq5Gbq0Sr1WFllf+yNW7cQn788TdycpQA+Pi4cf/+dvbuPc2iRZvo2LERjRpVYc2aXVSpUors7Fx+/HEdNWqUAwyZykaP/ggHh7fze+xSsSkxSWdxq5hN3HlL0qNkSBV6XMuo8ayoQaPP5vxSZ3h0mRcrtFQblIhIDCl3pdz80wG9FpxL5xDYKgOdBm5s8CDlvg6xhR6t0vThyxCVTI9jSSX+zdJJuiHn7j5b+k8awpKJc4vso0who3K/FGS2Knp1XkcJ36bUtSsJgIVczqmcu2SmZ9C7dlsirt7ky/lT6fxFL/rUbcf5Y8agYIglYoZ//w3dBn/yRuZyywGYvdLwf/X9naivzEfsWA591kPmLuvL8ZhGbDtkKPdyhYfxeaH7oWpQBmE3bYpqFrFIj1aXdyPN3+dV0Ov1hG78E7FeTW7u82dCfBfJysri228nEBdXdHywmEw17lYSBEEgW61DQI9CWrTrkUqrQyIIiJ7x4JOao8G+CEs+sUaNVKVCJbPAKiuLZvv+RilXcKBRE7IVBvdcqVSKXC4nIyMD9HpK3riOIqQcoVmZSERSJFIJH3XvQ4MG/3z22CV/fM+Unw2Bmn/6cg3vN+4OwN0bF1i0fALFg6txan8oB+O342Lpi7PCk+j0W4xJdedAcAX+vJlOk5gIuiRGkCWVcahdWxAEbNPSqH/tCttr1jYcSK/HI/ohDY4eIVOuwFKZi0ivRyMW80enzkZlad68n7Gyer1uy2/6/r158wOGDDlrEtjfx8eSOXMq8f77/7yVoBkzZt5+zp4NY9261SaWZY6OjnTt+jGVK1f9F3tmxsy7zdYHGYw6G28S2N/bUsLMSq60+x975xkeRdUF4He2JZveSA8phIRQQpUqTQKhioB0UBQLSlWKggqKiiggoCKgIMhHla6AoSOhhhY6oYaSQnrZlM2278cmmywJEDBIm/d5FrJ3bjlzZ+7MzplTfMr+3S8i8qQgKspEAJgw4We2bj3Ep5++Qbduz8+bq5c8qiN1iic7ToY6U45TYB4hPTPBICN2jyWeL+QSvcgJjUoGGBCkULNfGnbeGrRqAZmFcfmcW+1A8CsZZF6z4fza+5vZ+rTIonIzY/yhqB8q8fqoD7l04Sj/rNuHrVcB2beMAdMVFgpqNapH85fbUjkwgHrNG6HOV9PBpz56vR4PX2+2xB7hyO79vPOS8U2Gh683lTzduXT6PHmq0jFnXDxcUVhaYG1jg4XSko9/mkKNF+o89BymZcLUhZCchslF0qDNJXdlNaR+L1OnlgMLNn7F6Glw2BiXnIGdoX4NWLWlgCA/6NNRwcipcPF6WSMUK8esdNfIlRqDbEqleiRcQaMrXzZMz0qQmAp6Pei1BeTFRvPeGy6883bA/Rs/4yxe/Ct79+4pc9uR+FxyNXoaelqhlEvMrMseKQYDr2xYj1KdT9QLDY1ZH8ugcUhN3hk7njXbl5CQfIs3u43AWvl4TN31ej3rdi7D0kJJ5xbG9ajT6Vi/axkSiZJ2TToxctRb7Lm+kRaeLyMIEnI12Uz5ZjqXho7giwspNFQl4ZuvwluXx9YundDLLfA4fxx9+g2afP0bu5YvofXu3cR5eWGflckRH0fyK9fAOy4Oj7hbKLQ6Et3dOV+9Br179yc8vGOF7uN/cf/W6fRERiaTkJCHh4eS5s0rPRJLMhERkecHvV7PxYsXyMjIwMHBgaCgav+pJZmIyPOKTm9gf3IeiXla3JVGd8tHZUkmIlKRiIoykeeShd/8QMyJM+xY85d5PBzBQKMPkpBZGIjZYEfqJSUGLfi2ysYlJI+r2xywctVQubmK+CgrXELUWDroiN1tDRkBxMXcBsO9f3gZgKCX00m/bInCWo+3fWvqNG3OL5NnENLeEq38Npf+MsZ3utMFSSqTgqAHiRadWoqdoz2z93zH4hVvcHqFDZlxOnQP6JNYpUYwa87sIfFmHO+26UVC7E08AyozccEMVBlZ1GvRGBu7st/6qAug2ygDWSrzG55Bk0Pe351Qhgxk9aoOeFb25OwVmPE7+LjDJ2+DoozkZD8ug1VbodULkJkNJwqTzeivr6fg8mo6D+rH3oTOFBS+mLK11pOdU+j+StlueEXIpGBlCVkldIc2SvjwdWjXtJyT9YySnp7GypVLsbW149ixKLMApbtis7mRpaVrkC2OljIMBgN6gw6JIC2lMNMbDEjuokS7M+12KfR64wlftF2rpdvG9eilMo706Em8rnRmJLlczqRJX+Pp6fUQe/3f8NOKb/h8/vekqepjY6Vkw7fj+ebX93DXB+CSlUvw1YvULNChy8sj5/Zt5CXO4osh/uSqtdS5avQ7FgICuenoyA25nOt+fsaLQ/I1cDUqeztv+hNbldFn+a9OnfFv2pwPPhhXofsj3r9FRERERERERESedcQYZSLPHQe27uanCd8AIEgNoCtSsQhgEEi4aE9BghYbTw0p560AyEuTYelgwKuxigvrHVDFy8m8bsGtA3rqvpNCpZpqTv2WCgYJlo4a8tNLa4GK7KIE4MZeG9QZxjqN3glg0xJjQPWLu3N5YUQeaZcUaPMkWEqduX1VZeqjSAnmEKAhNwnqtWjMr/OHINinEdIvjXYNv+Pz7jN5EP23k1sl1GoVW1du5MalqwBcj7nC0Pe3obfwIFDxG8v2rzDV/3b0d+y5+gJValTlwpU48uWNTNsUcpAZcnDNnEenr16nY79XsHcyxpqqUQV+m3xvWYb3h/f6GJVasXHw1S9grYR3x9anINubOk1f4FYivPYJFGigcaiEXYeN8dHut8danbmSDECVB5PnwbU46NAMfDyK9TTPE46OTrz33ggAsrOzOHLkMGBUbjXzsaa2Wo+DRWHwfEFAKshKnWM6vQYD0lKKMq3egEwioNYZsJDeY3IlEmPdwioaiZS3a4eTlq+jaUouAY7m2RwHDBhEs2bNsbCw/De7/shJz04jv8ANkKDKVXPqWjxdwnqwatNiXt53EwdVPnkYz98/ajWj15mDyA16sh2sOdasLi3/OmDqqyAlmUwba65XLbSiFARwDUDQ6ZBrtWTZ2mGrUpGvUGCwtaVHj+fbrVhERERERERERETkYRAVZSLPHY6VnBEEAYPBgNRCj1MVNfb+apJOWlG5ujeXsrzIP3aC2m+kYO+nJsfKkbPjB3BJVkDgoZUorHVoco1WTLoCCQXZUpTOWvR6Pa6hOQgSoUxFWUkVgecLedh5Z3Ij0ob1v6w0lTs4upFwOI/UC8Y4cjqHsqzTDDhWKUAiyJDJ5SRetMSpAWhyJAQFtuTdz6XMmzTNfGyJAYNeQCKR8PbED5j/+YzCDXp8Op5n9Be2NAsdbaov9W6LtM5nSIGrV+0wGAxotVreC+vNsYNnsGhUlegb3ghyZ1MbpQX8MQMc7ayB0TwsssLwV35esOCLotLKhR/wdjeWX4+HZnXg+DlIzQSpxKgwexj+95fx06YRfDH0oUV/JnilR1/m/fUPtnKIzSigXRU7LKxKn4dmlmF6Pd6XzpEQXLtUPZnEuNYsZRI8424R7+V917FlJUzxk3O0JOUaFcMXUvMJcFQgl8uRSqX4+vrz0ktt/8Ve/neM7P8pNxKzWb0zAY9KbthZpTFxzicAFFCs/Dtu48w2SyesO3bCJi+PC7YZJN88i239+tjv2Y1Er2df/fpkODqZ2gh6PQaJBINUSt2ow7gnxANgWVDA6DovULmy73+7syIiIiIiIiIiIiLPAKJzvshzR0i9UL743Rg4X5srJfmMNWknXfGt7sP03yLYuXkNfi8aUNgY8G6iIrVfU+K8anLNrR4Hur6LTiojsEM2ShcNShcNBSoJF9baAwaSTlmTc1uG0lmLwkZAaW1lGtdQ+LF01+HZIBcbdy1+rbPNZEtNTOb6XiuK7KNUGVmld0BiQKaAtKtSdqzZhD0voNrfllZV51CtZkPSk1NKNTEUKpD0ej0Jty4hkUqQW+uo29WN26lnAYi9vYuA6sYkAYaCYrn06kxWz1vCuaMnObb3IGiy0Zz9GQBHqyVYyaOo672B7b/Cf5XTIcAbWjcEhQJ++gRG9De6UP5bdh6G3/+Ef478+76eVmxtbKhsryDI2ZKGXvcJBG8wgF5PyPlzyJTmWSoPxeWy8lwGZ5PzEQQBm+wsBJ0Oh7TUsvu5Uw6FBDuF8RZVyUpKzZqhhIWF06/fa4waNYbc3NLx955E7Kzt+XXiPDL+2cj5Nb9ga1WcCGFfgBM6QcAAOGvUOFoI5NnakuzqirWFMzdUMZxTnSPJxYXrlX3J9PRCqyhWrhkkEmzV+XhkZyPVajnUtBlnq1cHIOtY1J2iiIiIiIiIiIiIiIiUA9GiTOS5pMvAnty+Gc+cT6ZiMBjQaPOp2VnJuq3v0q/7AtwbpSFV6FHY6HFMuME1QDDosfctILlNGxZ9+jq/vLSEE7P/4WqEJTo1gNH6RZWgwLVODknRMgzSPDLGtEY4kkyTOqFEx99C+ucecgRbrA3ZZMUpypDOPNqWwtKCoV9+xKJZU8iI04JewqXNRlttmrgAAJyGSURBVI2UIBE4vGMvSmsr5v39GgBHdxtdtWw8CpBaGFA6a0k6aYVeC1ILPft2bkCvk6DPkVKguEbVSi+w+ZtYDqbd5t1JA7h9M54GrZvxy/xPuBWvQXtlFTfafMgJVRA2rgGokq4i9QmnkqOOfm2vYG2ZTPuXJjy6g3UffNyNH4AGNWDAx6DRGsu0WkgorTe8J7+uMf5vrYR5E8HB1hiLzd2lYuV+UrGxUuJmLUOv1+NgaZ7dUqs3kJKrxVkpQy4VTDHFYoKroZcV305yNXoupKqxkgtkqQvXha0dKls7rLMyUeTlUaAszr5bViJTG4WEV4Lt0OqN2TRTU1M5c+YUAP/73yJ0Oh3Dhn1AnTr1Sjd+gukRNpC12/7HvpM7UWSlIi1UEvqpVUw+vJWzmrqkOzgSHB+Hh6wqfmm5+N+IAyDd0ZFY/+LkEx7uHnw9ZTqzZ8/gmEyGWqnkRmVfnFJSCRr58FadIiIiIiIiIiIiIs8zoqJM5LnlrQkj2bbqTy6dOkuNPmlcv5UMwO9/DKBKQDOu3fwHTa6A99kjVN13DYleS4xXMwLCmjDtzTlkWm3Ho4qeCyeMljRF7pwASSeNSgBBZ8B9wXbUk5txfsRyLAA9Eg5tDcIl4RqqeDl6uQSJpshnsGQkMyMF+WoSb8Qhs84D5JTMAmnQG8fLy83l4LY9vNStIy1fbseVszHkJCmw81GTesGSdyeO40zmV2gl6aiuupMeCxb2Wmw81cSeu0FOshTQs2buEl597zXa9XoZmVzG+L7vYWWtJN97IJFRdhjCdhEWvJHePV6hmr8UG6vvHuUhemC8XOHXz+HYOWNCgD1H4MflYGMFefnG7QkpRkXa/cjJg9fGYzoUn737/AT9FwQJUNqPVSYRuJquxt3G3LW4pJIMwFImUMlKSsvK1tgozJVtOqmMAguLO0csQwYBAZBLDCikUhIS4kzbNBoNABERm546RZlEIuF2ciIAe501tMmrhIPcEnV8HHYaNU0OHyLLxga5RoO7kzNydT5gXPU5Fgqj9V2h22tCYgKXLsUgl8uRazSolUokOh1xXl6kSySIjpciIiIiIiIiIiIiD46oKBN5rlm4dz17I9YTcfJNkw3XtdgocnLVnFvpBAZQ2OrwzrpJss6d7B23uXHmewpStDT9KA+dRsCqkobcZLl5cHODBCQG0AuoM2RY/nCM/BLjWh6LQ1UYn0gu06DTSClpRSa30pvioAGs+GkB1q4gyPQYtGV4TBtg3a/LeKlbR7wCjI/HBh1kxlqAICCVyRj34S5OX/iLOjW6o5mh4+jpJZy/HMHNm+ewdnUiJ1lOcsJt5k6chpd/ZXZviECn1ZGbrYLsq4ATgtSC2+mLSUu5ik2NjyvmIFQwgZWNH4De7aFNY7C1MiYaEATIyIYJs+DUpfv3ZTD9A/ujoU41+PoX8POED157NPI/CSiVlqhUqlLlWr2B/BJJVXV6Q5kpviWCQIcqtmUZipFvbe7OaW9nT2ZWZhk1jZSMhWZhYYEgSMjPzwPA2bnSffbkyaRfu3eZsWwiUit7PGetwkUGowY15vUrYK2Fy1UCue7nT75SiaDV4nk7EcfUVNrs3Uu6tQUnGzQh0cMTAIlESkBAFdL/WE7omdPYZWUib96S0NA6j3cnRURERERERERERJ5SxBhlIs81tvZ23CpYhwE9ej3kZ0ko0GUht1Dj0zQHVYIC9yArEo8rufGLFus9lyhI0QECR350IfOmHL+XjPG8nNydSvRswMqloPhbSj53QyLTU6lmLg4Baoosa6QyGY3btjT1hUEg57bcTEmmsNFTr2UDrO1sAKjRphL/+98HLF01hOq90rCqpClsa+CnCd+QeDmPDi99RlaCgUVf/o4ssxZaXQEyCwMN3lHh3aRYMWLn5Ejbnl2QyWRU8nTnrQEevP3Kn1R1bYid8m/y1eax1Z5kXBzAQlGczdLBFr79EOpXN69X2aM4kUBZnL8C3UcZrdXW7oCPZ8KFq3D4FKRmPCLhHxMTJ36Fn1+AWZneYCAzX4efgxxNYdaEspRkRUgEoVjJdY8srAWa4nViqneX+mq12qQkCwgIpE+fAffblSeSt/sPZ9MPh1kzezcJ8fF8v3QBnRIV2Ggh29aOmGoh5Be6phpkMuK8vIn1D0AAnHLUvBi5l9rRJ2ixdw+H1q9hy8L5yNVqcqysiKvsy8u/r0QiEW/vIiIiIiIiIiIiIg+DaFEm8tzj6VaL0+f/JPWsHTf2K6j7VgoSGWTHyVE6axGSGnDt2AkMOmPsMBsPDV4Nc8mIVXBhdXEA87TEVIrii9l4aPBqokKVoCE7TgYYLcuMFLtOggGNSkbyGTklkwjKJFYc2v6P8YtgKGFsVlzJIUBN34ntWbl6K5k3ZWxYsgivxio8XzAqMZTO6Ryb62psJdHz519f8OehCyReTSV6hZLjl/LwaWZUjjk5BaBpfh6lk57+vX+kecc2ALzYsQ0KSwvkcjkDvTyIvTqa5DTYd3ge7Vp+jKWFbQUdhf8WW2sI8jUqvQCkUpgyAj6cBklpZbeJTzb/vu+E8QNGJVzNQBgzCKr4PDKx/zNcXCoxceKXzJ49nZMnjTspEQScrWQ4Wz3EbaPQLdksU2YhBr3B5LYs0xSAIEErL3Tt1OuhDIWPVCrlzTffwdb26Tz/ADw8vPjhh+lcunQRAImtG2TeRK0oodUtwmDA79pV01c54Hc9lqsBVbh1LIo2u3ZglZdHnqUlR98bjtTS8j/cExERERERERGRpxs/Pz9GjRrFqFGjHrco/zmxsbH4+/tz4sQJ6tSp87jFeWIQXzmLPPd0bvslIwbvIrznVDIVLhyf70JushTvZirqvJWCtbPOlDUSoGrnTFyq5xPYMQsLB6N1mZHi/1UJCpSOBvxaqajaKYuc2yVjMgnmf99hRONaOwelSwkLNIMEqcKAnY8GqYUeBAPu1S2YOH82W7Z/haWjBrfQPDT5AglHrNEXusZp8oqXd6Va+aTJt5KWcR2FkwrnavkUpNkgCBIEQUKnNp/Tt9s8hn7wC9oCPbGxxwCwtrVBXqi0kEgk6PTG2FB5+emo1aVd854mqpYI4KTTGTNe3qmfqBdSvr4MBjh9CYZ/A3nqipPxcdOnzwBsbGwqpK8iJVmOpth302AwkKtKwEpnLNMqLNCWiHf2YuReqly6iERrHlTO3z8AT0+vCpHrcbF//16Tkgwgy9u4P1YZKeiuH8M5xZiFQqLVgiCQ6OmJRqFAYmkJej1WeXnc8vImXS5HVhh0T6bV0lQmvv96GBITExk+fDgBAQFYWFjg4+NDly5d2Llzp6mOn5+fMXaeIKBUKvHz86NXr17s2rWrVH9HjhyhTZs2ODg44OjoSHh4OCdPnqwQWQcNGmSSo6yPn59fqTatWrW6Z5tWrVqZ9nHWrFlmbU+cOEHv3r3x8PDAwsICX19fOnfuzF9//WUKORAbG4sgCERHR/P555/fc6yyFOYPS0UftyJSU1Px9vZGEAQyMjJM5Xv27ClzfxITE011Sh4fuVyOv78/48aNIz+/tGX5rVu3UCgU1KxZs2ImROSJoeg8mDp1qln5hg0bzNZA0TlV8jyLj4+nVq1atGjRgszMu4cmOHHiBD179sTNzQ1LS0uqVq3K22+/zcWLxntL0bos+tja2lKjRg2GDh3KpUvm8ScSEhLo168fQUFBSCSSMpUFixcvLnXuW97xYkalUjFs2DC8vb1RKpVUr16defPmlXfayi2LiMij4m7X+ZKfPXv23LX97t276dixI87OzlhZWVG9enVGjx5NXFxcqf4lEgn29vbUrVuXcePGkZCQYNbX2bNn6dGjh+k+duf9GSjznlutWjWzOomJiQwcOBB3d3esra2pV68ea9eu/ddz9awjKspEnnsEQeCWczDDvCzIaFMbdZaM6EUupMZYoC+AqIhTYChWgqmzpeSlSUm9qECTf/clpLAxPvxbOuiRK++IHi8YkLqU/HFR7Gpmaa8juIsaB/98Y7lgIPS1NGoNSKPDJ864e3uTHKMl/ZIVqltWAKizJKiTbEg8Yc2JBc4kW3mzvttkVF1rYlcPPF/ILZZLbk3PgWOZtXQHn446xycjz1A/tBeBnp2Z2O8jtp99h+m/NODPraUzWb7W83/Urfkq/Xsswt7O44Hm+UmjaR2QF7paCgLY2cDt1OLtfl5Gy7MageXvM0sF73wBn/0IG3aCVnf/Nk8ybm7uTJs2m5df7v7wnRgMyPPySFRpyNXoiU7MN4vnZ3fxNDWjDmOXmUlQTAyWeXkYDAbkajX7WrQk1s/fLFmAIAj06TPw3+zWE4Gfnz9SqfEEDAsLp5WLGwDWOqhpo0R7fhs1dv9Fm107kKvzSXFyZs0r3ckqtLAzAAaJgMxgwCCAysqa88HVqNO0+ePapQpDj4ELJHOYm1wgGT13d92tCGJjY6lfvz67du1i2rRpnD59moiICFq3bs3QoUPN6k6ePJmEhARiYmJYsmQJDg4OhIWF8fXXX5vqqFQq2rdvT+XKlTl8+DD79u3D1taW8PBwUyKKO1m8eLFJWXU/Zs+eTUJCgukDsGjRItP3I0eOlGqzbt060/aoqCgAduzYYSpbt25dmWNt3LiRxo0bo1Kp+P333zl//jwRERF069aNTz/9tMyH+DFjxpjJ5+3tbZq3kjLfSatWrVi8eHG55gAq/riVZPDgwYSGht517JiYGLP9cXV1Ndvevn17EhISuHr1KjNnzmT+/PlMmjSpVD+LFy+mV69eZGVlcfjw4fvub0UqGZ83DDodaXv3kPDHCtL27sGge/Q3aEtLS7799lvS09PL3ebKlSu8+OKL+Pr6snXrVuzt7cust2nTJho3boxarWbZsmWcP3+epUuXYm9vz2effWZWt2itnzx5kilTpnD+/Hlq165tplBWq9VUqlSJTz/9lNq1a99VPjs7O7Nz//r162bbP/zwQyIiIli6dCnnz59n1KhRDBs2jD///LPcc1BeWUoyaNAgPv/883KPIfLfodPp2HP0FCsi9rDn6Cl0/8Ha+zc0bdrU7Bzv1auX6Zpe9GnatOzsXvPnzycsLAx3d3fWrl3LuXPnmDdvHpmZmcyYMcOsbkxMDPHx8Rw5coSPPvqIHTt2ULNmTU6fPm2qk5ubS0BAAFOnTsXd3f2uMteoUcNMvn379pltf+2114iJieHPP//k9OnTdO/enV69enHixImHnqc9e/aU+WLuWUJ89Szy3LM86Sr9YyJBIUXdryXKC7ewO36F3BQZVyLsSyjJjJzc54c8LhMMAmp3BywSM8rs9/pOF1zaaYn1rMuNto64rt5f6EYpYOtdgHv9TC5tcAAELJ015KcaLbfy02UcXWTAYDC6bEoVeqwqGRVtaTnnSb7tik4nYcvStZz8R4vM1hltrgX5CjkSdOTnWrLDohfZjp5kjx6AZvIK2HqEWt0F2rZ/m3atPkZpWfqHV/LtODyapiCzMD6U7jnwAy+HTzGrE+jfnED/p/9BHCAzG4qMmwwGmLOieFtlD1DI4J+jD97vtVvGz+4j8MNyaNsEPnqzTA/CpwILC0uCgoIfqM3NzALiVVp87OR42srRKJVosgrYGZtNZTtFYVZNo8tlflATjggCVrm5XAwOhkIXTU1hZkxdCSWZ0eXyXQICqlTkLj4WgoKq8fXX0ykoUOPt7UNsYiIpmzaCTEZrRWWm1rYh064y53U6gi+c53wNo8XJ3hdbEH7rFrk3YnFPSMD71i0sNBosNBraVq+Fe3iHx7xn/45jxLGSk6STZypzREkfalOfR2NF+P777yMIAlFRUViXSDZRo0YN3nzzTbO6tra2ph+rlStXpkWLFnh4eDBx4kReffVVgoODuXDhAmlpaUyePBkfH6Mv9qRJkwgNDeX69esEBj6A9r0M7O3tSz08Ozg43PNHtJNTcQzNIssmZ2fne7bJyclh8ODBdOrUqZQiLSQkhMGDB5snsSnExsbGzBJVKpWazVtFUdHHrYi5c+eSkZHBxIkT+fvvv8sc29XVFQcHh7vKZmFhYRrPx8eHsLAwtm/fzrfffmuqYzAYWLRoET///DPe3t4sXLiQRo0aPfA8iNyf2xvWETN2JOq4W6YyCy9vgqfNxu2Vf/Ei6D6EhYVx+fJlvvnmG7777v5Zwk+dOkV4eDgvvfQSv//+O7K7WAjn5ubyxhtv0LFjR9avX28q9/f3p1GjRmbWaWC+1gMCAujSpQtt2rRh8ODBXLlyBalUip+fH7Nnzwbgt99+u6uMgiDccy0fOHCA119/3aT4f+edd5g/fz5RUVG8/PLLAGRkZDBmzBg2btyIWq2mQYMGzJw506QUK68sIk8+63btZ9T0+dxKSjGVebu6MGvMu3R/qdkjGTM7O5shQ4awYcMG7OzsGDduHBs3bqROnTomi6ykpCQGDx7Mjh07cHd356uvvjK1VygUZue4UqlErVbf9x5269YtRowYwYgRI5g5c6ap3M/PjxYtWpRal0X3EXd3d4KCgujatSt169blvffeMym6XnjhBV544QUAPv747knUZDLZfdfl3LlzadiwIQCffvopM2fO5NixY9StW9dU78KFC7z//vscP36cwMBA5syZQ8uWLe/W7TPPU/roJiJScZzOKX7T5z1rI3bHryBT6sm4rkCvMV8it4e34+bQV0zKM8XtDDIbVC2z38Tzcpa9PIMDtfuSW80bgxTcQvNwrZVLfpoUO88CBKnxIcPBT41vqyxsPQtIPqckP0OGOlMGGNBpBMg0PiAKEvBsmIOFpSVdB/fG0tqC3BQ56nwDkoxCtw6dDuvdMaDXI8vXYHX2Blk3FSTFCESkxjJ5eV9OndsIQG5eBkkpRvP7i7dX4FKtpN+g+QNQanosk6b5M3ayI5evRT7MVD9ReLkZM2EWUdL6KyEZLpZ4Sap4yFcKBRrYvBf+jgSd/v71n1SqV6/JRx99SvPmrVAoFPetfzA+l/OpajMvYx87BV2q2lPbTWnm4qqVy9HLZKjs7IwFd1pMlPj++edTaNLk0fywehy4urri7W1UpPh9OA7HFq1BqyV985+8s2UfDaMOo5dIuObvb2qT6+CA4pOJxARWxffGdeyKMoYKAr4jRz+O3agwjhHHXA6ZKckA0sljLoc4RlyFj5mWlkZERARDhw41U7YUcS9lSBEjR47EYDCwcaPxuhocHIyzszMLFy6koKCAvLw8Fi5cSEhIyFP19nXbtm2kpqYybty4u9Z5XBZOj+K4AZw7d47JkyezZMmSeybEqFOnDh4eHrRt25b9+/ffc5wzZ85w4MCBUtfO3bt3k5ubS1hYGAMGDGDlypXk5OTcV26RB+P2hnWc6v+qmZIMQB0fx6n+r3J7Q9nWlBWBVCplypQp/Pjjj9y6deuedQ8cOEDLli3p0aMHS5cuvauSDGDr1q2kpKTcdW3e7/yXSCSMHDmS69evc+zYsfvuR0lUKhW+vr74+PjQtWtXzp49a7a9adOm/Pnnn8TFxWEwGNi9ezcXL16kXbt2pjo9e/YkKSmJv//+m2PHjlGvXj3atGlDWtpdgsSKPJWs27WfnuO+NlOSAcQlpdBz3Nes23Xva+fD8uGHH7J//37+/PNPtm/fTmRkJMePHzerM2jQIG7evMnu3btZs2YNP//8M0lJSf9q3NWrV1NQUPDQ61KpVDJkyBD279//wLJcunQJT09PAgIC6N+/Pzdu3DDb3rRpU1atWkVaWhp6vZ6VK1eSn59fypJ97NixjB49mhMnTtCkSRO6dOlCamoqzyuiokzkuecDr+q84uTDC8kFOO08ia1XAQ2GJhE6MB37YHM3GXlMErlVvdDaGV0eMYDtyaslahQrlwSdHo+5f1P5m9X4fbkKicGAz4sqqnbOwrNhLumXLQsTBIAqTo5UYSA7XmEqQzAgt9Vi511AVnbxBdM6zI7+P9fidPIMXJvdQBluj19frTHLpQDWzgU4/32MFsPmcCygGv1er06t11JxrZuC5OxKsi//zYLlPTl0fAmTvw9i8vdBrFg/hINHF5rtq1sl8wBd0WfWkpoeS15+BlHR//uXs/5k0LNt2eWaEp6yEgkUaMuuV16+WQg9PzTv92kjODiEN954m5kz5+Dk5HzPuoEOCl4JssPTRl7m9rKsUMqDhYXF/Ss9xSjc3Ex/C0CVq1cQDAbyrayRq41KbI1EwpTl35Ds5k6iqxvXff2Ic7DB0tsHfe7T+5Ctx8BK7h3DayUnK9wN8/LlyxgMhlLxPB4EJycnXF1diY2NBYzWS3v27GHp0qUolUpsbGyIiIjg77//vufD75NGUZyjktZWR44cMVmM2djYsGnTpsci26M4bmq1mr59+zJt2jQqV65cZhsPDw/mzZvH2rVrWbt2LT4+PrRq1arUQ9imTZuwsbHB0tKSWrVqkZSUxNixY83qLFy4kD59+iCVSqlZsyYBAQGsXr36ofdHpDQGnY6YsSPLzqRcWBYzbtQjdcPs1q0bderUKdP19s56Xbp04aeffrqvAroovti/Of+L2had/+UhODiY3377jY0bN7J06VL0ej1NmzY1UwL++OOPVK9eHW9vbxQKBe3bt2fOnDm0aNECgH379hEVFcXq1atp0KABVatWZfr06Tg4OLBmzZqH3h+RJwudTseo6fPLvGMXlX0wY36Fu2FmZ2fz+++/M336dNq0aUPNmjVZtGiR2TgXL17k77//5tdff6Vx48bUr1+fhQsXkpeXd4+e78+lS5ews7PDw+PhQ9M8zLps1KgRixcvJiIigrlz53Lt2jWaN29Odna2qc4ff/yBRqPB2dkZCwsL3n33XdavX1/Kwn3YsGH06NGDkJAQ5s6di729PQsXLrxzyOeGp+cXm4jII8JVoWR9jZegxkus/EHKytVjkBY+3xveqUH2Ui22J4zKMKdt0dimJeHyujUZP+YgICAU+u8VuNqTW80b26iLSPONCja3VZHoC82RDHoBTa4ECzs9+gKB26eUJhlUiQryM+UgMYC+8AeSQUAqh2rdMpBbGTDoYXfN1zjv+xLRt/bhP2cPCccckVqkU+mtVOzfsMYiLx2phR5VgpwmgY2Z+U0rzq1yploP422p6KeXXqdh6ZrXTePvPzIfhUTBwMr9QZDyV9IW2rUabzZPV28cMP3t5/NsuIe83RM83eBGIqwq28MGfQVZgiWlwbTFMOGtiunvcaFUWjFt2mwyMzPZu3cXTk7OqNVqUlJSiIu7yfXr16h7lwyX/5ZDh/bTufMrFd7v42bMV+8Qc+4iIX6+9AnvSOrWLQAUyGTIDAY0QJ2T0ZyvFsKL+/dhm5mBFON6vhRQBbfsPPIzbnCiR2daJ2QgPIV+vhdJKWVJdifp5HGRFKpRqcLGfVilbVn9FJ3zeXl5DB48mGbNmrFixQp0Oh3Tp0+nU6dOHDlyBKVSyY0bN6hevbqpvVarRaPRmLksTpgwgQkTSseKfJyEhoYSHR0NQNWqVdFqH177P2XKFKZMKXbvz8vL49ChQwwbNsxUdu7cuTKVVo/iuI0fP56QkBAGDBhw1/rBwcFmisOmTZty5coVZs6cyf/+V/wCqXXr1sydO5ecnBxmzpyJTCajR48epu0ZGRmsW7fOLI7MgAEDWLhwIYMGDTKV1ahRwxQDqmifS54jzZs3v6t7qAik748sZUlmhsGA+tZN0vdH4tSi1SOT49tvv+Wll15izJgxd63TtWtX1q9fT2RkJM2b3zvERUWc/0V9PMi9ukmTJjRp0sT0vWnTpoSEhDB//ny+/PJLwKgoO3ToEH/++Se+vr7s3buXoUOH4unpSVhYGCdPnkSlUuHsbP7CLS8vjytXrpRblmXLlvHuu++avqvVagRBYPr06aayv//++75zKfJoiDxxtpQlWUkMwM3bKUSeOEurBnePB/mgXL16FY1GY3IxBGO4gpLX7fPnzyOTyahfv76prFq1auWyRL4Xd8vu/qB9wIOtyw4dikNuhIaG0qhRI3x9ffnjjz8YPHgwAJ999hkZGRns2LEDFxcXNmzYQK9evYiMjKRWrVqm9iXXt0wmo0GDBpw/f95UVvL+o9PpUKvVZmUDBgx44OQdTzKiokxEpAR9hr1J614tmD77JRLlGk6FtMfiKxcG/HWajfP+AATcVVcIts7kgMTVpNRSOCs58+twtI422B6OocpHvxVuMyApMkcSDCBA3GErbh20waAXwBLINwAC2jwBnxZZpF+yJCPLloQRHamiOI8mIRK5lQ5NgZQYH+MbOYecBHKSjNo8nVpCXroMB7tssIG8dCk5V+04570RpY0cg8FAfJQ1VTtnorWw4KpjKMEpR7jzEuyicKGRcyPOZ52nhusL2Nt6ml301QXFWS7dXB4sZtWTikwKXVsb/x7YCVb+DUs3P7rxtuyF118GGyXY2z66cR41giDg4OBQZpD/iIjN/PHH8lL17/XDXiqVodPd/4HbxcX1vnWeNjRaDYmXUqlk6UVSQgH+83/Desa33FowH0VeLh3/3Eicry8Wqky6bCm23sm2tsZCrUYrlaKRy5HpdMhs7Uq7rj4lZFI6I+C/qVdeqlatiiAIXLhw4aH7SE1NJTk5Gf9CF9nly5cTGxvLwYMHTe57y5cvx9HRkY0bN9KnTx88PT1NCicwBttfu3Yty5YtM5WVjCv2OKha1RhWICYmhsaNGwNGq85/G2OtiCFDhtCrVy/T9/79+9OjRw+6dy++rnh6et5Vtoo+brt27eL06dMmq5aia5aLiwuffPIJX3zxRZn9NGzYsFTgZGtra9M8/fbbb9SuXZuFCxeaHlqWL19Ofn6+WUwyg8GAXq/n4sWLBAUFAbBlyxZTAoi4uDhatWpldt4olcUv3ERKo04sO3HEw9Z7WFq0aEF4eDjjx483U4SWZP78+YwbN44OHTqwZcsWkwVWWRSdHxcuXDB7sH0Qih5+/Uu49j8ocrmcunXrcvnyZcCo7JowYQLr16+nU6dOQLFyffr06YSFhaFSqfDw8Cgza+CDKCpefvlls/Xz0Ucf4eXlxYgRI0xlXl5Pd3bsp5mElPK50Za33tNAUFAQmZmZJCQkPLRVWdG6/DdhGhwcHAgKCjKtyytXrvDTTz9x5swZatSoAUDt2rWJjIxkzpw5D6TYKnn/OXz4MB999JHZWrYrCqPyjCAqykRE7sDNNZBpX98gR6fhn8zb1LdxZn3BGEJSM8hNkuFaN4+T2Q1Ab3xLKUj1uITno3U0atQLKrtQ/91kMq9bIBOsCXYfyJFTvyO1VJOTJOX2SSujkgwgH+RKAU0eyK306DRg6QQpU3rQ+vZ63DKvkSJ1IP5vPZmxClzVe5E7ClS9vQNa6YndZYvcXo+Vrx6NRIFcX8A/QQNI6hBC4+vrCUo4jKO/hpRLluTczmV79w9xUsVTNfU4abbe2KQloJQVYABu599m1IkP0WJUWOybHYHMWo6DnTcNavenbs1e2FpXwtMtFFeX4Ap5c/Ik4WAHQ3rDln2Qdvds7HhWgppVYduBu9dRyKBLK1i3485Ib9BnLFhawM+fgKM9uDhUgPBPEO3adcDKypq4uFvs3/8Pubm5dO3anQ0b1lF6NoyUVJIpFAoKCgpM362srOnbdyD29vbUrFlxbx2fFOQyORZKCwwFIJEIHIk+Trtvv0dRJZCbM77leGhtYmxtsc5Io9LWCBQICAYD1jk5SACVnR072oRR/+hRum+MeGrXpD2W96/0APXKi5OTE+Hh4cyZM4cRI0aUineVkZFx34e32bNnI5FIeOWVVwBjoG2JRGJ2LIq+6wtNVGUymZnCydXVFaVSWWFKqIqgXbt2ODk58e2335oFDK8onJyczJSBSqUSV1fXcs3Bozhua9euNXO9OXLkCG+++SaRkZFUqXL3BCLR0dH3fCiSSCRMmDCBDz/8kH79+qFUKlm4cCGjR48upTR5//33+e2335g6dSoAvr6+pm1FbrtP0jnypGPhXr6H1fLW+zdMnTqVOnXqmFm2lEQQBH755RckEgkdO3Zk8+bNdw2i3a5dO1xcXPjuu+/KXJv3O//1ej0//PAD/v7+ZoG8HxSdTsfp06fp2LEjABqNBo1GUyq+n1QqNV376tWrR2JiIjKZ7F8pA2xtbbG1tTX77uTkJK6PJwQPl/K96ClvvfISEBCAXC7nyJEjJmvkzMxMLl68aFI+V6tWDa1Wy7Fjx0yB8mNiYkoF239QXn31VT7++GO+++47s2D+RdxvXebl5fHLL7/QokULKlV6eMt5lUrFlStXGDjQmCE+NzcX4J7rsohDhw6Z5qlojkpaeZdcX7du3Sr1W+ZZQ1SUiYjcBWupnI5O3gCkeDbCMfBnnALVxDsEcqlyW3wW/YYuV8CtTh7+vtk0P7eUS/IGjPWuxVUHPZYOeaRe1HFo6z+MmbWEszYJ7N15mtxNf5hZc2nywLV2LlU7ZmEwgEGXi0KfjlvmNQDkOXncjnYEwH3BNiQGPbcqKwnsmEXlFirSLiuQCKCydOCEaxhXQowmUocUr+J9Mprgl/PxMqi56t0ES1UmMV5NSbQPINXeF6esm/TePxEJBnSYxwkQLA1oCwpITb/K1j1Gk/omDQZz7eZBNm79iDo1evBW/2cvnoS18t6KsuR0iIkte5tEAL3BGNPszz3wYj2ILBG6xrMSxCdDXj58+iPEJcHLrWHcGxW5B48XiURCi0IXlp49+5Cfn4+NjQ35+fns2rUDiUQwZd0rixo1QnFycuTEiWMEBAQyaNBbWFmVDtb9LPFFp17MXbWMBIWClSuXkpWZwd+HD+DctRt5mZmgKSDHwYk8G1u2tWyFX2wsoWdOc7pGTVJcKqGytUNXpy62hZkxn0aCcMER5T3dLx1REoRLhY89Z84cmjVrRsOGDZk8eTKhoaFotVq2b9/O3LlzzdwOsrOzSUxMRKPRcO3aNZYuXcqCBQv45ptvTD8W27Zty9ixYxk6dCjDhw9Hr9czdepUZDIZrVu3rnD5HxU2NjYsWLCA3r1706lTJ0aMGEHVqlVRqVREREQAxh/aj4uKPm53KsNSUoxuQyEhIaaHm1mzZuHv70+NGjXIz89nwYIF7Nq1i23btt1T1p49ezJ27FjmzJlDWFgYx48fZ9myZaViTPXt25fJkyfz1VdfPVXx7J5UHJs1x8LLG3V8XNlxygQBCy9vHJs9eve8WrVq0b9/f3744Ye71hEEgXnz5iGVSk3KsjuDbYPRYnHBggX07NmTl19+mREjRhAYGEhKSgp//PEHN27cYOXKlab6qampJCYmkpuby5kzZ5g1axZRUVFs3rzZbA0XWYuoVCqSk5OJjo5GoVCY3MQnT55M48aNCQwMJCMjg2nTpnH9+nXeessYU8LOzo6WLVsyduxYlEolvr6+/PPPPyxZsoTvv/8eMGYCbdKkCa+88grfffcdQUFBxMfHs3nzZrp160aDBg3KJYvIk03zujXwdnUhLimlzFekAuDt5kLzujUqdFxbW1tef/11xo4da4pDOWnSJLOXV8HBwbRv3553332XuXPnIpPJGDVq1L+20PXx8WHmzJkMGzaMrKwsXnvtNfz8/Lh16xZLlizBxsaGGTNmmOonJSWRn59PdnY2x44d47vvviMlJcUsy3RBQQHnzp0z/R0XF0d0dDQ2Njame9eYMWPo0qULvr6+xMfHM2nSJKRSKX379gWMisHAwEDeffddpk+fjrOzMxs2bGD79u2l4ozOmTOHqlWrEhISwsyZM0lPTy+VRfp5QrwLi4iUg0G1e/BqrgpZ2iXedA8i9MAMgn/vTS3/AWyIfIPEpLOEXt/ByGa16NGuHx+um8Xlc+e4GWkDxDP21bdIC6/LjU964xN9EZddx1HY6lBnGN0npYoin3QQZBASt4k0aw9k6kxO2zRGwHiRtJRbkp+TT/oVC4786AoY8OorIDOocMhNwkN9lXNaHcik2ERfITS4N05+EHViCUHOAaizYgk9upvN9UcBkGbng1puTaq1B5e8mnKjUig1b+yk/lVjjCThjmegYydXUqAxBgyPPruW85e2E1L1LhHxn1K+/cBoLdawllHpNWcF5OZDfJIxGL+LA2RkmbeRSiDIF26nQlrhNr0ePn/f2Ee+GpLTYPcR+N9fIJcZlWQAf+6GtAwY+DLUuLvRwlOJTCYzxS7o1asfvXr1Izs7m9jYq1Sq5MaqVcs4efJ44Y/fmshkMl59tQ+urm707z/o8Qr/H1GQmsqFgb1xCgrCVmHBdZ/KnDl0AIPBQEpKMp43b2JwdsIzLg47lYqQCxe4WCUQDAbO1jJa2MmkUjr9vOAx78m/Q4JAH2ozl0N3rdOH2khKOY3/ewICAjh+/Dhff/01o0ePJiEhgUqVKlG/fn3mzp1rVnfixIlMnDjRlD6+cePG7Ny500wBVq1aNf766y+++OILmjRpgkQioW7dukRERPyrIL+Pg27dunHgwAG+/fZbXnvtNdLS0rC3t6dBgwasXLmSzp07PzbZKvq4lYeCggJGjx5NXFwcVlZWhIaGsmPHjvv2I5PJGDZsGN999x0xMTFUr169zEDs3bp1Y9iwYWzZsoWXX375gWQTKY0glRI8bTan+r9q/IFVUllW9ND83SyE/0jhO3nyZFatWnXPOoIgMGfOHCQSCZ06dWLTpk1lnl9du3blwIEDfPPNN/Tr14+srCx8fHx46aWX+Oqrr8zqhoWFAWBlZYWvry+tW7fml19+KWUJUtK67NixYyxfvhxfX19TYPH09HTefvttEhMTcXR0pH79+hw4cMBMebVy5UrGjx9P//79SUtLw9fXl6+//pohQ4aY9m/Lli188sknvPHGGyQnJ+Pu7k6LFi1wK5HQ5n6yiDzZSKVSZo15l57jvsYYiKaYorv4zNHvPpKXLd9//z1Dhgyhc+fO2NnZMW7cOG7evImlZbFF+qJFi3jrrbdo2bIlbm5ufPXVV3z22Wf/euz333+foKAgpk+fTrdu3cjLy8PPz4/OnTvz4YcfmtUNDg5GEARsbGwICAigXbt2fPjhh7i7u5vqxMfHm62F6dOnM336dFq2bGlyebx16xZ9+/YlNTWVSpUq8eKLL3Lo0CGTVZpcLmfLli18/PHHdOnSBZVKRWBgIL///rvJGrSIqVOnMnXqVKKjowkMDOTPP//ExaXiX1A+LQiGioqI+gBkZWVhb29PZmbmM+fLKvL8YTAYiDw8F4lExosN3wEgNuYyb7fqQUpicbZKVU1frk19nRrdvsbaTo1raC63T1iRnyHDKTiHat2yTb/jBMF4U1nVbDJpCnf8Jy/H49JpJBIJ2QlSwIBvWDZOXV/lgk0udS6tQ2LQk1T7TfxeGELI7aO45aUS9uKHKBRWZKuSkVo68PqZrWiOz+eKS23OOBrjz0j1OjqpYvnTrkrRDtFn03icZYnm+wl4udUiqEpr9hwofiPar9sCmr4w+FFO8RNBagYcPQv1q8PIqXC9HCFNPnjNGPcsJxde6wI//3H35AAKGUx6D5wdoHoVY7bN54FnzYX3QdFkZLC3iie6vDwEQK1QkPPF1+y5cB7XlCQcL1/G7+pllBotF3y9uO0fhF1mJheDix+yW7RoxaBBb/8n8j7q+/cx4ljJSTPLMkeU9KE29RHjzYiIiDw4tzesI2bsSLPA/hbePgR/Nwu3V0rH2hQREakY1u3az6jp880C+/u4uTBz9Lt0f6nZfyJDTk4OXl5ezJgxwxQnUkSkPIiKMhGRR0Tq7WQ+f/MDbl6OxdPfB/+xr/HL+g1Yz/mT+u8ko3TWodfCsbmueDTMwqthvtGiTJBgMBi1KSeCenCgShcaxO+n0clfsZZWwbNgEFVCA2ja6UWcHCqTr87mRtwxFHIr/Hwa3kcqI7k6DXWOb+JSfhbveQTziU8tKketQY/xTc/LOTe4JLMm4NRifFNOUyBT8r+W3xFi585CR0cW/hZm6qt29e68PWDtI5jBJ5eTMTBpDmSo4F5J36wsjdZoD0q3NjD69fvXE3k2uL1+Daf69zR9j/PwxCs3F3VeLhYl4rWt7hiO1s6YKaxqzAVSnZ3xSEhg2M59WNjZ/yey/hf3bz0GLpJCJvnYY0kQLo/EkkxEROT5waDTGbNgJiZg4e6BY7Pm/5klmYjI84xOpyPyxFkSUtLwcHGied0aj9Rt/8SJE1y4cIGGDRuSmZnJ5MmT2bNnD5cvX36uraNEHhxRUSYi8h9y80osC6f8QIrDArDIBr2U7i2XsPfsZ+TlZxFa/RWa1H+T7f9MxdLSjlc7/4BgYUtu5g1iruykRlBHHOwrxqpCrdeRUJCHn6UNR7NTeCHamO6xvrUTx3KMWWhsBAmbZLl8Ktizr0BNlYQoul5eh1pV0tpMQKGwQiJIGT54J77eDSpEvqcBvd7oQvnBd5B49yzYd0UqAV0ZFma2VtA9DHq2MyYZEHn2OfveW9xatoRkRwfckpMpkMlRaDVmdQ40bsJ1P3/kBQV02rIJZX4+lv4BvHj6EsJ/ZIIo3r9FREREREREnlROnDjBW2+9RUxMDAqFgvr16/P9999Tq1atxy2ayFOGqCgTEXkMJKde4Uj0UqoFtiXAt+njFofjqlQanNiEAXjF2YedGQlkF2YinBvYGIPBwIfnttP98Dc45tzd59DdtTqfjjr7H0n95KAugM17YdEGSM+6b/W7UpYF2qpp4OVWdn2RZ4u0q1f5behgqu/fj2DQI9MVJ9goEEAqSEh098A+MwObnBzkLi68eOYKsv/wPirev0VERERERERERJ51REWZiIgIABtTb3A6J533Paox49ZZptw6DcDioGZUid3Jyo3vUSC1QKHLxwBlOkLpgRpVw+nd9WdcnAL+S/GfCDKz4c1JcDsFagXB6YvlaxcaZFSSHTpVepuTPeh0oNXBmEHQtkmFiizyhJG49g9OD+yNAcj18MQyJRmJRmMWDLdo7UmUStqk5v6n8on3bxERERERERERkWed5yRctIiIyP3o6lyZTyvXxkluwRd+dfi5SiMWBTXjNdcqRJ9bBxhQ6PLJUjiaHtTv1LJLgPOXtrJk9Wvo9TqeN+xtYeV3sGkOOJVThyCVwJlLZSvJANIyIVMFOXkwb5XRek3k2cWmek0kSiUC4FO9JjJBMK03gWIlWb6FBQ7j/32GJhERERERERERERERc0RFmYiISClkgoQGti7k6bRk6jS0ajICG+tKSKQK7ArSMQAFUgv2B/chX2YFmCvNrl7fz8dfP5/+gnIZONjC4O7GDJkdXjRmtCwLqdQYo0xfTrve22nQc3TFySry5GETUp2mx8+hcHUnbec2DCWC+edLZWQWWnFd8w8go279xyWmiIiIiIiIiIiIyDOL6HopIiJihsFg4GROGo2jt6A26Gkul7Mm8AVcXaoy5af6xMcfRy21ZH3D8VjqcqkVu50qScfL7Mu/clMqe9Wnc9svUVr+N1n5nkSiTsPKv+HIWaiIK66fp1Ex2Sscurb+9/2JPFmoExLYW8WzVHmqkzNHw8PR5BdgVbkyY8dOwMnJ+T+VTbx/i4iIiIiIiIiIPOuIijIREREzOp7Zzt/p8abvbumX6Xd8Jp+OOodMquDo6dVcVDhz4s+3kGvzCAhsh7VcyenzG+/ap9LSkcH9/qBaYNh/sQtPLM1frxhFWUlmf2y0XBN5dtDl5rK3qg/a9DRTmQFw+305tXv2fXyCId6/RUREREREREREnn1E10sRERET1/NUZkoy39snaHN6IQUFOWRmxSO1cia4/puczE1Hrs0DICE3jSuxkaY2giAt1W9efjq/rejFY9DLP1EMegVslCApx5XXxx2CfO9f79jzl2T0mUdqZUWTI6ep/cdGmp66RJXPv6JBxO7HriQTEREREREREREReR4QFWUiIiImOp/bafY9x9KRHCtXLgb3JN4+gKCj6/GOWkNmpRqc9G1LvFM1mrf5kpeafWBSkBkMZQfxz81LJz3zJidOryEu4S6R659xBneDiPnw6TsgK61PNMPH3RjA/35EnYF120GvrxgZRZ4MLD09ce38MtaBgQSM+wSnFq0et0giIiIiIo+BVq1aMWrUqMcthojIM42fnx+zZs163GKIPEGIijIRERFuqnPoeXYXZ3IzTGUyBKp4N2Bjgw/YHtCJ+YkxxBcYNTfJ2gJ+6r+SaUMPE2rjhJtrCBLJvTU/Lk5ViNj9NQtX9GTazy9wOznmUe7SE027prB+NgzoDAE+4FRG+LaD0RCXdP++LlyD7/8HLQbBkr9g3wlIz6poiUVEnm0SExMZPnw4AQEBWFhY4OPjQ5cuXdi5s/jlgZ+fH4IgIAgCSqUSPz8/evXqxa5du0r1d+TIEdq0aYODgwOOjo6Eh4dz8uTJCpF10KBBJjnK+vj5+ZVq06pVq3u2adWqlWkf73xQOHHiBL1798bDwwMLCwt8fX3p3Lkzf/31l8lKODY2FkEQiI6O5vPPP7/nWIIgUFFU9HErIjU1FW9vbwRBICMjw1S+Z8+eMvcnMTHRVKfk8ZHL5fj7+zNu3Djy8/NLjbNp0yZatmyJra0tVlZWvPDCCyxevLhC5kbk8VJ0HkydOtWsfMOGDQ+8BtatW8eXX35ZkeKVSUWup5MnT9K3b198fHxQKpWEhIQwe/bsUmPu2bOHevXqYWFhQWBgYIWf/3deL52dnWnfvj2nTt37he2gQYN45ZVXzMoSExMZOXIkgYGBWFpa4ubmRrNmzZg7dy65ubmmendeRw0GA2PGjMHOzo49e/aY+rrfXIs8Hu52nS/5KTqORSxevPi+bWJjYzEYDPzyyy80atQIGxsbHBwcaNCgAbNmzTKdQyXvoVKpFB8fH9555x3S0ozhOLp06UL79u3LlD0yMhJBEDh16pTpvlz0sbW1pUaNGgwdOpRLly6ZtVu3bh1t27alUqVK2NnZ0aRJE7Zu3Vrxk/uUISrKRESec9anXCf06EbWpN00K9diYJxXTZQSKQ4yBe97BNPWwQMvhRUfelWnto0T0pTzzJjXhIXLX8XLPRSA6kEd6dXlZxRyK1KtPYjxbIJGkGOhsCU17aqxb10BSSkX//N9fZJwtIMhvWDJ17DoSwhrDFaWxdsfxkn1l9Xw8UzoMgxWi/c3kacUg15PatwF4i8dJjXuAoZHbC4ZGxtL/fr12bVrF9OmTeP06dNERETQunVrhg4dalZ38uTJJCQkEBMTw5IlS3BwcCAsLIyvv/7aVEelUtG+fXsqV67M4cOH2bdvH7a2toSHh6PRaMqUYfHixSZl1f2YPXs2CQkJpg/AokWLTN+PHDlSqs26detM26OiogDYsWOHqWzdunVljrVx40YaN26MSqXi999/5/z580RERNCtWzc+/fRTMjMzS7UZM2aMmXze3t6meSsp8520atXqgR6SK/q4lWTw4MGEhobedeyYmBiz/XF1dTXb3r59exISErh69SozZ85k/vz5TJo0yazOjz/+SNeuXWnWrBmHDx/m1KlT9OnThyFDhjBmzJi7jr1nz54ylaEi90av13Hx6h6OnlzBxat70OvLtn6vSCwtLfn2229JT0//V/04OTlha2tbQVKVTUWvp2PHjuHq6srSpUs5e/Ysn3zyCePHj+enn34y1bl27RqdOnWidevWREdHM2rUKN566617PqA/6HUCitdjQkICO3fuRCaT0blz5wfq4+rVq9StW5dt27YxZcoUTpw4wcGDBxk3bhybNm1ix44dZbbT6XQMHjyYJUuWsHv3blq1avVAc12SImXL04ZOr2fP9UusOHuMPdcvoXvCXSCaNm1qdn3v1auX2TmUkJBA06ZNzdr07t3bbHuTJk14++23zcp8fHwYOHAgo0aNomvXruzevZvo6Gg+++wzNm7cyLZt20z91ahRg4SEBG7cuMGiRYuIiIjgvffeA4z3p+3bt3Pr1q1Ssi9atIgGDRqY3b+K7vUnT55kypQpnD9/ntq1a5spZffu3Uvbtm3ZsmULx44do3Xr1nTp0oUTJ07cdZ4eZi0+bcgetwAiIiKPj10ZCXQ/v6dUuQC86uJL90q+pDh5IREELCVSttVqZ1YvPeMmBoPxhufqEsSY9w6ZLMvUNu50TE1BK1VQxbUe7aPnENZ8HHn5mcQlnmT+/14mwLcZQQGtebHRezjYlc7y97zg7ACfvw+pGTDjd1DI4WYixMTeu51EcneXy9nLoG0TcBDjrYs8RSRePcb5/StQ5xQ/WFpYOxLSrC/uAfUfyZjvv/8+giAQFRWFtbW1qbxGjRq8+eabZnVtbW1xd3cHoHLlyrRo0QIPDw8mTpzIq6++SnBwMBcuXCAtLY3Jkyfj4+MDwKRJkwgNDeX69esEBgb+K3nt7e2xtzc3Q3VwcDDJVRZOTk6mv4ssm5ydne/ZJicnh8GDB9OpU6dSirSQkBAGDx5cZtxJGxsbbGxsTN+lUqnZvFUUFX3cipg7dy4ZGRlMnDiRv//+u8yxXV1dcXBwuKtsFhYWpvF8fHwICwtj+/btfPvttwDcvHmT0aNHM2rUKKZMmWJqN3r0aBQKBSNGjKBnz540atTowSZFpEyiz6xjzaaRZGQVP1g62HnzaufZ1KnZ/ZGNGxYWxuXLl/nmm2/47rvvyqyTmprKsGHD2Lt3L+np6VSpUoUJEybQt29xTMpWrVpRp04dZs2axYQJE9i5cyeHDx8266d27dr06NGDiRMnArBgwQJmzJjBtWvX8PPzY8SIEbz//vt3lbWi19OdbQICAjh48CDr1q1j2LBhAMybNw9/f39mzJgBGK8r+/btY+bMmYSHh99zbh+EkuvR3d2djz/+mObNm5OcnEylSpXK1cf777+PTCbj6NGjZvMTEBBA165dy7wWqtVq+vbty9GjR4mMjDRdZx5krp921l04ycht67mVnWEq87Z1YHa7bnSvVvuRjJmdnc2QIUPYsGEDdnZ2jBs3jo0bN5rWEEBSUhKDBw9mx44duLu789VXX5naKxQKs/uVUqlErVbf8x6mVCpRKpVmfVhZWZm1+eOPP1i2bBkbNmyga9eupnI/Pz9efvllsrKK3UFkMpmprZeXFz179mTRokUAdO7cmUqVKrF48WI+/fRTUxuVSsXq1auZNm2amWwl7/UBAQF06dKFNm3aMHjwYK5cuYJUKi1lST5lyhQ2btzIX3/9Rd26de+63886okWZiMhzyPqU63wae5x4da5ZuYUg4QPPEPTNX+ePkFYAWEllWN7FrbJ2jW60bfER9UP78nL4NyYl2e2CPNbfPI5WqgBApTQ+pFX2qk9c4il0ugIArl7fT8Tur5gxt8mj2M2nDmcHmDLSqDRbONloadavI/RsV3YCgPu9lOs+CjKyIU/9KKQVEalYEq8eI3rbz2ZKMgB1TjrR234m8eqxCh8zLS2NiIgIhg4davbAUsS9lCFFjBw5EoPBwMaNxsy/wcHBODs7s3DhQgoKCsjLy2PhwoWEhIQ8VZZA27ZtIzU1lXHjxt21TkW6UT4Ij+K4AZw7d47JkyezZMkSJPfIulKnTh08PDxo27Yt+/fvv+c4Z86c4cCBAygUClPZmjVr0Gg0ZVqOvfvuu9jY2LBixYr77oPI/Yk+s44Fy181U5IBZGTFsWD5q0SfKduasiKQSqVMmTKFH3/8sUzrDzAqruvXr8/mzZs5c+YM77zzDgMHDjRZft5J//79iYqK4sqVK6ays2fPcurUKfr16wfAsmXLmDhxIl9//TXnz59nypQpfPbZZ/z+++9l9vmo1tOdZGZmmintDx48SFiYeTb08PBwDh48eN/xHhaVSsXSpUsJDAzE2dm5XG1SU1PZtm3bXecHSl8LVSoVnTp14ty5c+zfv9+kJKuIuX5aWHfhJK+uXWSmJAOIy87g1bWLWHehYsIR3MmHH37I/v37+fPPP9m+fTuRkZEcP37crM6gQYO4efMmu3fvZs2aNfz8888kJZUj3sm/YNmyZQQHB5spyYoQBKHUC7AiYmNj2bp1q+keIpPJeO2111i8eLGZgnb16tXodDozJXtZSCQSRo4cyfXr1zl2rOzfVXq9nuzsbLP1+jwiWpSJiDxnnM5Jp8f5PRiAjo5ejPIM4cf4C0gFge0129Lcofxv/SUSKV3bTy1V/vK5XeSlXuPFW1EkOATyttKSzq9vwcW5CgKlH6zSM2+SlnGT5NRL6HQFBPq3RCFXlqr3vFHV1/gBeL0rHIiGHQeNAfzLQ4EWOhda8bu7wNxPodLzfc8TeUIx6PWc339vxcCF/Stx86uLUJ60seXk8uXLGAwGqlWr9tB9ODk54erqanKJsbW1Zc+ePbzyyiumuEJVq1Zl69atyGRPz8+uixeN7vElra2OHDlC69atTd9Xrlz5wC5MFcGjOG5F1h/Tpk2jcuXKXL16tVQbDw8P5s2bR4MGDVCr1SxYsIBWrVpx+PBh6tWrZ6q3adMmbGxs0Gq1qNVqJBKJmcvZxYsXsbe3x8PDo9QYCoWCgIAA0/yLPDx6vY41m0ZSdjADAyCwZvMoQqt3vW+c1YelW7du1KlTh0mTJrFw4cJS2728vMwUpsOHD2fr1q388ccfNGzYsFT9GjVqULt2bZYvX85nn30GGB/AGzVqZLJWnTRpEjNmzKB7d6O1nL+/P+fOnWP+/Pm8/vrrpfp8FOvpTg4cOMCqVavYvHmzqSwxMRE3Nzezem5ubmRlZZGXl2dmofNvKFqPYLSU9fDwYNOmTfdUhpekaH5KXgsBXFxcTBa6Q4cONVmMAnz55ZfY2tpy/vx5M6u1ipjrpwGdXs/IbevvsfJg1Pb1dA2qhbQC7+nZ2dn8/vvvLF++nDZt2gBGd0RPz2KvlYsXL/L3338TFRXFCy+8AGB6mfUouXTpUqlz6G6cPn0aGxsbdDqd6Rz7/vvvTdvffPNNpk2bxj///GMK27Bo0SJ69OhxV4VbSYrOv9jY2DKvM9OnT0elUtGrV69yyfusIlqUiYg8Z5R8+yARBGZWaYi2+WuoXxz4QEqye5Giyee0bxsybLz4yacGoztM5e9dX/Dl98FYWTmWJRUTv6vMjwvb8PPiDqKFWRk42ELH5vDVcKOV2Vs94Iv3wbqcvyMTU6D3WLh049HKKSLyMKQlXCxlSXYn+TlppCVUrPKgLHeZh+2nyKIgLy+PwYMH06xZMw4dOsT+/fupWbMmnTp1Ii/PmBDlxo0bJhdFGxsbhgwZQmRkpFlZSZe8J4XQ0FCio6OJjo4mJycHrVb70H1NmTLFbH8jIyMZMmSIWdmNG2VfsB7FcRs/fjwhISEMGDDgrvWDg4N59913qV+/Pk2bNuW3336jadOmzJw506xeUcylw4cP8/rrr/PGG2/Qo0ePh5az5Jx06NChzPNHpDSXYyNLWZKZYyAj8yaXYyMfqRzffvutKcbfneh0Or788ktq1aqFk5MTNjY2bN269a7nPhitypYvXw4Yz+EVK1bQv39/wKgIunLlCoMHDzY7R7766iszK7SSPIr1VJIzZ87QtWtXJk2aRLt27cpoeXf+zXWiiKL1GB0dTVRUFOHh4XTo0IHr168/kCx3EhUVRXR0NDVq1ECtNjfdb9euHTk5OaWu4w8y1x06dDDbTzAqSou+16hR41/J/yiJvHmllCVZSQzAzawMIm+WfU4+LFevXkWj0Zgpf+zt7c0UVOfPn0cmk1G/fnE4h2rVqj1ya74HOfbBwcFER0dz5MgRPvroI8LDwxk+fLhpe7Vq1Uz3IDAqYCMjIxk8ePADyVLWel2+fDlffPEFf/zxh1n8zYpYi08bT8+rTRERkX/NiCuH+Sn+Ai3s3Gjt4M77Ho/mjdbKai2ZmxBDx5DWtK/khyo3ldibxnga+fmZhFbvRnLKRbw963Ikemmp9nGJJ1m69k3CW31CJecqj0TGpxUrJbzfp/j7i/Xg+yUQsQ90emjTyJgt88K10m0LNBBzDapW/u/kFREpD+rc0kHh/0298lK1alUEQeDChQsP3UdqairJycn4+/sDxh+ZsbGxHDx40GSxsHz5chwdHdm4cSN9+vTB09OT6OhoUx/r1q1j7dq1LFu2zFT2uF0eqlatChgD1zdu3BjAlJmuIhgyZIjZ2+r+/fvTo0cPkxUMYGYFcKdsFX3cdu3axenTp1mzZg1Q/CDh4uLCJ598whdffFFmPw0bNmTfvn1mZdbW1qZ5+u2336hduzYLFy40PcQEBQWRmZlJfHx8qX0sKCjgypUrZpZ7Jc+Vw4cP89FHH5llXbOzE4NRlkVWdtmJIx623sPSokULwsPDGT9+PIMGDTLbNm3aNGbPns2sWbOoVasW1tbWjBo1ioKCgrv217dvXz766COOHz9OXl4eN2/epHfv3oDR5Q/g119/LRXjTiot22ruUaynIs6dO0ebNm145513zOIpgTFe2O3bt83Kbt++jZ2dncma7N9cJ4oouR7BGL/N3t6eX3/91Sw21d0IDAxEEARiYsyztQcEBACUafnWpk0bhg8fTteuXdHr9aaMnw8y1wsWLDC9XClqu2XLFry8vACQy+X37eNxkaAqX/r18tZ7FggKCir3GlMoFKZzdurUqXTq1IkvvvjCLPvt4MGDGT58OHPmzGHRokVUqVKFli1blqv/IqX9net15cqVvPXWW6xevbqUW3RFrMWnDdGiTETkOWJuQgwG4J+s24zyqk4lheV925SXrOxEvlvQlhnzmhGgVbEgsDGyoz/z24reFKhVvPTiaGztvLGwrsSpc+vJy8+gX7dfodAV8873LIeOLeKXpa9UmHzPKhYKGP8W7FkEe36DL4bCNyOhZQN4oSa4O4OLI3i5QtM68FJpC2sRkceOhdX9XQUepF55cXJyIjw8nDlz5pCTk1Nqe0ZGxn37mD17NhKJhFdeeQWA3NxcJBKJ2Zvaou/6wsCCMpmMwMBA08fV1RWlUmlW9rgVZe3atcPJycnMnagicXJyMttfpVKJq6urWdndXFUfxXFbu3YtJ0+eNFmeLFiwAIDIyMh7ZqKLjo4u04WyCIlEwoQJE/j0009ND709evRALpebgpiXZN68eeTk5JjFmSk5J15eXmWePyKlsbO9+3F5mHr/hqlTp/LXX3+Vir+1f/9+unbtyoABA6hdu3a53G69vb1p2bIly5YtY9myZbRt29Z0Dri5ueHp6cnVq1fNzpHAwMBSD8VFPIr1BMbYaa1bt+b1118vM8NskyZNzDLvAWzfvp0mTYq9Cv7NdeJuCIKARCIxU0LdC2dnZ9q2bctPP/1U5vzcjXbt2vHXX3/x66+/MmLECNP+lHeuvby8zPYTwNfX1/Td19e33LL813jYlE95X9565SUgIAC5XG6W/TkzM9NsTVWrVg2tVmsWnysmJqZc5/m/oV+/fly8eLHMOH4Gg6HMLNJFfPrpp0yfPp34+HhTWa9evZBIJCxfvpwlS5bw5ptvlituqF6v54cffsDf398sUP+KFSt44403WLFiBZ06dSrV7lGsxSedZ2tvRERE7smbblX5JfEiPZx9sZcp7t/gARhz/A9+DR6AS9Z10ndOwdU9lIuRxswrEomMah1mMcOuNgN2DMMKyMyOJ1+dTXirCWzdM4Usq0rY55oH0ky4fZbDx/9Ho3oDH1KqFCAVKF9MgKcZQYCi+1MlJ/h6xOOVR0TkQXDyCMLC2vGe7peW1k44eQRV+Nhz5syhWbNmNGzYkMmTJxMaGopWq2X79u3MnTvXzF0qOzubxMRENBoN165dY+nSpSxYsIBvvvnG9CDTtm1bxo4dy9ChQxk+fDh6vZ6pU6cik8nMrISedGxsbFiwYAG9e/emU6dOjBgxgqpVq6JSqYiIiADubqHyX1DRx61KFXPr5ZSUFMCYia/IJWfWrFn4+/tTo0YN8vPzWbBgAbt27WLbtm33lLVnz56MHTuWOXPmMGbMGCpXrsx3333H6NGjsbS0ZODAgcjlcjZu3MiECRMYPXq0mPGyAgj0a46DnTcZWXGUHadMwMHem0C/5o9cllq1atG/f39++OEHs/KqVauyZs0aDhw4gKOjI99//z23b9+mevXq9+yvf//+TJo0iYKCglKuv1988QUjRozA3t6e9u3bo1arOXr0KOnp6Xz44Ydl9lfR6+nMmTO89NJLhIeH8+GHH5KYmAgYrxlFMbuGDBnCTz/9xLhx43jzzTfZtWsXf/zxh1kcs4pArVabxk9PT+enn35CpVLRpUuXcvfx888/06xZMxo0aMDnn39OaGgoEomEI0eOcOHCBTM3vpKEhYWxadMmunTpgl6v56effnqguX5aae5TBW9bB+KyM+6y8sDbzoHmPhXrNWJra8vrr7/O2LFjTXHzJk2aZPbyKjg4mPbt2/Puu+8yd+5cZDIZo0aNqrCYeHejV69erF+/nr59+/Lpp5/Srl07KlWqxOnTp5k5cybDhw83UzSXpEmTJoSGhjJlyhRTvEsbGxt69+7N+PHjycrKKmWtWkRqaiqJiYnk5uZy5swZZs2aRVRUFJs3bzbdw5cvX87rr7/O7NmzadSokWm9KJXKcsU8e1YRLcpERJ4j5ldtQl6zAayp3qrC+45UuACQYufLb3JnJmbnYBCMF2BnR3+OqVLRGPTsqvUmeq9G9H55LrY2lejS7iumT8o2KckMlPw5a+B/a15j76GfS413K+Ekx06tQqu90z1hMdAFmAV4A9UAG+BE4fYkQANsBP6qkH0XERH5dwgSCSHN7p2pqVqzPhUayL+IgIAAjh8/TuvWrRk9ejQ1a9akbdu27Ny5k7lz55rVnThxIh4eHgQGBjJw4EAyMzPZuXMnH330UbGc1arx119/cerUKZo0aULz5s2Jj48nIiLinpZHTyLdunXjwIEDWFlZ8dprrxEcHMxLL73Erl27Hlsg/yIq+riVh4KCAkaPHk2tWrVo2bIlJ0+eZMeOHaag0XdDJpMxbNgwvvvuO5MVyahRo1i/fj2RkZE0aNCAmjVrsnz5cubOncv06dMfbDJEykQikfJq59mF3+60tDB+f7XTrEcWyP9OJk+ebLIqLeLTTz+lXr16hIeH06pVK9zd3e/6sFySV199ldTUVHJzc0vVf+utt1iwYAGLFi0ynauLFy++q0UZVPx6WrNmDcnJySxduhQPDw/Tpyh4OhjdvjZv3sz27dupXbs2M2bMYMGCBYSHh993/x+Eomuvh4cHjRo14siRI6xevdoUBL08VKlShRMnThAWFsb48eOpXbs2DRo04Mcff2TMmDFmLnF38tJLL7F582YWL17M0KFD8ff3L/dcP61IJRJmt+sG3G3lway23So0kH8R33//PU2aNKFz586EhYXRrFkzQkJCsLQs9qIpCvDfsmVLunfvzjvvvPPILXMFQWD58uV8//33bNiwgZYtWxIaGsrnn39O165d73vef/DBByxYsICbN2+aygYPHkx6ejrh4eF3dXsMCwvDw8ODWrVq8fHHHxMSEsKpU6fMXtz98ssvaLVahg4darZeR44cWTE7/5QiGCoqguMDkJWVhb29PZmZmWJcBRGRZ4T5CTEMv3IYZ0EgsfCH4EtyOTPtrKlZrQvZei2vxewjTavmt6BmVFWar/1Zv7bi0rV/ysiJCY3rv8mAHsXZom6nXOTHBTVp1lBDZc9a1Ki2AvDCqBwrO46M0YDWH7h0R3kQRuVZHgWaAvLyu2Bv+wdg8cBzICLyrPOo79+JV49xfv8KM8syS2snqjXrg3tA2W/sRURERO5F9Jl1rNk00iywv4O9D692mkWdmt3v0VJEROTfsO7CSUZuW28W2N/HzoFZbbvRvVrt/0SGnJwcvLy8mDFjRrmD3YuIgKgoExEReQhuF+TxWsw+dBj4PagZXhbWQGH2peRr9I8xZpDq5eLHqpDyBZZMuH2Wr2fXNH2Xy5RotMXxI3y9G/F2/7U42Htx6eo/eLq3wtqqaKsTUBcwj3Xx73gT+B6j66Zj4UdE5Pnmv7h/G/R6YxbM3EwsrOxx8gh6JJZkIiIizw96vY7LsZFkZSdgZ+tBoF/z/8ySTETkeUan1xN58woJqiw8bOxo7lPlkViSFXHixAkuXLhAw4YNyczMZPLkyezZs4fLly/j4uLyyMYVefYQFWUiIiIPzOTrJ5l0IxqAj71r8o1/saWHzqDnjYv7WZt8HZlEQlM7V5YGv4iz/N6JAzIKdPxyMIK0qNFU9a5N9w7T+ew78/SMDWp3J/52BB6ucgb1zqQ4ZqUlEACcu6NXH+Am5cFggLvHwLQGDgK1ytWXiMizinj/FhEREREREXlSOXHiBG+99RYxMTEoFArq16/P999/T61a4m94kQdDDOYvIvIccyQ7hfiCXLo4+SApR6aUIl6wdUaCgAEDjWyNQVmv3ThEliqRWtVe5sbNw+RaVAKdjoj0OH6OO0eLhIM4OfriWSUMmSAplUxg8MEEIuIDsai8kZOdP8fR+l0sFFLUBTpTnZgr28lW5RKfCKHV7ahXKwdBcAOWAXbARCARqAL0AroDnwLTMMYluzsFGmMGybLJARpjtDDrAzy/gS1FREREREREREREnkTq1q1rltFSRORhES3KRESeMi7nZbEs6Srhjl40tqt03/qJBXkU6HW4K5TM2/s9lvkZvP7SBKLzc2lycgsGwNfCmgsNumH5AG4IF3Mz0QPVrOy5cn0/ny3vjcEA3Wp2Z2HsYbbVGQKCBAH4SHWJ7EhjavC/Gk0grVJ1FgjZxB77lTo1exDeagIvbb/O4ZR8AI527ESI/RUSbsORaDh+GlLSSstQLbAtw968d7YxI+kYFWc77iiXArrS1e/LO8D8h2gnIvJ0I96/RUREREREREREnnVEizIRkcfI0ewUlidfo4ezL5XkFqxKiaWTkzf1bJzv2qbz2Z3E5GUx7dZZ4hv1xK6EZdbtgjwu5mXR1K4SUkHC7KRExlzei1aXR82U07Q8MgOA925foEPHGabsktfVORzNTuFFezcAruRlsTszkQ6OXqb4Y3cSZGW0qjIYYGNyLCuaGTP+SK9txkkVx6DdH3DGpyVNWkwg7Z9VyAvbCdpcVDot+3d9jF6dyc344zRt8BbzGnnww4U0GrlEEWJ/BQAPN+jSzoJM1YukpBXFH5MAehzsoF3LKFQ5L2NjvQq4V1pnAxACOAPDMVqEfQGsKVFHoHT6eC8gA6NFWUl+wWjFNhUYdo9xRURERERERERERERERJ4mREWZiMhjIkWTT/NTEeTrdcyNv4CbXMn1ghym3DjNgqpN6O9WBYDjqlReObcba4mMv2uGoS00AtVh4EBWMsOuHCZYaUf/SgG8fnEfEk0ONjILrFzqY3CohVZntNJS6bTG/y0diXCszv7Y4yZZbKVyNqfdoqmdK/uzkmh5KgIDYKUrYLyDCwOD25KmU+Mit8RWKmfs1aNsTrpMrWs7kVh7ccq9FgjGwJzLfTsg8QlDYjAgV1gxwMqR8VW6ExIyFEl+CmnaVJwzryMU7oedrQcxEgf8lQp+augOvAwcxqi4Ookg1GNgj3poCvpw/PQqmr4wmOpV26OQf0hQlevAXxw92ZkGtX8A5gHtgC53zPZnwM+Ff78M9MPoRnkWSANeodhCLBC4XPi3jtJKsiJygHFAOFD1/gdcRERERERERERERERE5IlHdL0UeerJ1Wmxksq4lJeFjVSGh8Lq/o0eE3PjL7AzI5EeLpV56+IBcg3Fbn/OUgWpugLT9y5OPqyr3ooPrhzhp4QLAHRz8mGYZwhbM+Lp4OhF13O7yNIZY2/JELBRxZNh4wGAhdIDR9fGJF5fb+oz5OZeEh2qkG7rVaZ8/Sr5k6mXsTn1krGgjAj39lae5GhU1D23hIaXNwAQWa0vp/zDy+zTMT8T50qNyXdriMGgR31uLh0PTMQ23+hLqXEKYUv/c7hIYIcLOJfh/flDUgJTrh/lRVtn/ghuQmp+DpfPNadJ/Wj0eli43Im3B7gB5zHq/28C7iV6+Az4qvDvVhhdMEsOdBFoBmQCq4BrwEJKJwcoa0p8gQigWpn7LyLyLCHev0VERERERERERJ51RIsykaeSXxIuEpF2i6OqVBJQ4GXjyfW0cyglUvbX7kDdQtfFa/nZjLl6FB8La6YHNEAmPLp0xAsTL3E6J51x3jXxtCitrLuSl8X7Vw4DsD/rtpmSDKCvawA7MxI4n5cJwF9pN+l4Zgd6g8GknVmfdpMt6XFcaNCNuQkxJiUZgBYDdqpEMqzdQRBQ5yWQkrDXbIzzPi1KySVDQFvocrg8+RrOggLb3BSylU4mK7Gi8Z1tA1G6NcPGoENzdYupD7Xc6J7pLJWTqlUXtwPSLe2R2nphzHkpkGHrzbba7+KXdJIUe38MNYdj0Ou4obrFIKkvN3XwjR2c08KiHOhqCTNij6FWp7E2P41PLBxIWhGOUnWLqOOQmw8FmkoYDNaFCixF4acYjeYjZLIFCEIisAc4BdQtUSMLGAp0A2oD31CWkgyKlWR6A0gEgOtoNC8gl2eXWV9ERERERERERERERETk6UFUlIk8dWxKvcm7lw+WKMnlRoZRYZSn17EjPYE8vY6f4y+wLT2eZK0agKZ2rvSq5GdqlaZRMyH2ONWU9ozyrg7AqZw0hlw6RGULaxYFNUMplZGt1bAzI4GYvEy2p8czzrsm7ZzMLbIOZiXx1qUDACyIj2FTrbZUUjqzO/UKFoKEidejSdPkm+orhGJrJkGQI5Up2ZWeiNYxlABnK27cPohWk8X2jIRSJkxqg54LuZkczEoqNTc33OogGHQYBBkYDGgLUo0b7uhDjkBTO1fUBj2TKoeyPyuJr26eBiDVUICrNo8cgw59kcKrsK2g9EBTkEFm6nHivJuSK5Ggl1pxxb0ObR08qBc1g7OZ8WxqMLp4PIOetNv7sXEIQZOfirYgA60g51C1XkiklljpsrAXQCazIVV9jC+dviNR35A5qtFogBXp6bx4cj7ZgoTowK78EncCQ933aBs9H67dwABkWyaTrVqBne1OoCV5+VJ27fscJ0dfAv2aM2NeU9q1TOWlF8HoWmmJMUbZSeBjoA2gAlYCF4DiYwWOGOOUFRvfGgqVZEXTKper0Ot/QCIZUeqYiIiIiIiIiIiIiIiIiDw9iIoykacO6R2ugAAGfXEcqXWp1/ko9lipsOyDL+5nys3T7KzVFme5Ja1P7+BUTgoAl/OzedcjiLFXj3EwO5mD2cl0dvJmgFsVupzdyT9Zt0397MpM5PoLr+JjaU1UdjIbU29S1bLYBSkHPa+n6tFbyVHnO5IcF1FK3kRNnulve+d62DhUIyHzEtbWAQAEuzfl7M3CdiUUTlKgk7MvYY4e2EhlvHFxH5fzVcUdC4JRSVayXeHfVZJO45h9He9affihZnt8SgTpb+/kjZ+lrUnZl2TnU0pmicSS9LQT6HS5YNCDIOGiV9NC2Qxsz0ggxrEmwblZxYo1vY4617dx2b89WanHTXVzlE5gMKDX5aPKOIdMbo+hIIPpVcfRVPkP8AeJupb8nNMAy0uL2RncAwQBmwIVaVIp2Hhxyq8dbU4vQCtREFl9ABMuX+OnumOM58CWtzh4dCEALZuMQJWTzLotoNGGEd7qCFC9xJ6lAtrCv1OIPPQhf277jWqB1Xmjz0AkkrEYDAMRhBUlp7NoV0x/SyQRgKgoExEReXaJjY3F39+fEydOUKdOncctjojIc0GrVq2oU6cOs2bNetyiiIiIiDw3PDo/NBGRR0QHJ2+cpYq7bj+UnVJKSQag0ms5mZOG2+HVDL18iBslPB/nJFwi9Pif7MpIMJV9ev0EDvuXmynJwGhXFHR0PW4HV9IkegtTbp7mncsHzOrolMbskVpNVpkyFhj0AMjk9ljbBwEgldtgKHTHzFGnF1fWFylxBHSChOOqVDK1Bbxo70ZMg+7UsXZEoivAUp2Fg0Z913m57tmErzp+z/r6PcyUZEUMdq/KQFejoi7Q0haAUGsbugeF4+rTGS+/HgQIWqOS7E4KtUU3XWqRK7fBKesGigIVwfEHOOvdkmwEnLOuA2Cfk0CepYOZIs+Qd5nMzPPEZReg1cLldCdCCgR2ORVwQ+mERK8lOG4/VrnJyLV5SICPXhxG83bfcsW9AZ2O/4B2XT9Wbnyfr2fX5OKVnaa+/X0aYWfrgYXCljo1XsAYhwyKL3/BwGYyMoPYGJHK5p0zycvP5MSZc9xO7gJIEYRlnD7/A+diPNHpLDAYLABL9IYOJSahGTAe2ImIiMjTRWJiIsOHDycgIAALCwt8fHzo0qULO3cWr2c/Pz8EQUAQBJRKJX5+fvTq1Ytdu3aV6u/IkSO0adMGBwcHHB0dCQ8P5+TJkxUi66BBg0xylPXx8/OrkHHKwsfHh4SEBGrWrPnIxhAReRYoWqdTp041K9+wYQNCGS9878W6dev48ssvK1K8MqnI6+DJkyfp27cvPj4+KJVKQkJCmD17dqkx9+zZQ7169bCwsCAwMJDFixdX6D7deb10dnamffv2nDp16r7tXnnlFbOyxMRERo4cSWBgIJaWlri5udGsWTPmzp1Lbm6uqZ6fn5+ZUtNgMDBmzBjs7OzYs2ePqa/7zbXIo6NVq1amc8LCwgIvLy+6dOnCunXryqy/e/duOnbsiLOzM1ZWVlSvXp3Ro0cTFxf3H0su8l8iKspEnkqWBTd/qHYyhQMShQM/J8SgN2goXgJGBZW2hIrtujqHTL2mVB9uckvyDTqStGqKVEYagwEHqdxUJys1Gpkun8zU42Zt71xwOq2K/JxbFKjTyEo9zu2bm0iO386tpKgSjcwtxG4V5HI+N5MDWUlUP7YBOwy8u+1dBu8aQZ9dQxEkFmZjyBXOgARr+2okW5e2FCvJkuDm5DQdyItVulG/al+mhaxELjuLwsIZJDLqBPYmQOkIQJAuj8pJ0UazqkIMgsCxmq+RZleZEEcfgmv3o0BuRWWNil4HvuDdHcP4MjsGa53arF2mKhmAAWcGMOhbN2ZNS2Py5u94ef8v9D6/lM7HZhJ26ldePfgFHY98TxNrJ7q4B9Oz5VgCDYXJDHRq9h2eS8Lts6Smx1IjuDODei9n5/7vycpOQF2QzY04P3S6F8lXu6PKmQWsIV43h2ZJL7FgXTzb94Kq0DjR27MuLk5VCiUUqBUynOrBcUil+QjCD4AGmfQw8C0wDfgBmAp0BMyVqyIiIuVHp9Ox53Q0K/7ZxZ7T0eh0uvs3+hfExsZSv359du3axbRp0zh9+jQRERG0bt2aoUOHmtWdPHkyCQkJxMTEsGTJEhwcHAgLC+Prr7821VGpVLRv357KlStz+PBh9u3bh62tLeHh4Wg0pe8pAIsXL6ZVq1blknf27NkkJCSYPgCLFi0yfT9y5MjDTUQ5kEqluLu7I5OJDgkiTxc6g549GYmsSLrKnoxEdGW99KtgLC0t+fbbb0lPT79/5Xvg5OSEra1tBUlVNhV9HTx27Biurq4sXbqUs2fP8sknnzB+/Hh++uknU51r167RqVMnWrduTXR0NKNGjeKtt95i69atd5WzVatWD6xMa9++ven6uHPnTmQyGZ07d36gPq5evUrdunXZtm0bU6ZM4cSJExw8eJBx48axadMmduzYUWY7nU7H4MGDWbJkCbt376ZVq1YPNNfPAjqdjmOH9rDtzxUcO7Tnkd/Ty8vbb79NQkICV65cYe3atVSvXp0+ffrwzjvvmNWbP38+YWFhuLu7s3btWs6dO8e8efPIzMxkxowZj0l6kf8C8ZeOyFNJK0cPHGQKMrQF969ciIWVJy4eYWjUqaTE7yBLnVmqjgBlWqOVpIGNMxHpcdx5mc8oEVg/UBOPMuU2sbp8szp6YIJPLW7lq1iSfA2DQUdq4u4S4wtoCzIAeNHOlX1lxCGTItDYrhI9zu0hJi+LGIOBAFtvrLNvkmrjjaPEQI5eQkdnLzyt3MmzrcZRjQQXCYRbgtoAFgKsyoXVeVBfDgcK4LYOnCXwslLCDjWAgg8yf2F7pVB+y5nGrzl9OKgBG++X0bsZEASBy9ciuR53DNcar9Lr8hEu5Gcx2rsGLzl40NDWBUuJlDM5GfjLLbjk7IR7pRC8PeswHKgStY6ramMA/DrWjngolERf2Y1DjlHJFJgQxUaflngX5BCces50fLwzLrEn6RwehzOwlsh4v8kHaCOGc1unx8ZkiSfQtsVY3CqFsHhVP9PcabUyZv2q49qNROxsp/D5mKvsKpBzQweCpNBdVIDhg3+kiu8QpFIZsAwYC7wILAfOAu8DOk6dS+Pcxc10aReDtVXRsdIjvoMQEXk41h2IZOSvc7iVmmIq83Z2YfbbQ+ne9OFekNyP999/H0EQiIqKwtq62Nq2Ro0avPnmm2Z1bW1tcXc3ZtStXLkyLVq0wMPDg4kTJ/Lqq68SHBzMhQsXSEtLY/Lkyfj4GF9OTJo0idDQUK5fv05gYOC/ktfe3h57e3uzMgcHB5Ncd+Pzzz9nw4YNjB49ms8++4z09HQ6dOjAr7/+anoIj4iI4KuvvuLMmTNIpVKaNGnC7NmzqVLF+NKgpOtlaGgolStX5pNPPuG9994zjXPixAnq16/PtWvX8PX1JSMjgzFjxrBx40bUajUNGjRg5syZ1K5d+1/Ng4hIeVmXcp2RV6K4VVBs9eOtsGJ2lYZ0d/F9ZOOGhYVx+fJlvvnmG7777rsy66SmpjJs2DD27t1Leno6VapUYcKECfTt29dUp6Tr5YQJE9i5cyeHDx8266d27dr06NGDiRMnArBgwQJmzJjBtWvX8PPzY8SIEbz//vt3lbWir4N3tgkICODgwYOsW7eOYcOGATBv3jz8/f1NyoaQkBD27dvHzJkzCQ8vO5P6w2BhYWGS193dnY8//pjmzZuTnJxMpUqVytXH+++/j0wm4+jRo2bzExAQQNeuXTEYSj89qNVq+vbty9GjR4mMjCQ4ONjUV3nn+mlnd8Q6Zk4eRVLiLVOZq7s3H0ycRev23R/ZuK1atTJZPv/vf/9DLpfz3nvvMXnyZJNFp5WVlem88Pb2pnHjxlSrVo0333yTXr16ERYWxq1btxgxYgQjRoxg5syZpv79/Pxo0aIFGRkZj2wfRB4/4tOcyFOJhUTKuXpdcZNZ3L9yIQqFE4IgkJkWjV5vdFG0d26AZ0A/7F0aAiBVuCCT29+rGzaXoSS7k+icNI5kp+Aqt0QuSJBQbGa/fvEyDh89ZvreV5PCu7s/ZOzxmfwZWJ+Gti6M8aqBd4nMmXIEBAQsFPY0s6tEnDqXto4eADjKLXj/nX9QtP+Rej1XkNy4D/nNB9Le0Zsl8dFsv7GTVL2eizpolAT1b8PpAvgoEw4XwM85EK2BBD2c0cKCEiHPZMjwlHrysW1lPArzD1SWYrrJBPo3p82Lo6jl6M2p+l253agXX/nV4yUHD2ykcmSChDo2TthbWNOgdl+8PeuY+m5XKH9lC2v2hLbns8q1yXWqyk3nGqhlSk76taNAbk1k9QFmc5ursCNL6YLGoCdDV8CUvAIueDVnWcup6E3zbMDLow635M6keDQDIN+lNqE1unHjltHaIis7EbVahf2ZBTTYP4bEOu/QMUzGG32qEhTwFlLpXqArMA5IAFZjDP5/nCILxHw17Ivay987jUoygwE2RGj58HN/InZ9dZ+zREREpCTrDkTy6tQvzJRkAHGpKbw69QvWHYis8DHT0tKIiIhg6NChZg8sRTg4ONy3j5EjR2IwGNi4cSMAwcHBODs7s3DhQgoKCsjLy2PhwoWEhIQ8UrfI8nDlyhU2bNjApk2b2LRpE//884+Za1hOTg4ffvghR48eZefOnUgkErp164ZeX9r6RiKR0LdvX5YvX25WvmzZMpo1a4avr1EB0bNnT5KSkvj77785duwY9erVo02bNqSlpT3anRURwagke/X8HjMlGUBcQS6vnt/DupTrj2xsqVTKlClT+PHHH7l161aZdfLz86lfvz6bN2/mzJkzvPPOOwwcOJCoqKgy6/fv35+oqCiuXLliKjt79iynTp2iXz/ji8Fly5YxceJEvv76a86fP8+UKVP47LPP+P3338vs81FcB8siMzMTJycn0/eDBw8SFhZmVic8PJyDBw/e2bTCUKlULF26lMDAQJydncvVJjU1lW3btt11foBS7rQqlYpOnTpx7tw59u/fb1KSVcRcPy3sjljH+KE9zZRkAEm34xg/tCe7I8p2c6wofv/9d2QyGVFRUcyePZvvv/+eBQsW3LPN66+/jqOjo8kFc/Xq1RQUFDBu3Lgy6z9Lx0ukNKKiTOSpxcPCir21OyCnfLEeVFkXyVXFIpEUu0jm5dzEoNdgZWP8Qa8tSEGrKW1pdncE7Jzrlyo1ABoMpGnySWrcG0uZ0lQ/xtGOmBKWZvpza5Dlp5F7+yTCjUOM865JZydvZgc0ZJRnCLMCXgALJwwYUBdkclCtY0BMJMM8Q7jcoBuXG3TnBWd/vm8xjI+rNEZSeLOeGXeObJ2Gm6p4NOp0MBjQAJkG+EkFXoWKL/s7pi/JAO0soL0FrHK2BQ4jE5qy0Rl+doCVd/ldIZdIcFUoy95YBj8HNia6bhdO1XsZe5mCJnau3Go6gJMvfs6CtnO55tXMNJeb647gmmsdEpyCOVzzTXoemYbCFLsNFJ710QtSLni/CEBoSFeUlna4yyVIC+feIi+JA1G/oitsp5BbEXNlJ1s3vo3X8RnkrZrBZzde4Z3outyMWw+8BvwJxAOgM8hZqNKRq+8JtCdbZc+2f4zjX71h4Hay0RqtfigUFOSwc9/0cs+FSMVwPT6OyONHyc7JuX9lkScKnU7HyF/nlGnRW1Q2asHPFe6ycfnyZQwGA9WqVXvoPpycnHB1dSU2NhYwWlvs2bOHpUuXolQqsbGxISIigr///vuxuyzq9XoWL15MzZo1ad68OQMHDjSLidOjRw+6d+9OYGAgderU4bfffuP06dOcO3euzP769+/P/v37uXHjhqn/lStX0r9/fwD27dtHVFQUq1evpkGDBlStWpXp06fj4ODAmjVrHv0OizzX6Ax6Rl6Juvd15WrUI3XD7NatG3Xq1GHSpEllbvfy8mLMmDHUqVOHgIAAhg8fTvv27fnjjz/KrF+jRg1q165tpqBetmwZjRo1MlmrTpo0iRkzZtC9e3f8/f3p3r07H3zwAfPnzy+zz0dxHbyTAwcOsGrVKjO3tsTERNzc3Mzqubm5kZWVRV5e3p1dPDSbNm3CxsYGGxsbbG1t+fPPP1m1ahUSSfkeg4vmp0jZVYSLi4up348++shs25dffkl0dDSRkZEmy+KSff2buX4a0Ol0zJw8yizMionCsllffvBI3TB9fHyYOXMmwcHB9O/fn+HDh5tZhZWFRCIhKCjIdB5funQJOzs7PDw8HpmcIk8uoqJM5KkmyMqesw1eYYpvXcLsPXCXWZZZTyK1xqAvIC3xH/JUsabygvzb5GRdIjnu7vEQ7odOkwNIy9giILPyxiVqI5VtPJBbOAMG9PX8IMDTVOuMRzP0goRchR3dc9S8en4PrU5v5WROOjOrNCwcpPgHgyDIyCp086yitMNJXrZVXe9KfgDIFY5IZNY45hbv9xY13NDBaBuIrASrnGC8TZHU0NsKfnWCasU6Rdyk0EUJjhV01RAEgdo2TtjLihMz2EjlHKvXmV212nGrUU+21mzL8uphxLrXY0v9UaxrNJ5zrqHctnLHYMpUaWBi48GstLPmza5z+fqTZHq9PAcAa20uboXx3oScBJwcjQpRvSBBbVeZrf98YyZTcNx+vuhwDh+vfkB2kaQASAUNOlbxS44NW3acZfL3mSQWelveiIP/FT7zyQpPhbq1elXMRImUiyyViv/9tZFdhw+xeuvf3Lh68XGLJPIARJ47XcqSrCQG4GZKMpHnTlfouGW5yzxsP0UWBXl5eQwePJhmzZpx6NAh9u/fT82aNenUqZPp4e/GjRumBywbGxuGDBlCZGSkWdmUKVMqRLaS+Pn5mcU68vDwICmp2MX/0qVL9O3bl4CAAOzs7EwWcEWKsDupU6cOISEhpof2f/75h6SkJHr27AkYA3qrVCqcnZ3N9u3atWtmFjEiIo+CyMykUpZkJTEAN9W5RGaWDnNRkXz77bf8/vvvnD9/vtQ2nU7Hl19+Sa1atXBycsLGxoatW7fedc2BUUFdtOYMBgMrVqwwKadzcnK4cuUKgwcPNltzX3311V3X3KO4DpbkzJkzdO3alUmTJtGuXbsH6nPKlClm+xEZGcmQIUPMyu41V4ApBlp0dDRRUVGEh4fToUMHrl//d9aEUVFRREdHU6NGDdRq82Ra7dq1Iycnp9R1vLxzfec+Pm1EH4ksZUlmhsHA7YSbRB+peEvxIho3bmx2PjZp0oRLly7dVzlX8jy+2zkt8nwgxigTeeqpqrRjfOVQxlcONZUdz05ladJV/kq7yeX8bECHlY0fBepUEGRIJBYU5CcCAgpLV3KyLpXqVyq3Q1cia6VUZotOm21WRyK1JCfrQplySRX2aDSZCBI5GXJX3FxeJO7qcgx3JAhIDB3J2oBupGWeRSstVnrFFeSyJe0Wo64eKRzLCoWFE4Img+p+nZiSBR/ZgvQu1+/PfetwyCKYM3oLBEHCuzYuzMyHkrdyGwk4SqGpFELlsFMNaQbwKUvv9x/hLLektYPxzU07hRK1Xke3tDgi0uPI0+vwyEnkn5qDTMkN5Do1K+Y1JCvzFvVDK6Frn87iVVoqe41CEAQK1MZj6OFag9MX/qJl8zF8ovDmksKBGsknaZV4Cp0gQWrQ45STQLhTYqEkWSQlT2b1ps+xtDTQopmUXEcr+lrWJTL/Jnnm4ecoMhRxdIBvJlhia/PLo58sERN6vR594Q/QY/u28cuYXgiChIHvjmPImK/K/eZY5PGQUE43vPLWKy9Vq1ZFEAQuXCj7Ol4eUlNTSU5Oxt/fH4Dly5cTGxvLwYMHTefd8uXLcXR0ZOPGjfTp0wdPT0+io6NNfaxbt461a9eybNkyU1lJF6WKQi6Xm30XBMHMrbJLly74+vry66+/4unpiV6vp2bNmhQU3D0eaNFD+8cff8zy5ctp3769yaVJpVLh4eFhyvRWEtFlReRRk3APJdnD1HtYWrRoQXh4OOPHj2fQoEFm26ZNm8bs2bOZNWsWtWrVwtramlGjRt1zzfXt25ePPvqI48ePk5eXx82bN+nduzdgXHMAv/76K40aNTJrJ5WW/ePuUVwHizh37hxt2rThnXfe4dNPPzXb5u7uzu3b5smPbt++jZ2dHUql0RtgyJAh9OpV/OKxf//+JsvXIjw9PbkX1tbWZrEhFyxYgL29Pb/++itffXX/MBmBgYEIgkBMTIxZeUCAMVN8kawladOmDcOHD6dr167o9XpTxs/yzvXkyZMZM2bMfWV7UklNSqjQev8VOp2OS5cu8cILLwAQFBREZmYmCQkJolXZc4j45CDyTFLP1pnvq7zAoqBmtHXw4AvvarhqUtBqsqks0RARWJufq7XDx7c7llYeBLjUwVJabNlkZRuIhaW5OXiVQkWIhbQ4poBUVvyWR6owj20mlVii02Sj1WSSozX+cHF2b8Wd1mcGgxapSz0k1j4IEqNFnI1ERms7d/J0RqspQZBh0Gt41VrBgKpd2ae1ZG4ObLlDWXMn3zsrCVVIaKWAN+xt2eICP9hDFwvoo4R+Je7tm/MhSgOXtfCz6u59/tdYSKSsq96a7Kb9uPZCD94PamNSklmqs+hwdDZZmca3VqfPJ2NtpaV1MzhwdAH5+cWKzoSksxyNXsbfh+dzSeEAQKxrHYICXsKyhIJyww4Zqelw/iJ8O2cS5y/pOXEaZs/T8ZZ8Fm7yaHp0gjt/bypkcPU6HD0JxncQovvff4mDnR29wjsQ7O1F9Jb/AWAw6FkybypNA2Ukxt37jbPI48WjnEqh8tYrL05OToSHhzNnzv/bu/PwqIq07+Pf0510yL6RkIQthCQsYUeIiGzKKqCgjLKpmMEZBxQdcBkfBRH3AQUU5H1FNh9wFBw3QFEkKAhuCIgsghEQAwmBQPat093PH00CTQIGTQg0v891xXTXqXOqqr26D7m76q655FeyZLcqiXpnz56NyWRiyJAhABQUFGAymVy+hS57XhaU8vDwIDY2tvwnPDwcb29vl7KaCJSdT2ZmJnv37uXxxx/n+uuvp0WLFlXarW/kyJHs3LmT77//nnfeead8ZgtAhw4dSE9PrzDe2NhY6tatW5PDESHS4vP7lS6g3p/x/PPPs3Llygr5tzZt2sRNN93E6NGjadu2LTExMezbd/4Z0Q0aNKBHjx4sW7aMZcuW0adPH8LDwwHn0sWoqCj2799f4T13dhCrTE18DoIzd1qvXr248847XXbELNOlSxeXpd8Aa9eupUuXLi59O3MM3t7ehIeHu5Rd6JJ2wzAwmUxVXt4ZGhpKnz59mDNnTqWvz7n07duXlStXMn/+fCZMmFA+nqq81meP8XITGl61oFJV6/0RZ2948fXXXxMXF3fOgDE485qdPHmSW265BYBhw4ZhsVjOuRmHkvm7N80oE7d2bWA9Pm3tnOadVC+OdVlp9A6OJNLiQy9gQClk26FtZCzExfJzYQ7pxQW8dGQ372f+xsCg+gwObYhhQFJEHFa7nfXZRxm4y7kNdB3vSHz8GkFuCtklp3Ob+fk1pY5/E46nZWAYBl4+9XE47JSWFsJZWwGYzF6YPbwJbzCAjN8+oqS4iDx7Kc1++IRiax69wlqQ4t8BDIPhgVY+t5562zocrMrYy8BGzTAZBp8Vwqx86GqBRwOcVY7Y4MdTE9heyIUH/SHcDN9bodAB+0vhsB16ejlnlHkbzvJEC5ccs2Eiuo4fj8V04tO8TL47cYiue/5DwxOnlzKUWOGdlacel+Tx3Q9LCY7uSfpvX+Flc86l8ynJpX9JJt/71ufB+gk0yt3Fvv3J5df4/HMr27fB04+AtdR1ivxvv9loEQeZJyEkqD7tW9/JF5tnU1ySz+6fYfepiYlvvZ9H24QIxo5MxzAqT/wq1a95kxjiG0cz72FThQ03hnSLxsfXn0+3ZdZ6niipqFvL1jQIrcvhzOOV5hMygAZ1w+jWsnW1tz137ly6du1K586dmTZtGm3atKG0tJS1a9cyb948l+VSubm5pKenY7VaOXDgAEuXLuX111/nueeeK/9jpk+fPjz00EOMHz+e++67D7vdzvPPP4+Hhwe9evWq9v5Xl+DgYEJDQ3nttdeIjIzk0KFD/Otf//rd86Kjo7nmmmv461//is1m48Ybbyw/1rt3b7p06cKQIUP497//TXx8PEeOHGH16tUMHTqUq666qiaHJFe4boHhNLD4cLik4NyfK14+dAsMr/G+tG7dmlGjRvHyyy+7lMfFxfHOO++wefNmgoODeemllzh69CgtW7Y87/VGjRrFE088QUlJSYW8S08++SQTJkwgMDCQ/v37U1xczJYtWzh58iQTJ06s9HrV/Tm4c+dOrrvuOvr168fEiRNJT3fO1jebzeU7Td5zzz3MmTOHhx9+mKSkJJKTk1m+fDmrV6++sBf3dxQXF5e3f/LkSebMmUNeXh6DBw+u8jVeffVVunbtylVXXcXUqVNp06YNJpOJ7777jp9++omOHSvmKwbnZ+CqVasYPHgwdrudOXPmXNBrfblq16kb4RENyDh6uPI8ZYZBvYgGtOtUM7tZgzNlwMSJE/n73//O1q1beeWVV8p3WAXnl1rp6emUlpaSmprKe++9x8yZM/nHP/5Rfq8uy3N27733kpOTwx133EF0dDSpqam88cYb+Pn5uVxT3Iv+WpArRpSXD7fXa+pSFn3WOyDOO4A47wC6BUVgc9gxG66TLj3MJm4IqU9y674csxbTOrAxJsMg8bsd5XWC6iZyb0QcxYaZr3yHsd9mxnRqtlppiXPZkJ8liL5Rndhqr0OpxTlroLgwA/+Q1mQd+xZPrxCK8p0zYFLww2FydvTBXDN5dgcYBjlZu5l/Yjs/eETh6RlAqg1KgR+s0MwDbvaBM9PT/mqDtked89nKJqK9W+g8Z1AdmBcMG8Ig1w5xrqtzLimGYbCh7QB+O7yVRdtmkmGY4IxEvFt+AOup9GWlpcWcPPg5ZfPFHIaJq1rfxp2hkdhshXSKas6SLyvONMovgOJiSBoO/1llJjvXOf32i68Seev9z8nNgxLrYXbv/Yjiksq/XfxhVx7ZORsIChxQza+AnI/JZOKj79K5Y3AHDv/qmo+lID+Xa+MthNStR0RUQyZPX0xhQT7RsS3w8b38coC4E7PZzOy7xzPs+ScxwOWP2rJ5WbPGjjvvN8F/VExMDFu3buWZZ55h0qRJpKWlERYWRseOHZk3b55L3SlTpjBlyhQsFgsRERFcffXVrFu3ziUA1rx5c1auXMmTTz5Jly5dMJlMtG/fnjVr1lzSSzdMJhNvvfUWEyZMoFWrVjRr1oyXX36Znj17/u65o0aNYty4cdxxxx0uy5AMw+Cjjz7iscce46677uLYsWNERETQvXv3Ckm8Raqb2TAxu2lnhu35/NyfKzGdK/xbr6ZMmzaNt99+26Xs8ccfZ//+/fTr1w8fHx/+9re/MWTIELKzz7+x1LBhw7j33nsxm80us7gAxo4di4+PD9OnT+ehhx7C19eX1q1b88ADD5zzetX9OfjOO+9w7Ngxli5dytKlS8vLGzduXJ4ovUmTJqxevZp//vOfzJ49mwYNGvD666/Tr1+/8479Qp352evv70/z5s1ZsWJFlT7byjRt2pRt27bx7LPP8uijj5KamoqXlxctW7bkwQcfZNy4cec897rrrmP16tUMGjQIh8PBnDlzqvxaX67MZjP/nDKLR8f/xbkK5Mxg2anZ1g9Mnlkj9/Qyd9xxB4WFhXTu3Bmz2cz999/vspnE/PnzmT9/PhaLhdDQUDp27Mjbb7/N0KFDXa4zbtw44uPjmTFjBkOHDqWwsJDo6GgGDRp0zsCzuAfDUV0ZHC9ATk4OgYGBZGdnExAQcLGbF6l2rxzew7TUXRT5NCaobidu8YZZQdDxKGSciuE4HA7yc/aRnbkV/+BWBASfnhlRmJ9Kzokd1Gt4Q3ndE0c3UFyQRmBYIn7+TTBwDXzl5+6nKO83QiN7ALj8I/CfvjDx1FvrrQLnzLJ1hbDDBvf7PMkIv/n0O/Yj2Y5gAFp4wKdhNfby1Jijx/fx1EvOXYiO+TcktW4CB8I70Dx1Ay0Pf1mhfp/rnqBOSCyP/LgKm9nCtIgYbEXZfL55VnkdB2DDhAd2PDxgU9xfSPdrTGrdVkzakERRfuW7Y/l4e1NwxjT++Bi4N2kAJtNH1Tpmqbq0w4e468aryDp57iTxADHxCbyxcisenpdwhPgSUdP373c3b+T++XNdEvs3rBvGrLHjuPmamvvmWUTc17vHf+X+X751Sezf0MuHWTGdublu41rsmYh7W7/mXWZOe8AlsX+9yIY8MHkmvfrffJ4z/5yePXvSrl07Zs2aVWNtiPtToEykmlgd8HQOpNthsj808ID5eTAzD2JNsO3UWjCbrRiz2QsPOL1vo8NGceFRPD0DMXv+/lK9sl1YHKUFYPausCNLb0/47NSSyzPbAfCkiPnBNzPmpDOAE2DAGyHQ8RJcblkVn29+md0pn5HZ7q9Myc4C4NpdS2l76LPyOoZhYmDvJ2nbcihPzemIyVbM0Xa9GFB3H/u/O0xePgT6w6amkwlN+5Kww+sBCAqArFNpznY27UOrX9aWX9PDDG0TIC0DjqTD7cPuYOM3mzmWmcKkeyAsFAyjPnAAUACmNq1dtZzJE0ZApYtvnG645U7CwiMZ8deJBIUod9K5XIz7t81mY+PuH0k7cYLIkBC6tWxdo986i4j7sznsbMzOIK2kgEiLc7nlxZpJJnIls9lsbP9uI5kZaYSGR9KuU7cav6crUCbVQYEykYtgSwkMzXQ+NuP8c/1//OC5vNMZyzyA9cFFDM+2cNhuwseAggt8d3oC11pg/bk3SwJgvO+z7CrtzT5rZ54OhD51LqydS9XcIz+xec2DBKZ8hOlUUMTL4sctg2ZzOG076cf2sDflM8xmZw4yfz84egyemgkx0QZLOm7g2v92xzh1rsUCZRtPmc1w5o7Stw+DxA5gtcLTs8DPF8aOguUfOoNuN/SGr7+H3LzODOm/CbNZK91r23tv/n9eePwf563T+do+vPzGJxepR5cf3b9FRETkUqZAmVQHBcpELpKVhfBLKQz1dibNDzfD2iL4Vzb4GDA7EDp4wUm7M89YhAGv5sNnxZB76l3qBRT/TjsmXJdoVuZh/0Lu86u4nbU7uP9xCza7tfy5xdOXEuvpPGJxTeDQYXj+MfD0hLx8+FfZZkwWf7J9GxJ4cvfvtzMW4pw7g/PiPDj4G9w0AD5ZD0Wn/ieVfbp2bDOCu4a/WR3Dk2pwz/AebP924zmPt73qWl5asApff92fzqb7t4iIiIi4OwXKRC5xW0vg5kznzLOeFvi8BOpwOiF/MHCykvPODqrd6gXFBrS3wJ0+4GFUcpIbmLdkELv2nnvHpCcmwd5f4FAqNI2GzVvgl4Onj1ssvpScI0H/maIioF9P59LLNcnOoFtiO/jyu4p1m8X25r6ktRUPSK2xlpTQq3UApdZzT798YMosho+ZcBF7denT/VtERERE3J0CZSKXgT1WOGGHrl6QZwe7AxYWQEMz3OIDKwrgkWxnQv8QAwqB+cGQXAz/Lx9iPeDjulDHDYNjJSUFLFlxO6lp27m28z00j+3DC3M6cva8OgeQ6VefVj6HSewAu/fBz/svrC3DgGaxYCuFnw+4HmsZB6V22PcLeFkgKNC5rNPHO4QpE/fi56u8V5ea/LxcDvy8i7WrlrN8ySs47LYKddZsyVDOsjPo/i0iIiIi7k6BMhE3d9LuTNhvdsMgGcB3299kyfJRVa6fXrcNbSjG4ulDatq2U6UGXl4BlJYWYLfbcDhOB9nq1AmmuDi7vMy7DtzYL5G1X/zAiawil2v36ALfbYd77oQlb0NOnsHYUbeQEN8duO9PjlRq2o9bv+buYdecUWLw6bbjBAQG11qfLjW6f4uIiIiIu9N2LyJuLtjkvkEygIZR7ckIaca7iY+yscXI8+xr6FTv+A669ZrMQ+O+wcc7FIAijzr8b4cJFGLC4bDTud0dGF6BOAwzRUUncTjseHg4dzwoLYWP131TIUgG8MVXzt0uU49A5kmwWh1s+/EdYALwaPUOXKpd6w5X8+m2EzRr2YFGMc2YteRjBclERERERK4w2oZNRC5rEeEtONTzOdIKc0gLaUbT9O9pkP0LdntpeR0HBh51W5CVc5hVnSbxal4p/RcOpmmhcyvSTP9GHAtqygm/+kRk7ye7bgvmXHcdCQfX0XPP/wJQWuoMjFlLwZrnvK6XBYpLwGQyYbc7Z5wdOgztWzl3wSwqhg6ty3qx4aK8HvLnBAQGsWTVltruhoiIiIiI1BLNKBORy15CHR8ALNYC4v3qMm7MGsxmS/lxAweFeem83etFTgQ0AmBPcPPy4wFFmbSzFRCeexgAR0keZmBvg2tJDWnmvLanL90TwcMMdw2HR+9zJvRv0hBMxumlmg6HwftroLAIxt8FzWMNbDYTeQV31/TLICIiIiIiIn+SAmUictmb0bA1f9kykxFfPgYn9rH4reHYbK67GaZ716PY5JxEay4tJjb9W6xmCw7Av/A4i8MiMdmd+4T++s0rLA0OpPeeN4k6sQ+Adgm92PANtIiDjm2gfiQMuA6KSiAkyNmGj3cwnFr8abPB7Pmwa6+DZ1+288n6by/GSyEiIiIiIiJ/ggJlInLZCw6M4qXbFhMf25s3Wo3lrRa3U2Kug3MfUKdm1iw62gqom3WAv64dR653GEu7v8D7Vz+Gf2Bj1m+aidnknIVWXJzDl28OJfbwl5hOBb6+/3EVAEeOQkGh85r5BdCpHURFDMNs8qSg8GSFvq3dAJP/Cf17vQ9UzGsmIrUvPT2d++67j5iYGLy8vGjYsCGDBw9m3bp15XWio6MxDAPDMPD29iY6Oppbb72V5OTkCtebMGECHTt2xMvLi3bt2p237ZSUFPz9/QkKCqrWMU2dOhXDMOjfv3+FY9OnT8cwDHr27FmtbYqIiIi4A+UoExG30CCqHWsiu5Hm4dyJb39ER5of3lx+vDAvjdt2L+bXVOfMrlaH1nHVLyvZ0nQQqSX55B6smEPM4bCVP7adeph5Eqa9BAH+cCS97Og75+yXr0/Z7zTgCBDzR4cockWwO+BwJuQXgW8dqB8KphrckOTgwYN07dqVoKAgpk+fTuvWrbFarXzyySeMHz+en376qbzutGnTuPvuuykpKeHgwYMsXbqU3r1789RTT/HYY4+5XDcpKYlvvvmGHTt2nLNtq9XKiBEj6NatG5s3bz5nPYAxY8YQHR3N1KlTqzy2yMhI1q9fT2pqKg0aNCgvX7hwIY0aNarydURERESuJJpRJiJuo0dgOACe1gLqH98FZ+2BWRYkA/C25mPgoNMvKwkoPH5B7eTlnxkkO83H25tWzSEuBjw9ncn+b7gOrKX1gHtRkEzk/FKOwMJP4b+bYM33zt8LP3WW15Rx48ZhGAbffvstt9xyC/Hx8SQkJDBx4kS+/vprl7r+/v5ERETQqFEjunfvzmuvvcbkyZOZMmUKe/fuLa/38ssvM378eGJizv+ef/zxx2nevDm33nprjYwtPDycvn37smTJkvKyzZs3c/z4cQYOHOhS1263M23aNBo0aFA+E27NmjXlxw8ePIhhGLz77rv06tULHx8f2rZty1dffeVynf/+978kJCTg5eVFdHQ0L774Yo2MTURERKSmKFAmIm5jSuubGL3xf7hr3f34F2eVl3t41Km0flkY7ezJKh4eBn6+4RXqx0b3ACDA73RZgL8/9SPB4gkFhYXs/AlSj8Bdt8H0KRASXBdPj1+BV/74wESuAClHYNV3kHfWCuW8Imd5TQTLTpw4wZo1axg/fjy+vr4VjldlOeT999+Pw+Hggw8+uKC2k5OTWbFiBXPnzr2g8y5UUlISixcvLn++cOFCRo0ahcVicak3e/ZsXnzxRWbMmMGOHTvo168fN954Iz///LNLvccee4wHH3yQ7du3Ex8fz4gRIygtde4y/P3333PrrbcyfPhwfvzxR6ZOncrkyZNd2hcRERG51ClQJiJuw2z2pLHZhKfD6lLu5xN2Vk3jjP+CYZhdjpaWOsjLzwCcSydjo53lKQe/AMBkhjYtwc8HcnJzOZwGJWc0WVhksGptc1asbM/xzLcBr2oYnYj7sjvg8x/PX+fznc561SklJQWHw0Hz5s1/v/I5hISEEB4ezsGDB6t8TmZmJmPGjGHx4sUEBAT84barYtCgQeTk5LBhwwby8/NZvnw5SUlJFerNmDGDRx55hOHDh9OsWTNeeOEF2rVrx6xZs1zqPfjggwwcOJD4+HiefPJJfv31V1JSUgB46aWXuP7665k8eTLx8fGMGTOGe++9l+nTp9foGEVERESqkwJlIuI2TCYz4+78mMiwVmeUeXD7XxbjOm/M9a/tslxkhlHxI9Fmg5SDrmVZ2bBjN+QVuJYbwM033MArz3Sk5zXBbPxmG7NeH0TmybMuICIuDmdWnEl2trxCZ73q5HBUT+TN4XBgGFVPpHb33XczcuRIunfvfs46y5Ytw8/Pr/xn2bJlPPvssy5lGzdu/N22PD09GT16NIsWLWLFihXEx8fTpk0blzo5OTkcOXKErl27upR37dqVPXv2uJSdeW5kZCQAGRnOLxb27NlT6TV+/vlnbDYbIiIiIpcDJfMXEbfyw653STu2s/y5YZh4Y8UdeHp4Yy0tOM+Z4HDYK5QVFTt/m0xgr3i4XFS9NmAU0LPrRxgGdO5g8OZ7YLUWkpt3lNDg6D8yHJErQn4VN4Star2qiouLwzAMl4T9FyozM5Njx47RpEmTKp+TnJzMhx9+yIwZMwBnoM1ut+Ph4cFrr71GUlISN954I4mJieXnPPLII9SvX58JEyaUl9WvX79K7SUlJZGYmMjOnTsrnU12ITw9PcsflwUH7ef7cBQRERG5zChQJiJupW5oU5fnpbYSvvVrjI9nIA0zd+Pp4Y2npw8FheefmnLSpx5ZvvUwBQfRLmMD2dmV1zvhF0ni9RH0CX6WeUsGkJYO9SPBZmtL24QYGtW/iuiGiZWfLCKAc3fL6qxXVSEhIfTr14+5c+cyYcKECnnKsrKyfjdP2ezZszGZTAwZMqTK7X711VcuM6w++OADXnjhBTZv3lwe/PL398ff37+8jr+/PyEhIcTGxla5nTIJCQkkJCSwY8cORo4cWeF4QEAAUVFRbNq0iR49epSXb9q0ic6dO1e5nRYtWrBp0yaXsk2bNhEfH4/ZbD7HWSIiIiKXFgXKRMStdGo3Cl/fMD74+GEOp+9gf3g7Pmv7NwBu/PYFGmbuwVpaCIDZbMFmK6n0OimRnen0y0o4BkaTIOxZWZXWC8lLY2LhkyxjA74+YUx/9Ri33jSWa66azd2jfGpkjCLupn4o+NU5//JLP29nveo2d+5cunbtSufOnZk2bRpt2rShtLSUtWvXMm/ePJelh7m5uaSnp2O1Wjlw4ABLly7l9ddf57nnnnMJYKWkpJCXl0d6ejqFhYVs374dgJYtW2KxWGjRooVLH7Zs2YLJZKJVq1bUlOTkZKxW6zkDfw899BBPPPEETZs2pV27dixatIjt27ezbNmyKrcxadIkOnXqxFNPPcVtt93GV199xZw5c3j11VeraRQiIiIiNU+BMhFxOy3j+tIyri/W0mL++tMXhBz6lgFb5+BjzXep5+nhjd1urTRPUduDn5LYAZo2huUrs8rLDQxiY3rx8/5k7MDuhr3wNDvIyZhDXn4uAN9u+5lrrlKQTKSqTAb0bO3c3fJcerZy1qtuMTExbN26lWeeeYZJkyaRlpZGWFgYHTt2ZN68eS51p0yZwpQpU7BYLERERHD11Vezbt06evXq5VJv7NixfPHFF+XP27dvD8CBAweIjo6u/kFUQWW7ep5pwoQJZGdnM2nSJDIyMmjZsiUffvghcXFxVW6jQ4cOLF++nClTpvDUU08RGRnJtGnTGDNmzJ/svYiIiMjFYziqK5PtBcjJySEwMJDs7Owa3+1JRK48J7IO8XHyNHy9Q9jy86fsLciiXs6vF3QNTw94cSqs2wgffHK6vGnj7vzy6wb694IVm4PZH30Njzb9lGtaW/l+B7z3MYQENWbawwerdUwil4Kavn+nHHHufnnmzDI/b2eQLDaq2psTEREREalAM8pExO28s3ICO/Z8UP683qnfhmGqNGE/QL0wOHrs9HNrKWSehFbN4dMvoLDImdC/aZNr+eXXDcQ2gYFFJ/l6y2o+2gtfbYZ774KVn3px+1/eqMHRibiv2CiIiXTubplf5MxJVj+0ZmaSiYiIiIhURoEyEXE7fn7hlZaHhcSSkbmvQnliB0g7evq5lwU8PGDmaxDdABwOGDLADI4XiIpoxTrzDOYsLKF+BJRNyc3JgTXJ0KfHI8Q16V4DoxK5MpgMaFi3tnshIiIiIlcqU213QESkuv1l0Mu0Tbi5QnllQTKAuiFw6LDzcR0vsDvg4XGQlw879kBRMbz/sY2dP61k8dsjyjcAOJzuXKLZpiX0uOYW6kdNp2/P/6mxcYmIiIiIiEjN0owyEXE732x7g9zco3h4eFFaWkLZvC9/P8jNq1j/u+0Q08gZLCu1QWkpPDGjYr0Dh77GZi92KSsohC4doXWLB4Grq30sIiIiIiIicvEoUCYibmPV2imsWf8M4MxDZhgmTi+OdM4Wy8t3LqU8U8ZxyKjC9c8OkpUJD5uEgmQiIiIiIiKXPy29FBG38dnG6ZQFyYAKifuPZVYMklVFaLBzxtmZLJ7O3wH+kRxJ74LdbrvwC4uIiIiIiMglRTPKRMRthIU0JS1jFwAWTz9KrJWss7xAEeHw8HhnYGzdRsjOhUG9nb+3/ujJqrVHWfDmMHp3e4ghA/79p9sTERERERGR2qNAmYi4haycI+VBMqBagmQAkeGnZ4/FNAaLBZ57BY6fgG6dg3A4jgGQefJgtbQnIiIiIiIitUeBMhFxC3W8/DGbPLHZrRd8rgPY0PJ2MgIa0+mXD4k+tgMAP1/nssv0DGdus7c/hKwcKCx0npeW0Zy+PcaSefIAN/Z7rhpHIyIiIiIiIrVBgTIRcQulpcV4eHhhK7nwQNmxgMbsatgTw2Hn6/i/lAfK8vLhs43OnTC7Xw3Zp4JkIcFNyM1L59rE8XRsc1t1D0VERERERERqiQJlIuIW/vPe3zhusvBZ4r8wHA76/PAavsUnq3RuYEEGY5Lvx8taQH6d4ArHc/MgvC50audB4wYL6dz+9uruvoiIiIiIiFwCtOuliLiF4pJ8djXsxZGQ5hwObcGuhj2qfK5XaSE+1jzM2AkoynQ55mGGm/pDcQns/9VGWN346u66iIiIiIiIXCIUKBMRt9C189+IyErBcNgx7DYislIq1KnjBSFBF3bdUhvMng9TZ8BvRxzMWdiH4uLq2ShARERERERELi1aeikibiE8NJ7oYz8wcoNz6WVg4bEKdYqKnT8XKvOMFZzFxbkUFufg5eX3J3orIiIiIiIilyIFykTELUSEt8AwzAQVZFQ4VmAJoNTkQUDRCWeBgXOrS8AwwOEw4+lZB6s1H4AA//rk5B52uUZUvdaUWAvp1fUBggKianIoIiIiIiIiUksUKBMRt2A2e+Dl5UdRUbZLeXpgDB8kPoINM0N+eImovAP8GtGBq7I2MXYkvLIA8gpstEsYSklJPj/sfq9CkAxg4t83U6eOZpGJiIiIiIi4MwXKRMRt1A2OITVtm0uZp62YkRsexbs4hxJPb+wlRdTf/w0JXaDECnkFznrf73gLu720wjUtFl9uuWGmgmQiIiIiIiJXAAXKRMRt1AtrViFQFpp3enaYR0kuAHbgxz0QGgKtm8PR41EcP3GMWwaC3Q5bdsCRdC+aNEzk73esxLtOwMUchoiIiIiIiNQSw+FwOC52ozk5OQQGBpKdnU1AgP4AFZHqUViUzbSXmpGbd/S89Rw405SVGX/XJzgcduKa3ICnp/Mj8YuvnqRHlyk111mRy5Du3yIiIiLi7ky13QERkeriXSeQB+7+4nfrGWc9/993xtCsaW88Pe8DIL+gFz26TK6BHoqIiIiIiMilTIEyEXErpbYSzCZLleqWTafNzUunuCQPmA1Y8fVJpmI4TURERERERNydcpSJiFtZ9NZwbPYS0oOasqHlaILz0rjuxwWYHbYKdctCYddd+yA+3kGnnuljUURERERE5EqlGWUi4jb2/pJMesZuAL6NG8qxwCbsq38Nv9Vtdc5zPD196N3toYvVRREREREREbmEKVAmIm5jb8pn5Y8jTqYAYLEWEHLGzpf1I0/X79B6BFP++RP+fmEXrY8iIiIiIiJy6dIaIxFxG4H+UeWPO6e8T5OMbfgUZeFnzcYBWDxhUB+DVZ+2oU3Lm7jh+qkYhnKRiYiIiIiIiJPhcDgcv1+teml7eRGpCbl5x3hmVivyCjIqHDMMmHQP+PsNIzR4RS30TuTyp/u3iIiIiLg7Lb0UEbfh7xfGM4+mEhzY6IxS54wxX58gggLfJjR4ee10TkRERERERC55WnopIm7FbPbkkfu28vwr7cjKTqXXNffTPK4PTRpdc8bOliIiIiIiIiIVKVAmIm7HzyeUxx/YTXbOEeqFNavt7oiIiIiIiMhlQoEyEXFLdbz8qaMgmYiIiIiIiFwA5SgTERERERERERFBgTIRERERERERERFAgTIRERERERERERFAgTIRERERERERERFAgTIRERERERERERFAgTIRERERERERERFAgTIRERERERERERFAgTIRERERERERERFAgTIRERERERERERFAgTIRERERERERERFAgTIRERERERERERFAgTIREREREREREREAPGqjUYfDAUBOTk5tNC8iIiJ/QNl9u+w+LiIiIiLibmolUJabmwtAw4YNa6N5ERER+RNyc3MJDAys7W6IiIiIiFQ7w1ELXwvb7XaOHDmCv78/hmFc7OZFRETkD3A4HOTm5hIVFYXJpOwNIiIiIuJ+aiVQJiIiIiIiIiIicqnR18EiIiIiIiIiIiIoUCYiIiIiIiIiIgIoUCYiIiIiIiIiIgIoUCYiIiIiIiIiIgIoUCZyRerZsycPPPBAhfLFixcTFBQEwNSpUzEMg/79+1eoN336dAzDoGfPnhWOpaamYrFYaNWqVaVtG4ZR/hMYGEjXrl1JTk4uP75hwwYGDx5MVFQUhmHw/vvv/5EhioiIiIiIiFwwBcpE5JwiIyNZv349qampLuULFy6kUaNGlZ6zePFibr31VnJycvjmm28qrbNo0SLS0tLYtGkTdevWZdCgQezfvx+A/Px82rZty9y5c6t3MCIiIiIiIiK/Q4EyETmn8PBw+vbty5IlS8rLNm/ezPHjxxk4cGCF+g6Hg0WLFnH77bczcuRIFixYUOl1g4KCiIiIoFWrVsybN4/CwkLWrl0LwIABA3j66acZOnRozQxKRERERERE5BwUKBOR80pKSmLx4sXlzxcuXMioUaOwWCwV6q5fv56CggJ69+7N6NGjeeutt8jPzz/v9b29vQEoKSmp1n6LiIiIiIiIXCgFykTkvAYNGkROTg4bNmwgPz+f5cuXk5SUVGndBQsWMHz4cMxmM61atSImJoYVK1ac89oFBQU8/vjjmM1mevToUVNDEBEREREREakSj9rugIhc2jw9PRk9ejSLFi1i//79xMfH06ZNmwr1srKyePfdd/nyyy/Ly0aPHs2CBQsYM2aMS90RI0ZgNpspLCwkLCyMBQsWVHpNERERERERkYtJgTKRK1BAQADZ2dkVyrOysggMDKxQnpSURGJiIjt37jznbLI333yToqIiEhMTy8scDgd2u519+/YRHx9fXj5z5kx69+5NYGAgYWFh1TAiERERERERkT9PSy9FrkDNmjVj69atFcq3bt3qEtAqk5CQQEJCAjt37mTkyJGVXnPBggVMmjSJ7du3l//88MMPdOvWjYULF7rUjYiIIDY2VkEyERERERERuaRoRpnIFegf//gHc+bMYcKECYwdOxYvLy9Wr17Nf/7zH1auXFnpOcnJyVitVoKCgioc2759O1u3bmXZsmU0b97c5diIESOYNm0aTz/9NB4ev/+Rk5eXR0pKSvnzAwcOsH37dkJCQmjUqNGFDVRERERERETkAmhGmcgVKCYmhg0bNvDTTz/Ru3dvEhMTWb58OStWrKB///6VnuPr61tpkAycs8latmxZIUgGMHToUDIyMvjoo4+q1LctW7bQvn172rdvD8DEiRNp3749U6ZMqdrgRERERERERP4gw+FwOGq7EyIiIiIiIiIiIrVNM8pERERERERERERQoExERERERERERARQoExERERERERERARQoExERERERERERARQoExERERERERERARQoExERERERERERARQoExERERERERERARQoExERERERERERARQoExERERERERERARQoExERERERERERARQoExERERERERERARQoExERERERERERASA/wPG8/eaO6lpBwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Silhouette-Score: 0.11356603354215622\n", + "Davies-Bouldin-Index for: 4.5638966789318545\n" + ] + } + ], + "source": [ + "umap_and_scores(test_data, LATENT_NAME, 20)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# PCA representation of latent embedding\n", + "# Clustering by all call_types\n", + "import scanpy as sc\n", + "from sklearn.decomposition import PCA\n", + "from sklearn.metrics import silhouette_score, davies_bouldin_score\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Input: AnnData Object, 'embedding name', n_components\n", + "# Silhouttte Score: Ranges from -1 to 1, higher values indicate better cluster separation\n", + "# Davies-Bouldine-Index: A low index indicates that clusters are well separates\n", + "def pca_and_scores_for_embedding(adata, embedding_key, n_components=10):\n", + " embedding_data = adata.obsm[embedding_key]\n", + "\n", + " pca = PCA(n_components=n_components)\n", + " pca_result = pca.fit_transform(embedding_data)\n", + "\n", + " adata.obsm['X_pca'] = pca_result\n", + "\n", + " plt.figure(figsize=(8, 6))\n", + " sc.pl.pca(adata, color='cell_type', size=20, ncols=1)\n", + " plt.show()\n", + "\n", + " pca_coords = adata.obsm['X_pca']\n", + " labels = adata.obs['cell_type']\n", + "\n", + " # Calculate Silhouetten-Score\n", + " sil_score = silhouette_score(pca_coords, labels)\n", + " print(f'Silhouetten-Score: {sil_score}')\n", + "\n", + " # Calculate Davies-Bouldin-Index\n", + " db_score = davies_bouldin_score(pca_coords, labels)\n", + " print(f'Davies-Bouldin-Index for {embedding_key}: {db_score}')\n", + "\n", + "# Example\n", + "# pca_and_scores_for_embedding(adata, 'latent_embedding_adt_3', n_components=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Silhouetten-Score: 0.24392212392088705\n", + "Davies-Bouldin-Index for latent_omiiwae: 2.6496585439434286\n" + ] + } + ], + "source": [ + "pca_and_scores_for_embedding(test_data, LATENT_NAME, 10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compute metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "LABELS_COLUMN = \"level1\"\n", + "X = test_data.obsm[LATENT_NAME]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Silhouette score" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "silhouette_score1 = sklearn.metrics.silhouette_score(X, labels=test_data.obs[\"level1\"])\n", + "silhouette_score2 = sklearn.metrics.silhouette_score(X, labels=test_data.obs[\"level2\"])\n", + "silhouette_score3 = sklearn.metrics.silhouette_score(X, labels=test_data.obs[\"level3\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Silhouette score for level 1: 0.29312247037887573\n", + "Silhouette score for level 2: 0.1856389343738556\n", + "Silhouette score for level 3: 0.25174757838249207\n" + ] + } + ], + "source": [ + "print(f\"Silhouette score for level 1: {silhouette_score1}\")\n", + "print(f\"Silhouette score for level 2: {silhouette_score2}\")\n", + "print(f\"Silhouette score for level 3: {silhouette_score3}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'Series' object has no attribute 'codes'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_11704\\3608699213.py\u001b[0m in \u001b[0;36m?\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtest_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mobs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mLABELS_COLUMN\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcodes\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\pandas\\core\\generic.py\u001b[0m in \u001b[0;36m?\u001b[1;34m(self, name)\u001b[0m\n\u001b[0;32m 6295\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mname\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_accessors\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 6296\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_info_axis\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_can_hold_identifiers_and_holds_name\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 6297\u001b[0m \u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 6298\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 6299\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mobject\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__getattribute__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m: 'Series' object has no attribute 'codes'" + ] + } + ], + "source": [ + "test_data.obs[LABELS_COLUMN].codes" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For n_clusters = 7 The average silhouette_score is : 0.29312247\n", + "For n_clusters = 18 The average silhouette_score is : 0.18563893\n", + "For n_clusters = 40 The average silhouette_score is : 0.25174758\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABZoAAAKgCAYAAAAS1si3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3gUVdsG8Hu2b3qvhCSEltCl11BEmlKlSlUUpSOiYgMsoPIpIAhiAwULRQGRJkgH6b2DhBZaKOnJbnb3fH/kzZhN3ZCyIbl/XLnYnTkz88zszOyZZ8+ckYQQAkREREREREREREREj0hh7wCIiIiIiIiIiIiI6PHGRDMRERERERERERERFQoTzURERERERERERERUKEw0ExEREREREREREVGhMNFMRERERERERERERIXCRDMRERERERERERERFQoTzURERERERERERERUKEw0ExEREREREREREVGhMNFMRERERERERERERIXCRDMRlTqLFy+GJEnyX2atW7eWhw8dOlQefuXKFatptm/fXrJBU6k0depUeZ8ICQkp0WUPHTpUXnbr1q2LbTm3b9/GsGHDEBgYCJVKJS9z9erVxbZMevzldi4tL/L6nqHyq7TsF6UljtKgsNuirG9Le9ZziIiIcsJEMxEVu19//RUdOnSAr68v1Go1XF1dERoaitatW2PcuHHYtGmTvUMs1WxNopf3xFF5JITAs88+i8WLF+PmzZswm832DgkAsH37dqt9dvHixVbjHz58iEaNGsnjFQoFFixYkOO0kiSha9euOS5n06ZN2cpy3388lPXkD1FpkvW8euXKFXuHVCR4HrE/NvSwTda6Sm5/xdkwgYiopKjsHQARlW2DBw/GkiVLrIbFx8cjPj4eV65cwY4dO3D16lV06NBBHt+wYUPMnDmzpEMlKlL9+vVDzZo1AQBBQUHFsoxr165hz5498vunn34aLVu2hEKhkJdd2sTExKB9+/Y4fvw4AEChUODbb7/FsGHDcp1m3bp1uHz5MipVqmQ1fM6cOcUaK5Vd/J4hejzwWKXyhD+YEFFZwEQzERWbjRs3WiWZ69evjw4dOsDJyQkxMTE4cuQI/vnnn2zT1ahRAzVq1CjJUImKXMeOHdGxY8diXcbVq1et3s+ePRthYWHFukyj0QghBLRabYGnvX37Ntq1a4czZ84AAJRKJX788UcMGDAgz+ksFgvmzZuHzz//XB524cIFbNy4scAxUPkWHx8PFxcXfs8QPSZ4rFJOClMXsYfcfiz5999/8dVXX8nvO3XqVFIhEREVG3adQUTF5q+//pJfV65cGfv378dHH32EyZMn4/PPP8f27dsRExODSZMmWU1XVLdCrlq1Ck2bNoWDgwPc3d3Ru3dvXL9+Pceyhw8fxuDBgxEaGgqdTgcnJyfUrFkTEydOxI0bN7KVDwkJkeObOnWq1bj8+suLj4/HjBkz0LhxY7i6ukKj0aBixYoYOnQoTp8+nW05oaGhVsPatGljdYtdxvJ27Nghl/nhhx9yvU3WYDBg3rx5aNWqFTw8PKDRaODv74/evXvnmPjPy7FjxzBy5Eg0btwYgYGB0Ov10Ol0CA4ORt++fbF79+5s02TdPnFxcZg0aRKCg4Oh0WhQqVIlTJ8+HUKIQi8rJ/Hx8XB2dpZj+Prrr7OV6d27tzw+c6V/165d6NGjBwIDA6HRaODk5ISQkBB06tQJU6dORVxcnFw2rz6aT548iYEDByIkJARarRZ6vR4VK1ZE27ZtMXnyZERHR+e7HpIkITIy0mpY5cqVczxuCrp/Z+2G5dSpU+jevTs8PT2h1Wpx9uzZfOPL6saNG4iMjJSTzGq1GsuWLcs3yaxQpFdVvv/+eyQlJcnD586dK+8jSqUyz3ncuXMHb731FurWrQtnZ2fodDpUrlwZo0aNwrVr17KVL8n9OikpCe+//z6eeOIJODs7Q61Ww8fHB3Xr1sWLL75Y4GT6wYMHMWzYMFSuXBkODg5wcnJC1apVMWzYMPz777/5Tp/fLfZ5nfv++OMPdOzYUe4mycXFBWFhYejevTtmzJgBi8Ui32adtQV75mVmne+uXbvQr18/VKxYEVqtFi4uLmjatCm+/PJLpKWlZVuHrN22rFmzBs2aNYOTkxMqVqwIoGDPArh48SL69+8PLy8v6HQ6PPHEE1izZk2O22/Xrl1o3bo1HB0d4eHhgT59+iAqKqpQfbYX9vgtSPy5Kci5ryiOn1u3bmHIkCHw8vKCi4sLnnnmGVy4cAEAcOTIEXTs2BHOzs65frdn3Y8vX76M2bNnIyIiAjqdDoGBgXj11VeRkJBQoO1QlN+fQPqPhf3794eHhwccHR3RqlUrbNmyJc9ptm/fjhdeeAFPPPEE/P39odVq4eDggMqVK2PYsGE4efKkVXlJktCmTRurYaGhodm6GzKZTHj33XfRuXNnhIWFwc3NDWq1Gp6enmjZsiXmzp2b4/GWk+PHj1tt/8zn2bfeekse/uqrr8rD79y5YzXN/v37AeR8rD7KeSRDWloaPv30U1SvXh1arRYVKlTAa6+9BoPBYNO6AcVzjGV148YNvPHGG6hXrx5cXFyg0+lQsWJFdO/eHZs3b7ZpHnl1YVUUdRRb6qiZXb58GWPHjkV4eDgcHR2h1+sRERGBN998E/fu3csWv611kYKcn+zltddey/Evc5dnLi4uePnll+0YJRFRERFERMVkzJgxAoAAILy8vMSlS5dsmm7RokXydFlPU5GRkfLwIUOGyMOjoqKspunQoYPV+4y/KlWqiJSUFKt5zpo1SygUihzLAxCurq5i27ZtVtMEBwfL46dMmWI1bsqUKfK44OBgq3EXLlwQISEhuS5Lq9WK5cuX57icnP4iIyOtlpfbX1RUlBBCiLt374q6devmWk6hUIjZs2fb9DkJIcTcuXPzXK4kSWLRokW5bh9PT08RHh6e47TvvvtukS4r82cxatQoeXjDhg2tpklMTBQODg7y+IzPY8uWLUKpVOYZw9mzZ+X5DBkyxOpzynD69Gmr+ef0t2HDhny3fX6feYZH2b8zH2f16tUTjo6OVtMcPXo0z9i2bdtmVX7KlCkiNDTUaj//448/bJq2e/fu8usvv/xSCCFEXFyccHZ2luPLfJxkPi8IIcTevXuFl5dXnuu/c+dOq2lKcr9u3bp1nsvq27dvnts6s2nTpglJknKd16pVq+SyuZ1Ls27/jHNHhtzOfVnP2zn9paSkZDtX5/SXeb5vvfVWnmVbtmwpEhMTrWLMOj7r551TvJll3ja1a9eW97Ws+8CWLVusplu7dq1QqVTZynp6eopmzZrleD7IT2GP34LEn5uCnvsKe/x4eHjk+D3p7e0tVq1aJbRabbZxWb/bs+7Hbdu2zTGWhg0bWk2X135R1N+fUVFRws/PL8ft07lz51zjmDhxYp7bV6PRiM2bN8vl8zveMo7/hISEfMs++eSTwmQy5btuFotFeHp6ytP99NNP8rgWLVrIwxs0aCAPX7FihTzcxcVFXk5On0lBziNZp8+tfjho0CCbP7uiPsayWrduXY7zzPgbN26cXDavOmfmabIec0VRR7Gljpph9erVec43MDBQnDlzJtftnFtdpKDnp7zY8j2W+S/r9i6o27dvW53PXnvttULNj4iotGDXGURUbJ544gn59b1791C1alXUrVsXDRs2RP369dGmTRtUrly5WJa9adMmNGzYEB06dMC2bdvkfmwvXryI1atXo1+/fgCAnTt34tVXX5VbGVasWBH9+/dHYmIiFi1ahOTkZMTFxaFXr164dOkS3N3dHzkms9mMHj16yC0Evb29MWDAAHh4eGDTpk3Yu3cvDAYDBg8ejPr166NSpUp4++23ceXKFUyfPl2ez8svvyx3jxAUFISgoCA4OTlhwYIFuHz5MgCgQYMG6Nu3rzyNh4cHAGDQoEE4duwYAMDZ2RkDBgxAhQoVsGfPHmzcuBEWiwUTJkxAgwYN0Lx583zXSavVokmTJqhbty48PT3h5OSEuLg4/P333zh48CCEEJg4cSL69u0LvV6fbfr79+/j4cOHGDx4MAICAvDtt9/KrVrmzJmDd955BxqNpkiWldno0aMxf/58CCFw8OBBnDx5ErVq1QKQ3h9wcnKyvN0yHkT39ddfyy1Pqlevjt69e0OlUuHatWs4duwYjhw5ku/2AtJbm2fMv0KFChg4cCAcHR1x48YNnDp1Cvv27bNpPjNnzsx2y+Vbb71ltY8Wxf599OhRqFQqDBo0CFWqVMG5c+eg0+lsijHD+++/L8eg1+uxevVqPPXUUzZN+9xzz2H37t24d+8e5s2bh5EjR2LRokVyS8SxY8fm2nItPj4e3bt3l/epjBaVer0eK1euxOnTp+X1v3jxIlxdXQGU3H599uxZ+cFJCoUCgwcPRtWqVXHv3j1ERUUV6KFKK1aswJQpU+T3Dg4O6NevH4KDgxEVFYW1a9faPK9HkfEwRyC9T9Wnn34aJpMJ169fx/79++WWZx4eHpg5cyYOHTqEZcuWydNkvq24WbNmANIfJJv53NehQwc0b94cd+7cwQ8//IDExETs2rULEyZMyPHOBCC9pZuXlxf69esHT0/PbHeN5OfEiRNwd3fHhAkTkJKSgm+++QZmsxlCCMycORPt2rUDACQnJ+OFF16AyWQCAKhUKgwbNgweHh748ccfsXfv3gItFyia49fW+PNS0HNfYY+fBw8eICUlBePGjUNSUhK+/fZbAOn9u/fo0QNOTk4YPXo0rl69ipUrVwLI/t2e1datW9GtWzfUqVMHGzZswMGDBwGk3wHw6aef4r333st3OxT19+fo0aNx+/Zt+f0zzzyDevXqYcOGDVi/fn2u0zk6OiIyMhK1atWCh4cH9Ho97t+/j3Xr1uHs2bMwGo0YO3asfPdIft8VGf35S5KESpUqoUmTJggMDIS7uzvS0tJw7tw5rFixAiaTCVu2bMFvv/2GPn365LluGXfc/P777wDSj8MBAwbAYDDI2x5I/35JTEyEk5MTdu3aJQ9v2bJlnneqFOQ8ktWmTZvQo0cPRERE4KeffpLrZD/99BM+/vhjBAQE5LluWRXFMZbZ1atX0bt3b7mekPFA3Lp16yImJgZbt24t0PwKqiB1FFvqqAAQFRWF/v37IyUlBUB6dyg9evSAxWLBTz/9hKtXryI6Ohq9evXCyZMnc/zsc6uLFFXdzB7mzp0rt6RXq9UYP368fQMiIioq9slvE1F5kJaWJho0aJBna4AWLVqIY8eOWU1XFC2aGzVqJIxGoxBCCKPRKHx8fORxr776qjxdt27d5OHOzs7izp078rj169dbzXPWrFnyuEdp0bxmzRp5uFKpFBcuXJDHmUwmUatWLXn8hAkTcl23rK3X8ts2GY4fP241n61bt1qNz9yCqkePHjkuIzfHjx8XS5cuFXPmzBEzZ84UH374odWyMrcYzdoCO3MLsNWrV1uNO3HiRJEtK2vLk/bt28vjxowZIw/v1atXjsO7du0qD//ll1+yxXXr1i2RlJQkv8+ttdDYsWPl4TNmzMg2nwcPHogHDx7ksqWt5df69FH378z7EgCxevVqm+LJLa7Mfz///HOBpl27dq1Vq9aNGzeKypUrCyC9hWNqamquLZrnzJkjD3d3dxf379+XxyUmJgpvb295/Jw5c7LFUtz79ZEjR+Rh4eHhwmKxWC3fZDKJK1eu2LTNn3jiCXlejo6O4vz581bjExMTrT7/om7RXLt2bXn4P//8ky2+qKgoYTab5fd5necz1KtXTx4/ePBgq3HLly+Xx6lUKqvPNvN8XVxcxNWrV7PN29bvGUmSxJEjR+Rx48ePl8d5eHjIw3/55Rer+S1YsEAed/HiRauWzra2aC6K49fW+PNS0HNfhsIcP0uXLpXHNW3a1GrcihUrhBDprWYDAgLk4Zm/27Puxy+++KI8zmg0iho1asjjKlSoII/Lbb8o6u/PmzdvWt19MHDgwFzjy+n4MJvNYv/+/WLx4sVi9uzZYubMmeLVV1+1mubatWu5bo+sx3Vmd+7cEWvWrBHz588X//d//ydmzpwpatasKU/7/PPP57t+Qggxb948eZoaNWoIIYTYuXOnANLvaslonbpp0yYhhLBqLf7ZZ5/J88nrWLXlPJK1zPjx4+Vxx44dsxqX2502WRX1MZZZ1s8xc2twIdI/+8yfX1G3aC5oHcWWOuqECRPk8VWrVrW6i+DmzZtWLZLXrFkjj7OlLvKo56ecnDp1SsycOdPmv6+//tqm+eYkMTFReHh45Pg9TET0uGOLZiIqNiqVClu3bsWMGTPw/fff486dO9nK7N69G+3bt8fp06fh7e1dZMsePnw41Go1gPRWAqGhobh79y4A4OHDh3K5zH0qduzYET4+PvL7Tp06wdvbGzExMXLZwrQ2yGhVDaS3bq5atWquZR+l9VtBlg8Abdu2LfTyjxw5gsGDB+fbSjCnfkSB9L51R4wYIb+vVq2a1fjMn1Vhl5XVmDFj5H4Oly5dik8//RRms9mqJVnm/h9btmyJP/74A0B634YLFy5E1apVUa1aNTRv3hyNGjWyqU/xli1b4osvvgAAvPPOO/jjjz9QvXp1VKtWDY0bN863JVdBFMX+XbNmTXTr1q1I4gGA9957Dy1atJBbOtli5MiR+PTTT2EymfDCCy/I/UO+9NJLeT4IKPM+//DhQ3h6euZadu/evRg7diyAktuvw8PD4enpifv37+Ps2bOoXLky6tWrh6pVq6J27dp48sknERwcnGcMQHpr2qNHj8rvM1pGZ+bo6AhHR8d85/WoWrZsiRMnTgAA2rdvj6ZNm6JKlSqIiIhAq1at5DsGbJWcnCy3HgWAH3/8ET/++GOOZU0mEw4cOJDjwzcHDx4s98v8KJo2bYp69erJ7zN/lpnPT4cOHbKabtCgQfLrypUro0WLFgVqoQ4UzfFra/x5Kei5r7DHj0qlsrojJyQkRN4WarUaPXr0AJDe0jM0NBQ3b97Md30yfx5qtRp9+vSR7wC4ceMG7ty5A19f31ynL+rvz8OHD1v11/7cc8/lGl9WmzdvxvDhw3PsXz6zGzduFOg8m5KSgpEjR+LHH3+ExWLJc762yNwv9JkzZ/DgwQO5f+5GjRpBq9Viy5Yt2LVrFxo3biyfP7JOW9RGjhwpv86rzmGrojjGMsvch3l4eHi25xgoFIocn/9RVIqjjpL5+Llw4UKed53t3btXvpMss9zqIkVVNwNK9sGT33//PR48eAAg/Vz22muvlchyiYhKAhPNRFSsnJ2dMX36dHz00Uc4c+YM9u/fj507d+L333+Xb32PiYnBkiVLrB4KU1hZK+GZk1GZL6AyKnkAcrzI9PX1lS/kc7tgyHyxCCDXB8pkXlZ+MpZZlIp6+SkpKXj66adx69atfMvmtk18fX2tumHImjTM+KyKYllZdenSBZUqVcLly5fx8OFD/Pbbb1CpVPKtnXXr1rW6eBw/fjxOnDiBn3/+GQaDAdu3b7dKHNWsWRN//fUX/P3981zus88+i9dee02+ZfKff/6xSigFBwdj3bp1RXKxUxT7d/Xq1QsdR8Z2BoBLly4hMjISW7dutfliOTAwEL169cKyZcvkJLNarbZKGOTkUfb5ktyvdTodli9fjmHDhuHatWu4fPmyvJ0AQKPRYMaMGfmeGx8+fGh1Hsr6cKbCsPX8Nn36dFy+fBkbNmxAYmIiNm/ebPXAqsjISKxbt87mZHfWdcpPbueswu6/eX2XZI4vNjZWfu3s7JxtPf38/Aq87KI4fm2NPy8FOfcVxfHj4+MDleq/S5SM7pMyxmVOcmUul1dyNHOSHsi+PWNjY/NMNBf192fm/cWW+DLcvHkT3bt3l7s2yEtBHm4HAJMnT872wLjCzDciIgJ+fn64ffs2hBDYs2eP3D1GixYt5ETzzp070axZM/nz8/DwQJ06dQoUe0FkPiZyOzc/6vyyzrMg57AMmfc1e5zLi6OOUhTHT27n8qKqmwHA6dOnsWHDBptjdXV1xYsvvmhz+QxmsxmzZs2S33fq1EnuwoaIqCxgopmISoQkSXJLgeeffx5Tp05FWFiYXKm/ePFikS4vozVz5uXnxMPDQ27pnFOL68zDMvd/qVAo5NcZickMua1LRj/JQHqC6YMPPsgtfLmv2KKUeflAer+5+fVlnJedO3daJRMmTpyIN998E15eXkhOTrYpoWTr51QUy8pKoVBg1KhRmDhxIgDg22+/tWrxmvVp9iqVCj/++CM+++wz7N27F+fPn8f58+exatUqPHz4EKdOncKbb76JH374Id9lz5w5E++88w727t2Lc+fO4cKFC/jjjz9w8+ZNXL16FSNHjsSOHTsKvE5ZPer+nVlRtIJ95513cOjQIcyfPx9Aen+NGcnmjL4c8zNu3Dirvjh79eqVb1+amfd5f3//PBO2GS3/SnK/BtJbRkZFReHIkSM4duwYLl26hL1792LXrl0wGo2YNGkSunbtmmd/9u7u7pAkSU4kREVF5RtjbjKf2wDr81t8fHyO+xEAuLi4YP369bhx4wb27duHCxcu4MyZM1i1ahWSk5OxY8cOfPrpp5g2bZpNcbi5uVm979q1K1q2bJlr+czPBMissPuvrZ9l5ngTEhKQkpJidX7N3BevrYri+C3Ivpibgpz7iuP4yRrLo7h7965VS9Os2zPr/pZVUX9/Zl1exuecW3wZ1q5da5Vk/uyzz/DCCy/A1dUVZ86cKdQPlJnPr7Vq1cIvv/yCatWqQaVSoU+fPlixYkWB59m6dWv8+uuvAIAdO3bIrb1btmwpJ2QPHDiALVu2yNNERkZmOw8Vpcz716McD3nNryjmmXlfK8y5PCOWjO8FW+uqQNHXUTKvU40aNTB06NBcy+aWcM3t3FGUdbODBw9i0qRJ+ZbLEBwc/EiJ5pUrV1p9tgVZJhHR44CJZiIqNj/88ANSU1PRv39/uLi4WI1zdHSEQqGQE835XeQVl2bNmmH16tUAgI0bN+Lu3btyy6INGzZYtazI/GCZzPEeOHAAQghIkoSTJ0/m+tCtzNOnpqaiRo0a6NSpU7Zy+/fvt2oRk/UiJreWTJnL5VQm64NxvLy88Morr2Qrd/r0aZtu97x//77V++eeew5eXl4AgOXLl+c7fUEU17Kef/55vPfee0hKSsL27dvl7a7RaKxuZQaA8+fPIygoCN7e3la3b9asWVNOYNry0JmoqCi4u7vDzc0NnTp1kveBp556Cj179rR5PrZ41P27qEmShC+//BIajQazZ88GAFy7dk1ONufVjUyGpk2bomHDhvKDpDK6uchLs2bN5P0jJiYGTz31FGrXrm1VRgiBv//+W054l+R+nZqaiqioKISHh6NBgwZo0KCBHJO7uzvi4uJgsVhw/PjxPBPNDg4OqFevnrzfZNwhknmalJQUJCQkZGs5mVXWc/G+ffsQEREBAJgxY0auLfROnTqFatWqoUKFCnj22Wfl4ePGjZNvw868X+d0XnNwcJDfOzo6om7dunL3Gffv38e4ceOyTRcXF4cNGzaU2O3Oucn47DL8+uuv8o9Vly5dsrod3lal5fgtyLmvJI+fgliyZIn8Q0VaWppVLIGBgXm2ZgaK/vvziSeesEoC/vTTT3LXL1njyyzr9h02bJj8w3Re29eWekTmebdp00Y+pmJiYgrc7UuGtm3byonmH374AXFxcVAoFGjWrBnUajXUajVSU1Px3XffWU1jq/zOI4+jFi1a4MCBAwCAs2fP4tdff7V6yKUQAtevX7epSyA3Nzd5f9y3b598F9CmTZtw+PDhHKcpaB3Fln2rWbNm8jrdunUL/fv3R2BgoFUZk8mEtWvXonHjxvmuV2ZFVTcrSf/3f/8nv27YsCFat25tv2CIiIoBE81EVGyioqIwbdo0jB8/Hi1atEDdunXh4eGB+/fvY+XKlTCZTHLZnPrWLAkTJkzAmjVrIIRAQkICGjZsiAEDBiAxMRHff/+9XM7DwwNDhgyR3zds2FDuE3XHjh1o0qQJAgICsGXLFhiNxhyX1aVLF4SHh+Ps2bMAgO7du6Nnz56IiIiAxWLBv//+i507d+Lq1atYtGgR6tatCwDw9vaGWq1GWloagPSnfB8/fhxqtRqtW7eWExyZK+3r1q2TW5F5eXlh6NChqFOnDtq3by/fzj569Ghs2LAB9evXh0KhwNWrV7F3716cPXsWU6ZMQYsWLfLcdln7Nhw4cCD69u2LK1euYMmSJflu+4IormW5ublh4MCBWLhwIYD/biXt2rVrtv58Z82ahSVLlqBdu3YIDQ2Fr68vHjx4YNVvrC0/mCxbtgxTpkxB69atUaVKFfj7+yMpKQm//PJLgeZji0fdv4vLrFmzoNVq8cknnwAAoqOj5WRzeHh4vtP/+OOPOHfuHNRqNZo2bZpv+aFDh+LDDz/EvXv3YDKZ0Lx5c/Tu3RuVK1eGwWDA+fPnsX37dty5cwfbtm1DaGhoie7XsbGxiIiIQI0aNdCoUSMEBARAr9dj9+7diIuLk8vZsj+8+eab6NOnDwAgMTERdevWRb9+/RAcHIzr16/jzz//xPz589G9e/c851O9enU4OzvLXRuNHDkSf/75J27fvm11+3RWr732Gg4cOIB27drJF/03b97EokWLclyPrEmGAQMGoFmzZlAoFBg0aBB8fX0xadIk+QefPXv2oHbt2njmmWfg7u6O+/fv4+jRo9i9ezf8/f2tEjH20K1bN/j4+MgtU19++WUcOHAArq6u+PHHH62+72xVWo7fgpz7SvL4KYhvvvkGMTExqF27NjZs2GDVf7QtLRKL+vszICAAnTp1kp8JsHTpUsTHx6Nu3brZ4sss6/bt0qULOnXqhBMnTmDlypW5Li/r8TZq1Ch06NABKpUKXbt2lfu0PXXqFID07aVQKODg4IAlS5Y8cndemftavnfvHgCgdu3acnL8iSeewP79+63OdwXpn9mW88jjZuzYsViwYIHcAnnAgAFYtmwZ6tati4cPH2L79u1o3bq1/KNtXho2bIi//voLQPqPLdHR0dDr9fKwnBS0jmJLHXXMmDH46quvkJqaigcPHqBu3bro3bs3goKCkJiYiDNnzmD79u2IjY2VE922Kqq6GZBeZ8irtXVR2L59u1Wf/mzNTERlUok+epCIypWsT5HP7S/z0+CFyPsp4pmfQJ35Cc35PfU6t+mEEGLWrFlCoVDkGp+rq2u2+Z0+fVpotdpsZfV6vWjdunWuTwA/f/68CAkJyXebZH06eI8ePXIsN3PmTLnMmjVrciyT8bR3IdKfJp/5ye65/U2ZMiXXzzWzjh075jh95qeZZ12fvJ6QntfnWNTLynDq1Kls81y3bl22ciNGjMhzmykUCrFq1Sq5fG5PdJ8xY0a+2/+LL76waftv27bNarrMT6LP8Cj7d17Hy6PElXV/fuedd6zG+/j4iBMnTuQ47dq1a/NdXnBwcK7x7tmzR3h5eeW7zYtzX8ttv75161a+cTVq1EikpaXZtN2nTp0qJEnKdV6Z98+8PuOsn0/GX4MGDYSPj0+O54kOHTrkuR46nU4cOHBALp+amir8/f1zLHvw4EG53OTJk/PdRlm3d177XoZH+Z7Jb7q1a9cKlUqVLT53d3fRpEkT+X2bNm1y/gBzUNTHb17x56ag576iPn4yT5d1XG7rmvU80qVLlxxjql+/vkhOTrZp+xT19+fly5etjqfMf5nXK3McRqNR1KpVy6btm3W/qFevXo7TrVixQgghxC+//JLjeH9/f9G+fXur2AoiKCjIan5jxoyRx7322mtW43x9fbNNn9dnYst5JL993pbzRVZFfYxltW7dOuHs7JzrPjZu3Di5bF7HzubNm3P8TvD09BSNGjXK8TN9lDqKLXXUVatWCUdHx3znnbkeY0tdpKDnJ3vr3LmzHFtYWJgwm832DomIqMgVXwdYRFTujR8/HitXrsTIkSPRqFEjVKxYEXq9HhqNBoGBgejatSt+++03fP3113aPc//+/Rg0aBCCg4Oh0Wig1+sRHh6OCRMm4OTJk9lua4uIiMCWLVvQsmVL6PV6uLi44JlnnsH+/fsRGRmZ67KqVq2KEydO4NNPP0WzZs3g7u4OpVIJZ2dn1K5dG8OHD8eqVauyPWX8m2++wZAhQ+Dr65tr34Vdu3bFvHnzEB4ebvXwpMx8fHywf/9+LFiwAG3btoWXlxeUSiUcHR1RvXp1DBw4ED/99JPNLSx+++03jB8/Hv7+/tBoNKhcuTKmT59udRtsUSmuZdWoUcPqVt2AgAB06NAhW7kXXngBb7zxBlq1aoWgoCDodDpoNBoEBQWhd+/e2LFjR76tRYH0luzvvfcennzySYSEhMDBwQEqlQr+/v7o0qUL/vjjD4wZM6ZQ65TZo+zfxe2DDz6w6qP87t27aNOmjdxNQlFq1qwZTp8+jXfffRf169eHi4sLlEol3NzcUL9+fYwePRqbN29Gq1at5GlKar92d3fHvHnz0L9/f0RERMDDwwNKpRIuLi5o0KABPvjgA/z9998290s7ZcoU7Nu3D0OGDEGlSpWg0+ng4OCASpUqYdCgQTY/bOj999/H9OnTERoaCrVajeDgYEyePBk7duzItV/aSZMmYdy4cWjSpAkCAwOh0Wig1WpRqVIlDBkyBAcOHEDDhg3l8lqtFuvXr8dTTz2VrWulzKZPn449e/Zg4MCBCA0NhVarhVqtRmBgIJ566ilMnz4df//9t03rVdyefvpp/P3334iMjIRer4ebmxu6deuGffv2WfW7X5A7FkrD8VvQc19Jfi/Yau7cuZg3bx4iIiKg1Wrh7++PcePGYevWrTb3tVzU35+hoaHYt28f+vTpAzc3N+j1ejRt2hRr167NtVWlWq3G1q1bMXToUHh6ekKr1aJmzZr4+uuvMXXq1DyX9/vvv6NHjx7w8PDIsR/hfv36Yfny5ahTpw7UajU8PT3Rt29f7Nu3L9/+8POStYVy5tbeWftdL+i+bOt55HHTuXNnnD59GpMmTULt2rXh5OQEtVqNgIAAdOnSBZ07d7ZpPk8++SRWrVqFJ554AhqNBp6ennjuuedw+PDhXO8iepQ6ii111O7du+PUqVN49dVXUatWLTg5OUGpVMLT0xNNmzbFpEmTsGfPHpsfEpyhqOpmJeHMmTNWDxt89dVXi7U/ciIie5GEeITH4RIREZUhL7/8stx9xptvvokZM2bYOSIietykpqZCp9NlGx4dHY2IiAjEx8cDAD766CO89dZbJR1eubJ9+3arBGdUVFSBE1hEREREVHDso5mIiMqlK1eu4PLlyzhz5oz8NHKVSoURI0bYOTIiehxt3LgRb775Jvr374+qVavC0dERFy5cwNy5c+Uks5OTE55//nk7R0pEREREVDyYaCYionJp8eLFmDZtmtWwCRMmsNUbET2y8+fP59qFgbOzM5YtWwY/P7+SDYqIiIiIqIQw0UxEROWaSqVCSEgIhg8fzqd/E9Ejq1OnDl555RXs3LkTN2/eRHx8PBwdHVGlShW0b98eo0aNQoUKFewdJhGVsHnz5mHevHn5lvvxxx/RqFGjEoiIiIio+LCPZiIiIiIiIqJiMHXq1Gx3UOVk27ZtJf5wXiIioqLGRDMRERERERERERERFYrC3gEQERERERERERER0eONiWYiIiIiIiIiIiIiKhQmmomIiIiIiIiIiIioUJhoJiIiIiIiIiIiIqJCYaKZiIiIiIiIiIiIiAqFiWYiIiIiIiIiIiIiKhQmmomIiIiIiIiIiIioUJhoJiIiIiIiIiIiIqJCYaKZiIiIiIiIiIiIiAqFiWYiIiIiIiIiIiIiKhQmmomIiIiIiIiIiIioUJhoJiIiIiIiIiIiIqJCYaKZiIiIiIiIiIiIiAqFiWYiIiIiIiIiIiIiKhQmmomIiIiIiIiIiIioUJhoJiIiIiIiIiIiIqJCYaKZiIiIiIiIiIiIiAqFiWYiIiIiIiIiIiIiKhQmmomIiIiIiIiIiIioUJhoJiIiIiIiIiIiIqJCYaKZiIiIiIiIiIiIiAqFiWYiIiIiIiIiIiIiKhQmmomIiIiIiIiIiIioUJhoJiIiIiIiIiIiIqJCYaKZiIiIiIiIiIiIiAqFiWYiIiIiIiIiIiIiKhQmmomIiIiIiIiIiIioUJhopjJh+/btkCQJK1eutHcoWLx4MSRJwpUrV+RhrVu3RuvWreX3pSnex1XWbVqcLl68iKeeegqurq6QJAmrV68ukeVm1bp1a9SsWdMuyy4uJfk5FoecjnciIiIqXUpb3Tsjnu3bt5e6OIYOHYqQkJASj8Veyy2IxMREDB8+HH5+fpAkCePHjy/wPKZOnQpJknDv3r2iD7CASst+aC+SJGHq1KmPNG1533ZEeWGimUotSZJs+uPJvfjMnz8fixcvzjb8zJkzmDp16mOZXEtOTsbUqVMLtN8MGTIEJ0+exEcffYQlS5agQYMGxRbfzZs3MXXqVBw7dqzYlkGPj/Xr1z9yBZiIiKgs47XC4+dxr+dOnz4dixcvxiuvvIIlS5Zg0KBBeZa1V+OU0mLv3r2YOnUqYmNj7R1KqcL6PZV1KnsHQJSbJUuWWL3/8ccfsXnz5mzDw8PDcfbs2ZIMLU+DBg1Cv379oNVq7R1Koc2fPx9eXl4YOnSo1fAzZ85g2rRpaN26dalveZBVcnIypk2bBgA2taRNSUnBP//8g7fffhujR48u5ujSK+DTpk1DSEgI6tatW+zLs7e//vrL3iGUauvXr8eXX37JyigREVEWj+u1AgC0atUKKSkp0Gg09g4lm2+++QYWi6VY5p1XPbc4l1tUtm7diiZNmmDKlCn5lp0+fTqeffZZdO/evfgDK6X27t2LadOmYejQoXBzc7N3OKUG6/dU1jHRTKXWwIEDrd7v27cPmzdvzjYcQKmqPCqVSiiVSnuHQUUkJiYGAIq0cpSUlARHR8cim9/jKDk5GQ4ODqXyAqusE0IgNTUVer3e3qEQERE9ssf1WgEAFAoFdDqdvcPIkVqtLlfLLYi7d+8iIiLC3mGUexnXEURUOrHrDCpTLBYLPvroI1SoUAE6nQ7t2rXDpUuXspXbv38/OnbsCFdXVzg4OCAyMhJ79uyxaRlz585FjRo14ODgAHd3dzRo0AA///yzPL4gfbbaGu+KFStQv3596PV6eHl5YeDAgYiOjrYqk1tftzn1d2axWDB79mzUqFEDOp0Ovr6+GDFiBB4+fCiXCQkJwenTp7Fjxw751sPWrVtj8eLF6N27NwCgTZs2Od6WuGHDBrRs2RKOjo5wdnZGly5dcPr06Xy3R8a227lzJ0aMGAFPT0+4uLhg8ODBVrHl5u7du3jhhRfg6+sLnU6HOnXq4IcffpDHX7lyBd7e3gCAadOmybHn9mvy1KlTERwcDACYNGkSJEmy2pZHjx5Fp06d4OLiAicnJ7Rr1w779u3LcZ127NiBkSNHwsfHBxUqVMhxedu3b0fDhg0BAMOGDZPjy9p9yZkzZ9CmTRs4ODggMDAQn376abZ5GQwGTJkyBZUrV4ZWq0VQUBBef/11GAyGPLfh6NGj4eTkhOTk5Gzj+vfvDz8/P5jNZgDAmjVr0KVLFwQEBECr1SIsLAwffPCBPD5DRt/Shw8fRqtWreDg4IC33npLHpd1v83vc8zYVjndDnvlypVs2+z27dsYNmwYKlSoAK1WC39/f3Tr1s2mY/TcuXPo06cPvL29odfrUa1aNbz99tt5TpPbPhUSEmJ1d0BaWhqmTZuGKlWqQKfTwdPTEy1atMDmzZsBpB+7X375pTzPjL8MthzHGct9+umnsWnTJjRo0AB6vR4LFy4EAGzevBktWrSAm5sbnJycUK1aNfmzISIiKmuK81rhzp07UKlU8p1zmZ0/fx6SJGHevHkAcq7HXLx4Eb169YKfnx90Oh0qVKiAfv36IS4uDkDOdZwMWeseV69exciRI1GtWjXo9Xp4enqid+/eNtV9sl47tG7dOtduSTJiefDgAV577TXUqlULTk5OcHFxQadOnXD8+HF5PvnVc3O6ZklKSsLEiRMRFBQErVaLatWq4f/+7/8ghMi2/qNHj8bq1atRs2ZNaLVa1KhRAxs3bsx3fYH8654Zn1dUVBTWrVsnx57b9pQkCUlJSfjhhx/kslnvEI2NjZVb+rq6umLYsGE51r+XLl0qXwd6eHigX79+uH79uk3rFR0djRdeeEGuq4eGhuKVV16B0WjMdZqs9dUMOdXZ87ounjp1KiZNmgQACA0NzXGb2bJueV1H2Hq9YzAYMGHCBHh7e8PZ2Rldu3bFjRs3bNqGAHDjxg10794djo6O8PHxwYQJE3K8ptq1axd69+6NihUryvFMmDABKSkpcpn86vf/93//h2bNmsHT0xN6vR7169cvNX3LE9mKLZqpTPn444+hUCjw2muvIS4uDp9++imee+457N+/Xy6zdetWdOrUCfXr18eUKVOgUCiwaNEitG3bFrt27UKjRo1ynf8333yDsWPH4tlnn8W4ceOQmpqKEydOYP/+/RgwYECxxLt48WIMGzYMDRs2xIwZM3Dnzh3MmTMHe/bswdGjRx+ppe2IESPk+Y4dOxZRUVGYN28ejh49ij179kCtVmP27NkYM2YMnJyc5MSar68vwsLCMHbsWHzxxRd46623EB4eDgDy/0uWLMGQIUPQoUMHfPLJJ0hOTsaCBQvQokULHD161KauNkaPHg03NzdMnToV58+fx4IFC3D16lW5kpeTlJQUtG7dGpcuXcLo0aMRGhqKFStWYOjQoYiNjcW4cePg7e2NBQsW4JVXXkGPHj3Qs2dPAEDt2rVznGfPnj3h5uaGCRMmoH///ujcuTOcnJwAAKdPn0bLli3h4uKC119/HWq1GgsXLkTr1q2xY8cONG7c2GpeI0eOhLe3N9577z0kJSXluLzw8HC8//77eO+99/DSSy+hZcuWAIBmzZrJZR4+fIiOHTuiZ8+e6NOnD1auXIk33ngDtWrVQqdOnQCkX0R17doVu3fvxksvvYTw8HCcPHkSs2bNwoULF/LsL65v37748ssvsW7dOvkHBSC95cDatWsxdOhQucX+4sWL4eTkhFdffRVOTk7YunUr3nvvPcTHx2PmzJlW871//z46deqEfv36YeDAgfD19c1x+bZ8jgXVq1cvnD59GmPGjEFISAju3r2LzZs349q1a3nujydOnEDLli2hVqvx0ksvISQkBP/++y/Wrl2Ljz76qMBxZDV16lTMmDEDw4cPR6NGjRAfH49Dhw7hyJEjaN++PUaMGIGbN2/meBswYNtxnOH8+fPo378/RowYgRdffBHVqlXD6dOn8fTTT6N27dp4//33odVqcenSJZt/dCMiInrcFOe1gq+vLyIjI7F8+fJsXSssW7YMSqXSqm6VmdFoRIcOHWAwGDBmzBj4+fkhOjoaf/75J2JjY+Hq6lqg9Tx48CD27t2Lfv36oUKFCrhy5QoWLFiA1q1b48yZMwVqDfr2229j+PDhVsOWLl2KTZs2wcfHBwBw+fJlrF69Gr1790ZoaCju3LmDhQsXIjIyEmfOnEFAQIBN9dzMhBDo2rUrtm3bhhdeeAF169bFpk2bMGnSJERHR2PWrFlW5Xfv3o3ff/8dI0eOhLOzM7744gv06tUL165dg6enZ67rZ0vdMzw8HEuWLMGECRNQoUIFTJw4EQDkBixZLVmyRK7fvfTSSwCAsLAwqzJ9+vRBaGgoZsyYgSNHjuDbb7+Fj48PPvnkE7nMRx99hHfffRd9+vTB8OHDERMTg7lz56JVq1b5XgfevHkTjRo1QmxsLF566SVUr14d0dHRWLlyJZKTkwt9V2F+18U9e/bEhQsX8Msvv2DWrFnw8vKy2mYFWbecriMKcr0zfPhwLF26FAMGDECzZs2wdetWdOnSxab1TElJQbt27XDt2jWMHTsWAQEBWLJkCbZu3Zqt7IoVK5CcnIxXXnkFnp6eOHDgAObOnYsbN25gxYoVAJBv/X7OnDno2rUrnnvuORiNRvz666/o3bs3/vzzT5tjJrI7QfSYGDVqlMhtl922bZsAIMLDw4XBYJCHz5kzRwAQJ0+eFEIIYbFYRJUqVUSHDh2ExWKRyyUnJ4vQ0FDRvn37PGPo1q2bqFGjRp5lFi1aJACIqKgoeVhkZKSIjIwscLxGo1H4+PiImjVripSUFLncn3/+KQCI9957L9dlZBgyZIgIDg6W3+/atUsAED/99JNVuY0bN2YbXqNGjRznuWLFCgFAbNu2zWp4QkKCcHNzEy+++KLV8Nu3bwtXV9dsw7PK2Hb169cXRqNRHv7pp58KAGLNmjW5ru/s2bMFALF06VJ5mNFoFE2bNhVOTk4iPj5eCCFETEyMACCmTJmSZywZoqKiBAAxc+ZMq+Hdu3cXGo1G/Pvvv/KwmzdvCmdnZ9GqVats69SiRQthMpnyXd7BgwcFALFo0aJs4yIjIwUA8eOPP8rDDAaD8PPzE7169ZKHLVmyRCgUCrFr1y6r6b/66isBQOzZsyfX5VssFhEYGGg1PyGEWL58uQAgdu7cKQ9LTk7ONv2IESOEg4ODSE1NzRb3V199leM6PcrnmHEMZd0HMz6vjO338OHDHD8/W7Rq1Uo4OzuLq1evWg3PfO7I6XjPbf8KDg4WQ4YMkd/XqVNHdOnSJc8YcjvvFeQ4Dg4OFgDExo0brcrOmjVLABAxMTF5xkBERPQ4KA3XCgsXLrSaX4aIiAjRtm3bbPFk1GOOHj0qAIgVK1bkOu+sdZzMstY9cqqj/fPPP9nqkTnVp7JeO2S1Z88eoVarxfPPPy8PS01NFWazOVu8Wq1WvP/++/KwvOq5WZe7evVqAUB8+OGHVuWeffZZIUmSuHTpkjwMgNBoNFbDjh8/LgCIuXPn5rouQthe9xQivU6VX90tg6Ojo1W9L8OUKVMEAKvtJ4QQPXr0EJ6envL7K1euCKVSKT766COrcidPnhQqlSrb8KwGDx4sFAqFOHjwYLZxGft2Tp9/1vpqhqx1dluui2fOnJmtnlzQdcvtOsLW651jx44JAGLkyJFW5QYMGGDTNWHG/rF8+XJ5WFJSkqhcuXK2bZfTcTdjxgwhSZLV9URe56qs8zAajaJmzZpW5w+i0o5dZ1CZMmzYMKtfZzN+Kb98+TIA4NixY7h48SIGDBiA+/fv4969e7h37x6SkpLQrl077Ny5M8+HULi5ueHGjRs4ePBgicR76NAh3L17FyNHjrTqx61Lly6oXr061q1bV+BlrlixAq6urmjfvr28/vfu3UP9+vXh5OSEbdu2PfL6bN68GbGxsejfv7/VvJVKJRo3bmzzvF966SWr1pivvPIKVCoV1q9fn+s069evh5+fH/r37y8PU6vVGDt2LBITE7Fjx45HXq+szGYz/vrrL3Tv3h2VKlWSh/v7+2PAgAHYvXs34uPjraZ58cUXi6TvbicnJ6u+BzUaDRo1aiTvM0D6ZxweHo7q1atbfQ5t27YFgDw/B0mS0Lt3b6xfvx6JiYny8GXLliEwMBAtWrSQh2Xu4zchIQH37t1Dy5YtkZycjHPnzlnNV6vVYtiwYfmuX1F/jnq9HhqNBtu3b7ep+5UMMTEx2LlzJ55//nlUrFjRalxureoLys3NDadPn8bFixcLPG1Bj+PQ0FB06NAh2/KB9C5QSvvDd4iIiIpCcV8r9OzZEyqVCsuWLZOHnTp1CmfOnEHfvn1znS6jxfKmTZty7D6hoDLX0dLS0nD//n1UrlwZbm5uOHLkyCPP9/bt23j22WdRt25dzJ8/Xx6u1WqhUKSnFsxmM+7fvy93yfWoy1u/fj2USiXGjh1rNXzixIkQQmDDhg1Ww5988kmrVsO1a9eGi4uLVR05t+WU1DVEZi+//LLV+5YtW+L+/fvyNcTvv/8Oi8WCPn36WNX1/Pz8UKVKlTzr8xaLBatXr8YzzzyDBg0aZBtfFHXZwlwXF3TdcrqOsPV6J+P6Met+NH78eJtiXb9+Pfz9/fHss8/KwxwcHOSW6pllPu6SkpJw7949NGvWDEIIHD161KblZZ7Hw4cPERcXh5YtWxbquCUqaew6g8qUrAkhd3d3AJATTBkJnSFDhuQ6j7i4OHm6rN544w1s2bIFjRo1QuXKlfHUU09hwIABaN68ebHEe/XqVQBAtWrVsk1bvXp17N69u8DLvHjxIuLi4uRb3bK6e/dugeeZed4A5C/4rFxcXGyaT5UqVazeOzk5wd/fP89+5a5evYoqVarIldwMGV16ZGzLohATE4Pk5OQcP5fw8HBYLBZcv34dNWrUkIeHhoYWybIrVKiQrXLo7u6OEydOyO8vXryIs2fP5no7X36fcd++fTF79mz88ccfGDBgABITE7F+/XqMGDHCatmnT5/GO++8g61bt2ZLrGf0J5ghMDDQplv0ivpz1Gq1+OSTTzBx4kT4+vqiSZMmePrppzF48GD4+fnlOl3GRUnNmjULtLyCeP/999GtWzdUrVoVNWvWRMeOHTFo0KBcu3LJrKDHcU77X9++ffHtt99i+PDhePPNN9GuXTv07NkTzz77bLbtT0REVBYU97WCl5cX2rVrh+XLl+ODDz4AkP5jvUqlkrtsy0loaCheffVVfP755/jpp5/QsmVLdO3aFQMHDixwtxlA+u3+M2bMwKJFixAdHW3Vp3HWOpqtTCYT+vTpA7PZjN9//x1arVYeZ7FYMGfOHMyfPx9RUVFWz+vIq9uKvFy9ehUBAQFwdna2Gp5bnTDrZwukf775NTQoyWuIzPLaF11cXHDx4kUIIbJdF2XI6+GJMTExiI+PL9Z6bGGuiwu6bjldR9h6vXP16lUoFIpsXZfkdB2Xk6tXr6Jy5crZrr9ymv7atWt477338Mcff2Tb72w97v788098+OGHOHbsmFU/0EXV0IWoJDDRTGVKbi1GMypXGS0QZs6cibp16+ZYNqMP3pyEh4fj/Pnz+PPPP7Fx40b89ttvmD9/Pt57770cH/xR2HgLQpKkHKfL+mA2i8UCHx8f/PTTTznOJ7cva1tkbN8lS5bkmMRTqcrvKSfzr9OFYcs+Y7FYUKtWLXz++ec5lg0KCspzGU2aNEFISAiWL1+OAQMGYO3atUhJSbFqiRMbG4vIyEi4uLjg/fffR1hYGHQ6HY4cOYI33ngjW2ufolr/DLlVtrLu70B6i4VnnnkGq1evxqZNm/Duu+9ixowZ2Lp1K+rVq1ekceUla2ytWrXCv//+izVr1uCvv/7Ct99+i1mzZuGrr77K1hdiVgU9jnPa/nq9Hjt37sS2bduwbt06bNy4EcuWLUPbtm3x119/FUkLfCIiotKkuK8VAKBfv34YNmwYjh07hrp162L58uVo166d3Edtbj777DMMHTpUrheMHTsWM2bMwL59+3JsaJAhp7rPmDFjsGjRIowfPx5NmzaFq6srJElCv379HvkupkmTJuGff/7Bli1bsj3Yevr06Xj33Xfx/PPP44MPPoCHhwcUCgXGjx9fYndNFeV1VUmwZV+UJAkbNmzIsWx+++Gjyms/yxxHYa6LC7puOdVjC3u9U9TMZjPat2+PBw8e4I033kD16tXh6OiI6OhoDB061KbjYNeuXejatStatWqF+fPnw9/fH2q1GosWLZIfskj0OCi/WR8qlzJ+yXRxccGTTz75SPNwdHRE37590bdvXxiNRvTs2RMfffQRJk+ebNW9RVEIDg4GkP4gr6ythM+fPy+PB9J/Bc/p1rCsv8KHhYVhy5YtaN68eb7Jv9wqGrkNz9i+Pj4+j7x9gfRfqNu0aSO/T0xMxK1bt9C5c+dcpwkODsaJEydgsVisWiRkdOGQsa2K4tdgb29vODg44Pz589nGnTt3DgqF4pErN0URX1hYGI4fP4527do98vz69OmDOXPmID4+HsuWLUNISAiaNGkij9++fTvu37+P33//Ha1atZKHR0VFFSp2Wz/HjFYfsbGxVtPn1uokLCwMEydOxMSJE3Hx4kXUrVsXn332GZYuXZpj+YwuUU6dOlXgdXB3d88Wl9FoxK1bt7KV9fDwwLBhwzBs2DAkJiaiVatWmDp1qpxozutYs/U4zotCoUC7du3Qrl07fP7555g+fTrefvttbNu2rVDHMBER0eOoKK4VunfvjhEjRsjdZ1y4cAGTJ0+2adpatWqhVq1aeOedd7B37140b94cX331FT788MMC1X1WrlyJIUOG4LPPPpOHpaamZpvWVr/++itmz56N2bNnIzIyMsfltWnTBt99953V8NjYWKsEe0HqpcHBwdiyZQsSEhKsWjVnrRMWlq11z4IqbJ0+LCwMQgiEhoaiatWqBZrW29sbLi4uRVaPBdL3s8xdBgL5XxfnVY991HXLPA9brneCg4NhsVjw77//WrVCzuk6LrfpT506BSGE1XKyTn/y5ElcuHABP/zwAwYPHiwP37x5c7Z55hbvb7/9Bp1Oh02bNlndMbBo0SKbYiUqLXhvLJUr9evXR1hYGP7v//7Pqv/ZDDExMXlOf//+fav3Go0GEREREEIgLS2tSGMFgAYNGsDHxwdfffWV1a0zGzZswNmzZ62ePBsWFoZz585ZrcPx48exZ88eq3lm3PKWcTtfZiaTyapi4ejomGNFw9HREUD2im6HDh3g4uKC6dOn57g98tu+Gb7++mur6RcsWACTyYROnTrlOk3nzp1x+/Ztqz7xTCYT5s6dCycnJ7lSnPGU7UetaAPpLRCeeuoprFmzxqo7jzt37uDnn39GixYtbO4mJKvctm1B9OnTB9HR0fjmm2+yjUtJSUFSUlK+8+jbty8MBgN++OEHbNy4EX369LEan9H6IHMrEaPRaNVf36Ow9XMMDg6GUqnEzp07rabPuvzk5GSkpqZaDQsLC4Ozs7PVMZWVt7c3WrVqhe+//x7Xrl2zGpdfy5iwsLBscX399dfZWhxlPZ84OTmhcuXKVnHltj8U5DjOzYMHD7INy2i9lTmGc+fOZdsGREREZVFhrxWA9L5rO3TogOXLl+PXX3+FRqNB9+7d85wmPj4eJpPJalitWrWgUCjk72QXFxd4eXnlW/cB0utpWesrc+fOzbH1c35OnTqF4cOHY+DAgRg3blyOZXJa3ooVKxAdHW01rCD13M6dO8NsNmPevHlWw2fNmgVJkvK8LigIW+ueBZXbdZStevbsCaVSiWnTpmXbtkKIbPXIzBQKBbp37461a9fi0KFD2cbnVZcNCwvDvn37YDQa5WF//vknrl+/blXOluvi3D7vwqxbBluvdzL2ky+++MKqzOzZs/NdBpC+f9y8eRMrV66UhyUnJ+Prr7+2KpfTtZEQAnPmzMk2z9y2i1KphCRJVsfplStXsHr16mzzuHbtWrZn4hCVFmzRTOWKQqHAt99+i06dOqFGjRoYNmwYAgMDER0djW3btsHFxQVr167NdfqnnnoKfn5+aN68OXx9fXH27FnMmzcPXbp0ydZ/WFFQq9X45JNPMGzYMERGRqJ///64c+cO5syZg5CQEEyYMEEu+/zzz+Pzzz9Hhw4d8MILL+Du3bv46quvUKNGDav+cyMjIzFixAjMmDEDx44dw1NPPQW1Wo2LFy9ixYoVmDNnjvywg/r162PBggX48MMPUblyZfj4+KBt27aoW7culEolPvnkE8TFxUGr1aJt27bw8fHBggULMGjQIDzxxBPo168fvL29ce3aNaxbtw7NmzfPVlnMidFoRLt27dCnTx+cP38e8+fPR4sWLdC1a9dcp3nppZewcOFCDB06FIcPH0ZISAhWrlyJPXv2YPbs2fLno9frERERgWXLlqFq1arw8PBAzZo1C9yH2YcffojNmzejRYsWGDlyJFQqFRYuXAiDwYBPP/20QPPKLCwsDG5ubvjqq6/g7OwMR0dHNG7cuEB9PA8aNAjLly/Hyy+/jG3btqF58+Ywm804d+4cli9fjk2bNuX4YJDMnnjiCVSuXBlvv/02DAZDtgfYNGvWDO7u7hgyZAjGjh0LSZKwZMmSQt+eaOvn6Orqit69e2Pu3LmQJAlhYWH4888/s/VNfOHCBXlfioiIgEqlwqpVq3Dnzh3069cvz1i++OILtGjRAk888QReeuklhIaG4sqVK1i3bh2OHTuW63TDhw/Hyy+/jF69eqF9+/Y4fvw4Nm3alO2W2YiICLRu3Rr169eHh4cHDh06hJUrV2L06NFymfr16wNIf4BJhw4doFQq0a9fvwIdx7l5//33sXPnTnTp0gXBwcG4e/cu5s+fjwoVKlg99DE8PByRkZHYvn17nvMjIiJ63BX2WiFD3759MXDgQMyfPx8dOnSQH8Cbm61bt2L06NHo3bs3qlatCpPJhCVLlkCpVKJXr15yueHDh+Pjjz/G8OHD0aBBA+zcuRMXLlzINr+nn34aS5YsgaurKyIiIuQuLx6lv+SMh7C1atUq251gzZo1Q6VKlfD000/j/fffx7Bhw9CsWTOcPHkSP/30U7YWsAWp5z7zzDNo06YN3n77bVy5cgV16tTBX3/9hTVr1mD8+PHZ+tx9VLbWPQuqfv362LJlCz7//HMEBAQgNDQUjRs3tnn6sLAwfPjhh5g8eTKuXLmC7t27w9nZGVFRUVi1ahVeeuklvPbaa7lOP336dPz111+IjIzESy+9hPDwcNy6dQsrVqzA7t27c90nhw8fjpUrV6Jjx47o06cP/v33XyxdujTb9rblujijHvv222+jX79+UKvVeOaZZwq9boDt1zt169ZF//79MX/+fMTFxaFZs2b4+++/cenSJZs+hxdffBHz5s3D4MGDcfjwYfj7+2PJkiVy46UM1atXR1hYGF577TVER0fDxcUFv/32W459hOdWv+/SpQs+//xzdOzYEQMGDMDdu3fx5ZdfonLlylbP4wGAwYMHY8eOHaW2axgq5wTRY2LUqFEit11227ZtAoBYsWKF1fCoqCgBQCxatMhq+NGjR0XPnj2Fp6en0Gq1Ijg4WPTp00f8/fffecawcOFC0apVK3m6sLAwMWnSJBEXFyeXWbRokQAgoqKi5GGRkZEiMjLykeNdtmyZqFevntBqtcLDw0M899xz4saNG9niW7p0qahUqZLQaDSibt26YtOmTWLIkCEiODg4W9mvv/5a1K9fX+j1euHs7Cxq1aolXn/9dXHz5k25zO3bt0WXLl2Es7OzAGC1Dt98842oVKmSUCqVAoDYtm2b1fp16NBBuLq6Cp1OJ8LCwsTQoUPFoUOH8ty+Gdtux44d4qWXXhLu7u7CyclJPPfcc+L+/ftWZbNuUyGEuHPnjhg2bJjw8vISGo1G1KpVK9u2FEKIvXv3ivr16wuNRiMAiClTpuQaU8ZnMnPmzGzjjhw5Ijp06CCcnJyEg4ODaNOmjdi7d2+O63Tw4ME81z2zNWvWiIiICKFSqaz2h8jISFGjRo1s5XP6jI1Go/jkk09EjRo1hFarFe7u7qJ+/fpi2rRpVvtrXt5++20BQFSuXDnH8Xv27BFNmjQRer1eBAQEiNdff11s2rQp2/6QW9wZ4x71c4yJiRG9evUSDg4Owt3dXYwYMUKcOnXKapvdu3dPjBo1SlSvXl04OjoKV1dX0bhxY7F8+XKbtsGpU6dEjx49hJubm9DpdKJatWri3XfflcfndLybzWbxxhtvCC8vL+Hg4CA6dOggLl26JIKDg8WQIUPkch9++KFo1KiRcHNzE3q9XlSvXl189NFHwmg0ymVMJpMYM2aM8Pb2FpIkZTsH2nIcBwcHiy5dumRbt7///lt069ZNBAQECI1GIwICAkT//v3FhQsXrMplPfaJiIhKo9JwrZAhPj5e6PV6AUAsXbo013gy6kuXL18Wzz//vAgLCxM6nU54eHiINm3aiC1btlhNl5ycLF544QXh6uoqnJ2dRZ8+fcTdu3ez1WcfPnwo16WcnJxEhw4dxLlz57LVRbLGIUT2emVwcLAAkONfxnZLTU0VEydOFP7+/kKv14vmzZuLf/75J8d6Xm713JzqswkJCWLChAkiICBAqNVqUaVKFTFz5kxhsVisygEQo0aNyrads65vbmyte+ZWp8rJuXPnRKtWreT9ICOOKVOmCAAiJibGqnxOdUohhPjtt99EixYthKOjo3B0dBTVq1cXo0aNEufPn883hqtXr4rBgwcLb29vodVqRaVKlcSoUaOEwWAQQuT8+QshxGeffSYCAwOFVqsVzZs3F4cOHcr2WdpyXSyEEB988IEIDAwUCoUi2/rZsm55XUfYer2TkpIixo4dKzw9PYWjo6N45plnxPXr1/O9Dsy8Hbt27SocHByEl5eXGDdunNi4cWO2bXfmzBnx5JNPCicnJ+Hl5SVefPFFcfz48WznmLzq9999952oUqWK0Gq1onr16mLRokXyPpNZZGRkruc7InuThOBPIERUOixevBjDhg3DwYMH821xS0REREREREREpQf7aCYiIiIiIiIiIiKiQmGimYiIiIiIiIiIiIgKhYlmIiIiIiIiIiIiIioU9tFMRERERERERERERIXCFs1EREREREREREREVChMNBMRERERERERERFRoajssVCLxYKbN2/C2dkZkiTZIwQiIiIiKgZCCCQkJCAgIAAKBds0lBes3xMRERGVXbbW8e2SaL558yaCgoLssWgiIiIiKgHXr19HhQoV7B0GlRDW74mIiIjKvvzq+HZJNDs7OwNID87FxcUeIZSItA4dIGJiAC8ve4dCZM1igeriRQCAqUoVoDy2OLt6FfD1heTtDeU770BRr569IyIiKhPi4+MRFBQk1/eofCgv9XsiIiKi8sjWOr5dEs0Zt9O5uLiU6YpomkoF4ekJydvb3qEQWTOZoD54EACQ5ukJqOxyKrAbcf06EBAA5cSJUA4YYO9wiIjKJHafUL6Ul/o9ERERUXmWXx2/HDZjJKLyTBiNQEoKlEOHQtG/v73DISIiKhUWLFiA2rVry4nipk2bYsOGDfYOi4iIiIgeI0w0E1H5EhMDqUIFKAYPZms7IiKi/6lQoQI+/vhjHD58GIcOHULbtm3RrVs3nD592t6hEREREdFjonzdL09ElJgIqWtXSK6u9o6EiIio1HjmmWes3n/00UdYsGAB9u3bhxo1atgpKiIiIiJ6nDDRTETlhjCbAaUSiiZN7B0KERFRqWU2m7FixQokJSWhadOmOZYxGAwwGAzy+/j4+JIKj4iIiIhKKXadQUTlR3Iy4OAAqWpVe0dCRERU6pw8eRJOTk7QarV4+eWXsWrVKkRERORYdsaMGXB1dZX/goKCSjhaIiIiIiptmGgmovIjKQmSkxNQsaK9IyEiIip1qlWrhmPHjmH//v145ZVXMGTIEJw5cybHspMnT0ZcXJz8d/369RKOloiIiIhKG3adQVQeqVRIe/ppe0dR8lJSINWtC0nFUx8REVFWGo0GlStXBgDUr18fBw8exJw5c7Bw4cJsZbVaLbRabUmHSERERESlGFs0E1H5YTYDVarYOwoiIqLHgsViseqHmYiIiIgoL2zWR0TlihQYaO8QiIiISp3JkyejU6dOqFixIhISEvDzzz9j+/bt2LRpk71DIyIiIqLHBBPNROWR2QzlsWPpL+vWBZRKu4ZTEoTFAgCQ/PzsHAkREVHpc/fuXQwePBi3bt2Cq6srateujU2bNqF9+/b2Do2IiIiIHhNMNBOVR0JAcesWAMBcp46dgykhRiOg0QCenvaOhIiIqNT57rvv7B0CERERET3m2EczEZUPSUmQHBwghYTYOxIiIiIiIiIiojKHiWYiKh9SUwEvL0hubvaOhIiIiIiIiIiozGGimYjKB4OBrZmJiIiIiIiIiIoJE81EVD6YzZCCg+0dBRERERERERFRmcREMxGVHxUq2DsCIiIiIiIiIqIyiYlmIirzhMkEKBSQ/P3tHQoRERERERERUZmksncARGQHSiXSOnaUX5d5qamAXg8pIMDekRARERERERERlUlMNBOVR5IEqMrR4Z+aCkmnA4KC7B0JEREREREREVGZVI4yTURUbhkMQIUK6clmIiIiIiIiKhZHTEewLW0bKisro5umm73DIaISxkQzUXlkNkN58mT6y1q1yn73GQYDJLZmJiIiIiIiKjZ3LXfxQfIHMMGE7Wnb4Sw5o626rb3DIqISxIcBEpVHQkBx4wYUN24AQtg7muJnNgOBgfaOgoiIiIiI6LFlFEZcN19HmkhDgkjA/JT5iIyLRK3YWng58WXcs9xDokjEPcs9XDFfweyU2VhjXGPvsImoBLFFMxGVfZIEydfX3lEQERERERE9luIscZiUPAm3LLcQIAXglPkUTppPIglJUEKJm+abuGy6jJ3mnTDDDAkSHloeIk7EoYqiCiJUEfZeBSIqAUw0E1GZJoQALBYmmomIiIiIiB7RftN+3LLcAgAcNh/GZfNlJCMZlv/9S0ACtpi3QOC/O2YTkYhL5ktIFIn2CpuIShi7ziCiss1gALRawN/f3pEQERERERE9loIUQZAgAQBUUMFBcpDfS5CggMIqyQwAKUiBk+SE+sr68rBblltYkLoAyw3LYRKmklsBIioRbNFMRGWbwQBJq4Xk42PvSIiIiIiIiB5L4apwvK1/G8fNx1FPWQ9fpX6FX42/wgILVFBBCy0MMMjlVVDBXXLHIO0gKBXpD58XQmB00mjcttyGm+SGZJGMobqhdlojIioOTDQTUdmWlAR4eQEBAfaOhIiIiIiI6LHVWN0YjdWNAQDLjMtQRVkFUeYoOMABTnBCPOLlshZYYBRGpJhTMCxxGBqqGqKKVAW703YDAJwkJ9yw3LDLehBR8WGimYjKttRUSGFhkJRKe0dCRERERET02LlivoLPUj+DQRjwiu4V1FPVw03LTdy03IQRRmglLUwwQSVUMJnSe2i1SCbEKmPxrfFbOCgcEGWOQm1lbfgqfHHHcgcpIgVtVG3svGZEVNSYaCYqj5RKpLVvL78u08xmICTE3lEQERERERE9lr42fI0r5isAgM9SPsMo3SikiBSooIICCqSIFPhJfvA1VUJ0ggD0MYBQQeju4YH0ABBAlCUKvbW9EWWJgp/khyrKKmimbmbfFSOiIsdEM1F5JEnpD8grD4SAVLGivaMgIiIiIiJ6LCmhhEEY8K/5XzzEQ0SZo3DFcgUxIgYmmCBBwjlxDkqjP5RmL5hTADjcAYQCkAANNAhVhGKkdiRaqVrhrriLpqqmkCTJ3qtGREVMYe8AiIiKizAYAI2GiWYiIiIiIqJH9LL2ZRhhRJqUBgkSLpov4q64CxNMAAABARNMUCgswNVOkFJ9AZMekiSggAI1lDWwwHEBJElCLVUttFO3g4PkYOe1IqLiwBbNROWR2QzFmTMAAEtERNntPiMlBZJeDyk01N6REBERERERPTbuWu5ipWElDpsOI1QZClfJFUooAQHEi0SYJLNVeQGBZN0NoM4ngNkB0CRASAI66HDech56SY/DpsM4Yz6DxqrGqKqsaqc1I6LixEQzUXkkBJRXrwIALOHhdg6mGKWkAC4ugJ+fvSMhIiIiIiIqddJEGm5ZbsFH4QOdpAMApIpUvJ78OranbUeKSIGP2QfJIhlmYUa8JRkWiwQJWghlKpC19wuVCVDFy2+NMMIiLFhqWIoDpgMQEFhtXI0vHb+En4LXaURlDbvOIKKyKyUFUvXq7PuLiIiIiIgoi1SRiteSX8OopFEYmTQS9y33AQD3Lfdx33IfRosRQoj0JDPMiBNxMMEMgYz8cv7XWWlIg7fkDSWUEBAAAKMwItoSXWzrRUT2w0QzEZVdJhMQEmLvKIiIiIiIiEqdk+aTuGy+DACIscRgr2kvAMBP4YcEkYBUpCIRidALPcIV4TDAAEkoICxqSGY9pFxSSgoooIYa7pI7HOGIMboxeF73PNwkNwBARUVFhCvL8J21ROUYu84gojJJmM2AQgFF7dr2DoWIiIiIiKjUCZACoIJKfqhfRUX6Q9TviXtwlBxRS1UL1yzXIEGCEkq4wQ0PlA9hllKgM3ohWYqV56WEEmak99ushx7OkjMcJUd013THEP0QAMACpwW4abmJYEUwtJIWQgjefUpUxjDRTERlU0oKwAcBEhERERER5ShQGYhpDtOw37QfNZQ1UEdVBwDgIrnAWXKGAgqkilR4KjwhSRKCFcEwWAxIVCQiWXcbAgISJKihhvJ//9KQBgss6Kfuh5H6kaiiqiIvz0lyQlVlVSSKRLyV9BYumi+itbo1JugmMOFMVEaw6wwiKpsSEiC5uQFMNBMREREREeWotqo2XtS9iGbqZvIwvaTHhw4fooO6A57RPAM/yQ8SJHTWdIZCUsAMs9zfsoBAdUV1RCgj5BbNPpIPLolLmJU6K8dlbjZuxgXzBQgIbEvbhrPms8W/okRUItiimYjKpsRESK1aQdJo7B0JERERERHRY8Vb8kZPbU+MVozGRfNF6KFHokjE94bv8QAPrMqesJxABCLgK/nirrgL1f9STQ/Eg5xmDWfJWX4tQbJ6T0SPNyaaicojpRJpbdvKr8sqqXp1e4dARERERET0WDloOogZKTOQJtLwtPpptFS3hEbSIMWSAhNMVv06ZziP81AKJXTQ4SEeIt4Sj1EOo3Kcfzt1O9wWt3HefB5t1G0QpAwqidUiohLARDNReSRJgIODvaMoNiIlBdBoINWqZe9QiIiIiIiIHivrjOuQJtIAAHNT52Jt2loIIXBb3EaySIYTnJCMZBhhBJD+IEAHOCANaVBKSjRRNcGbujfRUtMyx/lLkoSB2oEltj5EVHKYaCaisufePUj+/pDq17d3JERERERERI+VIEUQDuMwACAJSZAgIU7E4bz5PAQEzDCjlqIW+mj7YJ9pH+5Y7kAPPW6JWxAQ8JQ8YRAGnDefR7AiGDpJZ+c1IqKSwkQzUXlksUBx7lz6y+rVAUUZey5oUhKkdu3YPzMREREREZGNjGaBh6lm9NT1whXzFSgkBUIUIbhiuYL7lvsA0lsva6DBi7oXMUI/AgDwwPIAPxt+xm7TbmwzbsNq42qsMq5CuDIcDVQNMNNxJhwlR3uuGhGVECaaicojiwXKy5fTX1atWqYSzSI+HnB0hCIy0t6hEBERERERPRYepJrx+u4HuJ1kwk3nXfCvdxIKpRkval/EKfMp3DDdgBlmGGGEG9zgrPjvAX4eCg+0UrfCSsNKxCIWFlgAANGWaPhafHHGfAYNVQ3ttWpEVILKTnaJiAgAbt2CVLEipEaN7B0JERERERHRY2FndCruJJthggnRsTokxPoBAHaYduCE+QSiRTTMMEMJJSopK2GZYRk+TfkUtyy3AAAKKKCX9FD9rz2jBAlOkhM0kgYVFBXstl5EVLLYopmIygyRmAio1VAOHw5JkuwdDhERERER0WMh0FEJAFBDBReFI7T6BKSJNBwyHUKsiEUc4gCkJ5DviDtQWVRYlbAd312+gLZ3ZmByg+rop+0HBRQ4bT4NT8kT3bTd0EHdATNTZiLaEo26yrpQSSpUU1ZDV01XO64tERUXJpqJqEwQJhMQHQ2pYUNIHTvaOxwiIiIiIqLHRkM/HcbXdcXZh0a869cYZg8HJItkzE6djRhLDABAAw18JV80VDVEokjC4TgDlIqHuJFoxo/nEvBOoyE4ZDqEQ+ZDuCVuYa9xL+It8dhn2gcHyQFz0uagjrIOdko74Sa5oZW6lZ3XmoiKGhPNRPTYE2YzcPEipIoVofroIz4EkIiIiIiIqIDaVdSjXUX9/941hRAC+0z7cNZ8Fk6SE1zhCn+lP17Xv44ZyTOghBlBd/sBAPQqCWkiDdtN2wEAZphx3HIc0WnRuC1uwwQT0kQaDMIAjaTBXctd+6wkERUrJpqJ6LEm0tKAM2cghYVBOXkypJAQe4dERERERET02JMkCW/p34Kr5IoNxg1QSArUVNbEE6onsMx5GY4bU/HLnRS4+inwfIQzVFCgmqIaHloeIg1pcJFcUFFZEbdMt5Am0uAheeCauIanFE+hnbqdvVePiIoBE81E9NgSDx4AN29CioiAcuZMKGrVsndIREREREREZYYkSRilG4VwVTgSRSKeUj8FAIgVsdjr9AsqNVBigGYAXBTpfTzPcpyFFcYVcIAD9JIeK40r4SQ5wVfyRSVlJXhL3pjvOB8KSWHP1SKiYsJEM1F5pFQiLTJSfv24EWlpwPXrgEIBRevWUE6bBqliRXuHRURERERE9Ni7b7mPP4x/wEVyQTdNN6gkFdqp28EkTDDCCAD4JOUTnDGfAQDEWGLwrsO7AIAgZRBe1b8qz6uWqhbOmM5gk3ETIAFj9WOZZCYqw5hoJiqPJAlwdrZ3FAUmTCbg2jXAYIAUGAjF4MFQPP88JEmyd2hERERERESFdsR0BLNSZkEhKTBRNxG1VbVLPIb3kt/DNcs1AMBD8RDDdcNx2XwZ7ya/i3gRj2c1z+Ku+K+P5TuWO3LsZ81n4SV5YblxOYzCiNG60RioG4iBuoElvh5EVPKYaCaix4KIjQXu3oXk7w+pY0cohwyB5O9v77CIiIiIiIiKzMLUhYgVsYAAvjF8g7mquSW6fCEErluuy+8zEs6/GX9DvIgHAKw0rsSL2hfxneE7KKBAP20/nDSdxNTkqRAQOG8+jxBlCLTQYr5hPhqrG5foOhCR/TDRTFQeWSxQXLyY/rJKFUBRum9dEvfuAbGxkOrVg+rzzyEFBNg7JCIiIiIioiKnl/T/vYY+j5LFQ5IkPKN5Bn8Y/4AKKnRWdwYAeEvechlnyRmdNZ3RTtMOCiigl/RYY1wDAQEASBJJuGi+CG/JG9GWaAxLHIaemp54RvNMia8PEZUsJpqJyiOLBcqMRHNYWKlNNAshgFu3gKQkKLp1g3L6dEiPYZ/SREREREREtpiom4ivDV9DCSVe1L5YYss1CRN2mXZBCy2Ga4ejs7oz9JIeHgoPAMAA7QAICMSIGPTQ9IBKUkEFFYzCiFhLLBqrGmOFtALXLdehgAIqocIVcQWVFJVwz3IP36R+g2aqZvBUeJbYOhFRyWOimYhKr+hoQJKgGDgQytdfZ5KZiIiIiIjKtCBlED5w+KDEl/tZ6mfYnbYbANBL0wtDdUOtxmskDYbphlkNu2S+hPeS30OCSEBnTWcscFqAlYaVWGFYAaWkxA3LDSil/67hJPDZOkRlXelsxkhE5Z5ISgIMBiiGDYPqnXcgaTT2DomIiIiIiKhMOmY69t9r87Fcy2W21rgWCSIBALDeuB4WYUE/bT9UV1UHALRWtUZHdUcEKYIwRjcGLpILfjT8iOnJ03HcdLyoV4GISgG2aCai0ik6GlLdulCOGGHvSIiIiIiIiOzmJ8NP+CvtL4QpwjBJP8mqH+ei0ljVGH+n/S2/toWvwld+7SK5QC/poZE0+MzhMyQhCY5whCT914o5o7UzABwxH8Eip0VwlpyLcC2IyN6YaCaiUkckJwMaDZTDhrElMxERERERlVtXzFfwq+FXAMADywOsM67Ds9pni3w543Tj0EzVDFpJizqqOjZN00fTBwoocNtyG101XaGGGnctd+EmucFJcspW/oF4IL82CAMSRSITzURlDBPNRFT63L4NKSgI0pNP2jsSIiIiIiIiu1HC+jk1Kql40jiSJKGRulGBplFJKvTT9gMAWIQF76e8j0OmQ/BQeOBjh4/hr/C3Kv+M5hnsM+1DjCUGnTWds40noscfE81EVKoIkwlIS4OiTx9IKp6iiIiIiIio/ApSBmG4bjj+Mv6FMGUYOqs7F8l8jcKIKEsU/CQ/uCpcCz2/fy3/4pDpEADgnuUevkv9Di/oXrBKJvsr/PGd43cwwACdpCv0Momo9GEWh6g8UiphatFCfl2qxMdD8vCA4umn7R0JERERERGR3XXTdEM3Tbcim59RGPFm8pu4aL4IR8kRHzt8jBBlSJ7TxFpiccJ8AqGKUAQpg7KN95Q8oZW0SBWpOG8+jweWBzhsOoypDlOtuuKQJAk6MMlMVFYp7B0AEdmBJEG4uUG4uQGZHs5QKiQmAkFBkHx87B0JERERERHRY+u8+TyGJA5B74Te2JG2Qx4eZYnCRfNFAECSSMIe0x4AwMHbqZh9NA6bryZbzSdRJGJC8gTMTJmJsUljccF8IcflVVRURLJIhiMc4aXwggkm7DbtLqa1I6LSiIlmIipdDAZIjQrWNxgRERERERFZW5y6GCdNJ3HSdBIfJn8oD/eT/OAoOcrvwxRhuJ5gwocHY/H39RR8cTweB2+nyuOjzFG4Z7kHADDBhGOmY9mW9VXqVzhgOoCL5ou4Lq7DAAMAIFwZXkxrR0SlEbvOICqPLBYooqLSX4aGAorS8ZuTEAIAoKha1c6REBERERERPd6iLdGItkQDAFItqbhnuQcvhRdcFa742OFj7DHtQZgiDE3UTXD4gQEW8d+0t5PN8usQZQg8FB54YHkAJZSopayVbVnxIh7/mv+FBRZohRa+ki/G6MYU+AGDRPR4Y6KZqDyyWKA8ezb9ZXBwqUk0IzUV0GiAChXsHQkREREREdFjramqKQ6aDsIMM4IUQYgX8fCCF4D05HHmfplreWkQ4aHGmQdpCHBUolWgHmkiDWpJDWfJGZ85fIajpqMIU4ahkrJStmUN1g7GL8ZfkCbSEKwMRi1VrSJJMgshMN8wH8dNx9FY1Rgv6F4o9DyJqPgw0UxEpUdyMiRHR0iVK9s7EiIiIiIiosdab21vHDMfw03LTbRVt0WoIjTXshqlhI+be+B+qgVuWgXmG+Zic8JmBCmCMFk/Ge4Kd7TXtM91+ghVBFY6r8Si1EVwU7hhmHZYkazDbtNubDRuBACsNq5GPVU9PKF6okjmTURFj4lmIio9kpOBKlUgubraOxIiIiIiIqLHmpfCC185fgUDDNBJunzLS5IEL70SUeYobE7bDAA4Zj6GHgk9EKgIxCu6V9BR0zHX6bXQop26Heoo68Bb4V0k6yAg8nxPRKVLKblfnogIQGoqpLAwe0dBRERERERUJkiSZFOSOTNnyRmq/7VLvGW5BQUUsMCCX42/5jrNcsNyDE0cipFJI9EtoRuWGZZZjX9oeYhbllsFjr+FqgXaq9vDR+GDrpqueELJ1sxEpRlbNBNR6SFJkIKD7R0FERERERFRueWl8MKb+jexKW0TNNDAIAwAAD/JL9dp9pv24564BwB4KB7i77S/0VfbFwCwN20vZqbMhAkm9NL0wlDdUJtjUUgKjNWPffSVIaISxRbNRFQqCIsFEAJSxYr2DoWIiKjcmTFjBho2bAhnZ2f4+Pige/fuOH/+vL3DIiKiR/BP2j9YbVyNWEusPGy5YTl6JfTC6MTRuGu5m+88Gqsb4z2H97DYeTG6aruis6YzXte/nmv5Oqo6cIQjAMBFckEVZRV53Lq0dTDBBABYY1xj83rcSzFj0dn7mHd1H+6Y79g8HRHZD1s0E1HpYDQCGg0QEGDvSIiIiMqdHTt2YNSoUWjYsCFMJhPeeustPPXUUzhz5gwcHR3tHR4REdloo3Ejvkz9EgCwXrEe8x3nI1EkYolhCQDgqriKlcaVGKkbadP8nCVnvKR7Kd9ygzSDECwFY5dpF2oqa6KLpos8roKiAk7gRPprZQWbliuEwJt772Kb9zQkGi9jyR09FvnMQIQqIlvZWEssFhoWIl7EY7B2MKopq9m0DCIqekw0E5VHSiVMTZrIr0sFgwGSVgvJx8fekRAREZU7GzdutHq/ePFi+Pj44PDhw2jVqpWdoiIiooI6Yz4jv75luYV4EQ+tpIVG0sAojAAgtzy21THTMfxh/AOBikAM1g6GWlJnKyNJEiI1kYjURGYbN1w7HF6SFxJEArprutu0TINZ4EpaNBL1lwEA8SYD9pr25pho/sbwDXan7QYAfGT+CD86/1iAtSOiosREM1F5JEkQXl72jsJacjLg5gb4+9s7EiIionIvLi4OAODh4WHnSIiIqCBaqltiZ9pOmGFGbVVtuEvukCQJb+rfxO+G3+Gv8Jf7TrZFkkjChykfwiAMOIiDcJQc0U/br0AxqSU1emt7F2ganUqB9r6BOG9yQ5oqFl56Jaoqq+YaY4ZkJEMIAUmSCrQ8IioaTDQTUemQlASpWTNICnYdT0REZE8WiwXjx49H8+bNUbNmzRzLGAwGGAwG+X18fHxJhUdEVC6dM5/DSsNKeCo8MUw7DDpJl2O5hqqGmOc4D/fEPdRU1pQTrg1VDdFQ1bDAy00RKfLDAIH0B/2VlNfr+qFN3CycVu5FTX1IrvEP1g7Gdct1JIgEvKx7mUlmIjtiopmoPLJYoLh2Lf1lxYpAKUnuSrlczBIREVHJGTVqFE6dOoXdu3fnWmbGjBmYNm1aCUZFRFS2XTNfw1eGryCEwAjdCIQoQ+RxJmHCtORpSBSJAAA11BiuG57rvCooK6ACbOsLOT9eCi/00PTAauNqeCu8be76oihIkoRGboFohLxbQ1dSVsJ3Tt+VUFRElJfSkV0iopJlsUB56hSUp04BFou9o4GwWACLBVLFivYOhYiIqFwbPXo0/vzzT2zbtg0VKuSepJg8eTLi4uLkv+vXr5dglEREZc+c1Dk4aTqJU+ZTmJ0622qcCSY5yQw8eqviRJGIv9P+xlnTWZunOWU6hVPmU6ilrIUZDjPgr2BXh0SUO7ZoJiL7S0kBHByYaCYiIrITIQTGjBmDVatWYfv27QgNDc2zvFarhVarLaHoiIjKPiOM8uvMXVUAgE7SYZB2EJYalsJd4Y7emoL1dwykt4p+Pel1XLdch4T0PpubqZvlO90nKZ8gVsQiRaRgWOIw9NP2Q19NX2gkTYFjIKKyj4lmIrI/gwGSTgcEBto7EiIionJp1KhR+Pnnn7FmzRo4Ozvj9u3bAABXV1fo9Xo7R0dEVPaN0I7ArNRZAIBXdK9kG99H2wc9NT2hhPKR+iCOETG4bkm/+0RA4Kj5qE2J5jSkAQDOW85DDz2+T/0efxr/RFdNV/TV9IVKYlqJiP7DMwIR2V9SEhAcDLi42DsSIiKicmnBggUAgNatW1sNX7RoEYYOHVryARERlRMGYcBdy11UU1bLt5/hwiR1vSVvhChDcMV8BRIkNFA2yDWeFcYVSBAJ6KXphXG6cZifOh9KKBEgBeC8+TxuW24jWSRDDTUaqhoiQSSglrIWH8JHREw0E1EpkJICqX59VkyIiIjsRAhh7xCIiMqdh5aHmJQ8CXcsdxCqDMUnDp9ALxXPXSQqSYWPHT7GYdNh+Cv8UUVZJcdy3xq+xUbjRgDASdNJzHeaj6bqpvgk+RP8YvgFZpjhp/ADAOxM24mlhqUQEGilboVJ+knFEjsRPT74MEAisiuRmgoolVA0aWLvUIiIiIiIiErMP6Z/cMdyBwAQZY7CcdPxYl2eo+SIVupWuSaZAeCm5ab8+pblFoQQiDZH44D5APyUfvCVfKGAAg6SA86az+K65TrMwoxdabv4oyVRMbkWlYj3JhzB22MO48LZOHuHkycmmonIvm7dglSxIqTmze0dCRERERERUYmpqPjvYehKKBGgCLBjNOm6a7rLD/p7VvssJEnCv5Z/YRRGqKFGsDIYY3VjUVGqiIfiIW5abuKK5QqqKqvyDlWiYvLNnAvYvuk2Nv95E9NeO2bvcPLErjOIyiOFAqaGDeXX9iISEwGzGYq+fSE5OtotDiIiIiIiopJWU1UTb+nfwknzSTRSNUJFZcX8JypmDVUN8aPTjzAIAzwUHgCAZJGMy+bLEBCoraqNZupmWG5cjkBFIHSSDl6SF6Y5TLNz5ERl15VLiXh43wAAuHA6DvfupsLLR2fnqHLGRDNReaRQQPj62mXRwmgEUlOBu3eBtDQo2reHok8fu8RCRERERERkT03VTdFU3dTeYQAAfjX8igOmA6inqodB2kEAgCSRhIWpCxGkCEIyktFC1QLeCm/01PTEYsNi+Eg+GKcfB0eJDYeIikJqqhkqFXD5YiKiLibi7MlY3LmVjNRUM1ycVQgKcYTJVHq7qWGimYgKTZjN6cljsxlIS0v/MxoBkyn9L6PVtMUCqNWAVgspNBSKjh2hGDKErZmJiIiIiIjs6JjpGH4y/AQAuGi+iKqKqmisbgyTMMEMM9SSGq5whVJSAgB6aXshUh0JFVRwU7jZMXKix9/RA/fx7RcXcPlCAlJTzDBbBFRKCTF3UmE2C+j0Snj56ODopMLQkVXgF1A8Dw0tCkw0E5VHFguk6GgAgAgMtOo+QwiRnjA2GNL/MhLHZvN/fwCQ0f+WEOmvdTpIKlV6ItnZGfD1heTjA7i7Q/LwAHQ6wMUFUkgIJF9foGJFSEplSa85ERERERFRmZYiUhAn4uAr+drcb3KqSLV+j/T3rgpXPK97HssMy+Cv8EdvTW+5jJfCq+iCJiqHoi4lYN1vN7B2+TU8fGjAjSvJkKT0NItSBUBIsFgEDKlKNGjqhZZP+qFrH/t3sZMXJpqJygBhNqe3HBbivz+jMb0FcUaSOCOB/L+y6vPnAQDG1NT0RLPF8r+ZCUClAjQaSDodoNEAgYGQ3NwAFxfA1RWSkxPg4PDfaxcXSBUqAE5OwP+SynwQBBERERERUfFIESn41fArkkQSntU+Cz+FHwDgsvky3k5+G4kiES3VLTFJN8mma7NGqkaIVEfKXWc0V/33sPbumu7oruleXKtCdnLon3vYtvEWKgQ7ovfgEKhU9nt+U3mTlJiGf3bcxbyPzyIpyYhTR+PlceJ/vWKY0gBAQPG/9nkeXlr0GxZa4rEWFBPNRHYitxy2WNKTxBbLf68zEsMWy3+vM/4yl1Mo0ocpFOnJ4YwKhEIBSaNJH56RFFarITk7pyeLVSrgf4lm5dix6Qnj/5WBKv20IIWEAIGBgF6f3lKZiIiIiIiISoWvU7/GlrQtAIAz5jOY7zQfALAxbSMSRSIAYFfaLgzRDoGvlP/zeRSSAq/pXyu+gKlUeXDfgC8/PQuzSeDkkYdw99SgY7cK9g6rXDCZLHj/tWPYtuk2bkUnw5SWe3/LkgRo1ApUr+mKgS+FldoHAGbG7BFREZETx0ajdf/EGa8zWgynF07/X6n8L0msUEDKeJ2RNNZq0xPDajWgVKZ3NaHRAI6OgLd3etcUDg6QAgMBd3d5fpJKBXh7p3dX4eCQ/RfspCRgzpz0EIYMSZ8fERERERERPRbuiDs5vg5UBMqvnSVnuEguJRpXQa01rsVSw1L4KHzwtv5tuWU2Fa+UZBPMmR4oFx+XZsdo7Of+PQOuXEpAparOcPfQlsgyp08+gV8XRyHNaJFTQzmSAI1WAZ2DCt37V0TTSJ8Sia+wmGgmKiBhNgOxsUBKyn/dUgD/60RHmd5yWKuVH3qHKlUgOTtDqlQpvVsJFxdIen16MtnVNb3FsIMDoNf/l0R2dmbXE0RERERERJSjXppeOG8+D6Mwor+mvzy8q7orAOCm5SY6qDtAL5Xeh4Yli2R8k/oNBASumK/gV8OvGK8fb++wyoXAIEe06xKAretvIiDIAe2fDrB3SCUu5k4q3ht/BEmJJji7qvHBnCfg4Zk92ZyUmIYr/yYiKMQRLq6aAi8nNdWMrRtuwWIR+HPlNfyx/DqEJf/pNGoFHJ1UqBrhivsxRigUj0eOiIlmIhuJtDQgOhowGCC5u6c/7M7fH1KtWoCTU/owf//0RLK/f/pD8NjlBBERERERERWx+qr6WOq0FEZhhKvCVR4uSRK6abqVSAzxlnj8YPgBqUjFc9rnEKAoWLJSBRU0kgYGYQCAUp0UL4uGvFwZg14Ke2wSmEXtzIlYJCWaAAAJcWk4fzoOTVtZtxqOjzNiyoSjuB9jgLOrGtM+r1eg7iuMRjMWfn4Of/1xEzeuJuHunVQgr1bM/+PiqkRQiBO8/XRQq5U4eyIWQojHokEis2BENhBxccCtW5BCQqDo3h2KTp2A0NDH4iAnIiIiIiKix4NRGPGb8TckiST00PSAp8Iz17J6SV+sydkEowU3Ek0IdVFBl8OD4r40fIm9aXsBAFfNVzHPaV6B5q+RNJisn4xlhmXwVnhjoHZgkcRNtiuvSWYACKvmDLVGgTSjBVqdEpWqOGcrc+5UHO7HpP8QkhCXhhNHHqJtR/985y2EwJefnsOB3TE4ffwh7txMkW+Gz49aI6FTjyBcvZyEM8fjUCHEEU92CXhs8k9MNBPlQ8TGArdvQ2rSBKoPPkh/SB4RERERERFREfvG8A02GjcCAE6YT+ALxy/sEsftJBNe2/UAcUYLgpxU+L+WHnBQWyebH1geyK/vi/uPtJz6qvqor6pfqFiJHkWFio6Y+lldnD8dj/DarvD1z/6jTcVQJzkZrVBKCK3slOc8798z4MDuGPy66DKOHXgASSFw56bB5pi0esDHV4/zZ+Lh7aNDWDVnKBQSxrwZXuD1sxcmmonyc+cOFG3bQvn555DKykPztFpg+fL/XhMREREREZHd3TDfkF9HW6IfeT4JIgE3zDcQqgyFTrL9Vv8M+28bEGdM70j2eqIJZx+kob6v9bXjAO0ATE+ZjjSRhqHaoY8cK5G9BIU4ISgk9+SxX4Ae73xSB6eOPkS1mq4Irfxfq2ez2YKVS67g6uUkRD7lh/hYI2ZOOYULp+NgMltgNtkehyQBlas74+F9I1KSzYh9YISXjw5Ozmp4+WihyuGOgtKKiWaiPIiEBECng6J//7KTZAbSH0TYu7e9oyAiIiIiIqJMumq64lzKOZhgQk9Nz0eaxx3LHUxMmog4EYcKigr4P8f/g6NUsOvZMFc1JKR3J6tRABWclNnK1FPVwy9Ov8ACCzRSwR+SRvQ4CK3sbJVgzrB1wy2s+y39h6Ezx2MRdTEely4kwGJjFxmZBVdyRKPm3jh/Jg5qlQI6ByUaNfeCIdWM3oNDC7sKJYqJZqK83LkDKTwcUosW9o6EiIiIiIiIyrim6qZYrFwMAwzwUfjkP0EO9pv2I07EAQBuWG7gjPkMGqoaFmgeNb00mNbEHWceGNHIVwdfx5zTRyqJaSUqP65eTsTxQw9QraYr7t8z4Oq/iUhONsHBSYUrl5MeKckMAA/uG6DTK+EX4ABDqhmde1ZAv2GVijb4EsIzAlEuhCG9Hx1F796QVGXsUDGZgFWr0l/36JHewpmIiIiIiIjszlXhWqjpKykqQYIEAQGNpEGQIuiR5lPPR4t6PmWvq8X1xvW4ZL6ENuo2qKWqZe9wqBQ7fvgB7txMQZNW3khJNuP9ScfS+2tWSAgKccDlSwkwmwQUSjxSklnxvx4xTGkCm9ZGY8naVvAN0MPd4/E97phdIsrN3buQ/Pyg6NrV3pEUPYMB6NMn/XViIhPNREREREREZURNVU1Mc5iGM+YzaKRqBD+Fn71DKjW2pW3DgtQFAIAdph1Y6LgQXgovO0dVNplMFhhSzXB0Uts7FABAWpoFfyy/hof3jejQLRBBwXl3J7Ppj2i8P+kY4mONCKzoiJ7PBeP0sYfQaBQICnHEbz9dhSlNAECB+mMGAAdHJTy9tTAYLEiIS4NGq4SwADdvpKB6TbdHXMPSodxll6Kjo/HGG29gw4YNSE5ORuXKlbFo0SI0aNDA3qFRKSIsFiApCdKAAWWrb2YiIiIiIiIq8+qp6qGeqp69wyh1blluya+Nwoj74j68wERzUYu+noSP3z6JuIdGtO3kj6Ejq9g87YWzcbh0LgF1G3ogoIJDkcW06uer+HPldQDA8UMPMGdxYygUUq7lv593ATeuJsGUZsH9GAMunImFTq9CWpoFN68nIyXlEfvJAJCaYsbt6BRYhIAQQJrRgqoRLqhVz/2R51lalKtE88OHD9G8eXO0adMGGzZsgLe3Ny5evAh398f/g6QilpgIODtDWRZbMxMRERERERGVQ+3U7bA5bTPuWe6hvqo+Kisq2zukAruXYsbxGCMqu6kQ7FI6WgtntXntTcQ9NAJIf2je072D4OWty3e682fiMP3N4xAC+GPZNUz/sj48PB+tGwkhBDb/eRN3b6eiTUc/3L2dCgBITTUjLioR744/AgdHFZ4fXQV7tt3FpXPxaBrpg8j26XcA6PRKmM0CFkv6/FKSLUhJNj5SLBkk6b//BdKTzO4eWiiUQLe+FeHtm/82Ku3KVaL5k08+QVBQEBYtWiQPCw19vJ7eSCXkwQNIAQFA5cfvS4eIiIiIiIiIsvNV+GKh40LEiTh4SV6QpNxbtJZGcQYLJuy8j1iDBSoF8GlzT1RxL33JZg+v/5LDOr0SDrk8TDKrf88nQKT3RoHkJBNuXE165ETzhtXR+PX7yzCbLPhnxx1UiXDBgd0xMBosUCiB5EQT/Cs44LUXD+DS+QQ4O6tx5vhDVKrihJs3UlAx1BEubmo8vFe45LJKJQGSgCRJ0GgVMBoENFoFXN3USIg3QZKAwIqOaNLq0R7+WdqUq0TzH3/8gQ4dOqB3797YsWMHAgMDMXLkSLz44ov2Do1KESEEYDBA6tSp7D0EkIiIiIiIiKgc00gaeEve9g7jkVyOS0OsIb2JrckCnLxvLHCiOTnJhBU/RiEp0YSufSuiQsWi7y60c88KSEuz4M7NFDz5dAAcHGzLrdRp4I7VvyiRmmKGt68OYVWdHzmGq5cTcPFsPOLjjEhNMWPbxlswmcywCIE0AxB1KQFxsUbcvpkCi1lAALh9KxmzPjyFbRvvwGIR8AvQQ6uVcDva8MhxKFUSIuq44+E9A65fTYZKJcHNXY2nngnEsNFVcOFsPGrVdUfFUKdHXkZpUq6yaJcvX8aCBQvw6quv4q233sLBgwcxduxYaDQaDBkyxN7hUWkRFwc4O0PRurW9IyEiIiIiIiIiAgBUclXDXavAQ4MFagVQx0tToOmTk0x4sc8enD8VB29fHS6di8fn3zUu8jhVKgV6PRdS4OkCgxwxY34D3LiahMrVnAv0IMHN627i+y8uQKmW8NL4avALcEBKsgmGVAuEAJKTzDAa05P0er0SQgD37hqQZhTyPO7fNWLZoiuwWAClUkL8QyO0emWB1yMz0/8S7l4+Oiivp0CplGBItUCSJFSp7ooq1V0LNf/Splwlmi0WCxo0aIDp06cDAOrVq4dTp07hq6++YqKZ/hMTA6lBA0h16tg7EiIiIiIiIiJ6jK1fdQP7d8WgSrgLBrxQKc8H0OXHVavArFaeOHHPiMpuagQ5W6f1rl5OxLdfXICwCAwdVQWVq7lkiyXqYgIMqWbcuJYEDy8NhBCP3IXIsUMPsGnNDfgFOqD/86HQaAqXlAUATy8tPL1y7i7DaDQj5k4qvH11Vsu6fDEBM987iVs3kgEAn007hXdn1kVEHTdci0rC/bupSEtL729ZqQC8/XRQqRRQqSScPx1vtYyMPpnNZgGzWSA11VKg+BUKQAAQ8mQSgsOckJpihk6vhICASq1Al2crFGi+j4tylWj29/dHRESE1bDw8HD89ttvdoqIShuRkgJIEpTduj12fTUViEYDZPRVrinYL6BERERERERElL/LFxPw6/eXAQBRFxMQXMkRLdv5FWqennol2gTpcxz3/byLuPpvIgDg2zkX8PH8BlbjhUjvDiI5yQSLWaBr3+BHzn0kJqRh7owzSDNacPpYLJxdVOg5IOSR5pXV/XsGfD3rPOIeGtFnSCieaOyJuFgjnuu8A7ejUxBa2Qnf/d4CLq7p+YwH9wwwGs0wmwXSjBbcjzGgYogjRk4Kx66/72D7plu4cCY+vb9kAGFVnTFkZBUs/PwccLpIQgaQnmR2cFIhzWhBmtEClVqCk7MaY9+KQFK8CUcO3MetG8lIiEvD7r/vIryWG9w9Hq0P6tKqXCWamzdvjvPnz1sNu3DhAoKDg+0UEZU6d+5ACg2F1LWrvSMpXmo1MHSovaMgIiIiIiIiKrOMBnOW9wVrHVtYyckmaDQKqFQKAECXnkG4djkJFUOd0P6ZAHTpGfTI8zYY0pOpGRITTFbj9++OwfZNtxBcyQm9B4fAbBZIiDfBw1OTb3J7xQ9ROHsiFgAwf+ZZLFzWDD9+dUlOop87FYeNa6LRZ3AokpNM+G3pFaQkm5EQlwa1WoJWp8C5U3Fo9aQfTh17CF9/PS6dj4chxQKdXonLFxMRUskJKUlmaHUKGA0W+SGEShWgkAAHJyXiY83y8NxIUnqCWatT4pk+QWjTwR/b/7qNQ3vvwZBqRsVQJ7Ru7w8ACK/lij7ttyM1xYyb15Ph4aXF8LFVC7DVS79ylWieMGECmjVrhunTp6NPnz44cOAAvv76a3z99df2Do1KAWE0AmlpUPTvD0lbtn5RIiIiIiIiIqK8PbA8gE7SwUFyKJL5VavhijYd/eWuM1q08y2S+QLA3h13cWjvPVSr4YoOXQMBAENHVsZ3X1yAxQL4VdDj5b574eSswmvTaqFSFWc4OKowcUpNGI1mbFoTjW+/uIDmbXwQXsvNat4b19zA6WOxqNfYE207+ue4fE8vLZ7pE4R1v92Aj58OnXv81xXEvbupWDDzHCwWgdPHYgEJ+Onrf3HjahKqhLvgh7WtoNfnnpK0WAQe3DPgfowBjs4qCAG4eaQnqIUQgAR4+aTnbQ7vu4foa8nw8tHh1o1kKJTAtcuJmPrqUXh6a3H1ciIcHJUwGf/XFUaKGUqlhLUrr+PBPUN6dxZCQKNVwGRKb/VtSLEgIS79RwKVWoLZJKBQABaB9H4x/kelklAh2BFuHhpUjXBBleouWP3LVRiNAmq1AgnxaUhJNiH6ehICgxyxZtk1JCWakJxoQnxcGjb/eRMDXqgEB8eyk54tO2tig4YNG2LVqlWYPHky3n//fYSGhmL27Nl47rnn7B0a2ZkQArh4EVL16lB062bvcIqfyQRs2pT+ukMHQFWuTgVEREREREREVpYalmKZYRm0khbv6N9BXVXdQs9TkiQMG1UFw0ZVKXyAmVy9nIiFn52DEMChvffg6qaGq7sGvgF6fPhFfaSkmDCiz14A6S2NN6y6gVGvhwMATCYLJo88jM1/3gQkYOPqG/j8u0aoGOoEADh++AF+/ja9u4/jhx6gQrADqobn/MC63oNC8ezAEHk5Gf09JyWaYLH8l5Hduv4WrvyvNfLZk3H4belVDHwxDABgNlugVCrkskajGVVruuKb2Rfw8IEBCoWEp5tuxvh3auCZ3kE4efQhWnfwQ9uOAQAAH//0bkQS49OgVALJSemtky+ei8eFswJ6vRLR183pfS9LACDg5aPF/7N31/FS1Psfx18T26e7gQMHOHRISwmKErYidmJd49rtz6teu9trdxdiJ4KAgHQcTnfn9uzOzO+PhYXjOZQSB52nDx7O7s7OfDdhP/OZ9zchyYyq6ii+0P77DYphxeImVHXbuHU9lLUsywKOSAmfN9TFbbFKJCRZ+df1ffn521qWLKinYFMboihgsUkkJlnYvKENk0kgoGjcfcMann5zDDFxFqw2Ea8HtKDOiiX1TBrwBVOmp3HD3YOIjjn4o03/cdWlmTNnMnPmzAM9DEMXomsaFBYiJCcj3XgjQlTUru90sPP7YevnwOUyCs0Gg8FgMBgMBoPhb6lSraRcK2egPBCH4DjQwzF0UZqu8b7/fQD8up+P/B/TXx+EyRQqgDbU+XjrxSJUVeeUc3pgd8isWdFERjcHPXpF7tG+1q1qprbKy4hxCeGM4a0qy9001vvJHRgT3ndnmpsUdB1qqry42gLcdf1q4hIsWG0SN987mPQsOxFRJlxtAeprfbz5QiEfvlnCsXO6cewpWWxa30owqIEeyjeuKPOEC81tLaFt11Z78XlVfvm+loxuDux2mTW/N9FQ52f0+MRwF24wqPPA7WvZtLaVzO4ObrpnEBFRJmSTQMEmJyPHJdBvcDSLf64DQJQEYmJNKIrKGTN/YeOaFrr1dPDa5+PRVIG7r19F4WYnXm8Qi1XC61EpLnDy7EObyO4dyaRpKeHCvbMtQEBRGTIyjqoKNzaHiUAggKbpaGqo81mUQjEdW8M6BFFg9tk9GDY6gece3kxsgoXkVAurlze3K45DKBLDZBYwmUVUVScYDBXSo2PNjDw0kclHpfHB66X4fSp+v4bJJKADNZVedF1H1cDrVdG3bHf22T1YurCe3xbW43YFUPw6Xo/Kt59XsXFtC6ee15OTz+qxR++nrsaoLhn+sXRdh+ZmqKpCSElB/Pe/EcePP9DDMhgMBoPBYDAYDAbDXrAxuJGbPDcRJEiGmMEjjkewCtYDPSzDn6TroaLcn40ZqNPqeMf/DhbBwqmWU4kUthWIRUEkWUymWqvGX25n0e09mbzuS/r0j+aux4fxytMF4czgui0F2Mb6ULftdXcOpN+gmJ3uW9N0Xnh8M99/UUVNpZesHg6+/KSC/z45HLNZAmDVskYevWsDmqbTZ0A0N/13EIIg4HIGeOr+jVSVe5h+fCbTjk5nwJAYYuLNrPytEdkkUlrkwmYPbWf54ga6ZXfnuv8M4PP3y/ngjRKcrQGcrQHef7WYnr0jEUVCEwJqoYzhgUNj+X1pI689W4DJIqKqGtUVHtSgzmN3r2fJz3UcMSudee+XA/D9/CruenwYgiDw5v8K+eGLamLjzZSXuPns3TK+/KSSxgYfmd3tRMeaOefS3tRW+/htYQOjJyRy5LEZfPBGCRtWN6OqOmt/b+aYcd8zdWY6DXV+HBEykijg92lIUmhCvZJCF4IgUF/rx2QqJC3TznuvFFNc4KS6wosg6JitEmaziCgKqKqO3bElFmPLdYGATnyCmTnn9sTrDTJ0ZDzO1gCKoiHJAkIAdBUkWSAjy4YgCURFmUGH/Ly2UFc0OhGRMja7xNsvFmEyi5jMIoqiIcsiA4bE4HYFiYoxU1fjIyrGxKXXh7rJ7Q6Zp94YzbuvlPDiE3nUVvsIKBqqquN2Bfn8g3IGHxJHn/6dd5AfDIxCs+EfRQ8GQx28W//Y7QjjxiFddhniqFEHengGg8FgMBgMBoPBYNhLlqnLCBKaoKxCq6BcKydH2rsRBoZ9JxjU2LSulehYM/EJFv570xrKilz0GhDNMVf0oXeCGZu8467fP7rbezdFaigSokVv4Xrb9e1uv8N+Bx8pH7H6ixhWr4zC41L4bWE9j9+zke2SHaiv9YUn9dM0nXWrmuk3KIbqSg8lhS76DYpB8WvYHRKOCBNVFR5+/qaGBd/WUFfto6nBT1SMCUEQaG5USN4S/bB0YUO4ozZvXSstzQqxcRbmf1geyjkG3nqhkEPGJhCfYGHmCZk01vnRNZ2Na1sIKBpul4/qCg/BoEb3npFccl0uSxc20FjvB0CSQlEOAgKRUSYio2RyB0UTGWXihcfywhP6SZJIn/7R5K1vRdegtTnA1/Mqw89BeYkbZ1uAtb838/mH5dTWeKmv9ZHVw86Hb5WSt76V1iYFs0UKdwHfePfgds93fGIoY9nvC8VayLLIisUNOCJkivNdiJJAdp8IYuMsmMwCRfkuSgpdaJpOVbkHq1WirNhFW0uog1kQQ1nKw0Yn0H9wNNOOyWDkuESaG308/J8NLPqxFlXVufymfgDYbDK33DeYX3+qIzXDxqN3aiz5pR5JhNETEnnji4m8+MRmfviimsQUK3U1XhSbhigJyCaBmkovxflOLLbQcxUMapx+QU9OOL07X35SycdvlXDY9FQuvqYv6ZnbzqaQJJFTz8vmkLHxfPRmKb8vbaS2yktSSuh9oO9q9sEuzig0G/6WdF0HRQkVkxUFnM7QYTpAiIyElBSEyZMRDzsMYcgQBCM6wmAwGAwGg8FgMBj+VvpL/fmAD9DRiRPjSBPTDvSQDoj85gDv5ruItYic0y8S+04iGbqSR+9az5oVzQgCjBqfSFmRC19Q570f6vgpwUafobE8ND5+tx9PvVYfXq7T6jrcniqmcqn1Ut5JKGKVth4Idbb6fSrn/iuHp+7biKrqnH1pLz58o5SKEjelxW6++qQCi0Xks/fKCSgajQ1+omNMOCJMzDwxg4/fLqO50U9tlZfkNCuN9QKiINAjJzJcbAXo0z+KRT/UApCSbiMyygRsi37YStzycA89LJlff6qjaLOTo2d347v5lZSXeNi8oY1lvzbw6qcTEEWBW+4bzH+uXUVVuYdDpyRjsYq0tSoAOJ1BLBaZ269ayca1rSSlWLFYJXJyI6mp9FKQ10Z0jBmrTWL4qASWLKhD16F3vyh+/qaGee+XowZ10jPtFG120dykEFD8BBSNYFBHVYOsW9lMW6vSISbk8BnpnHVxDh+8XkwgoJOYYiU+wcKkI1N45oG88HMw/fgMTjknm4tOWcTShQ2YzSINtT5694tCEAQkWUDVBAQh1DEsClBW7KG+xofJJJKUYuf2h4aw/NcG4hOt7brPU9PtnHBadwB+/KoGr0fF5Qzi9ahUlrlZ/FM9NrtMS5NCt56haBGLRUJRNGoqvVRXhiYhvOHugRwxKx1BEPjq0wref7UYCOVGX37mUtSgxmU39WPKUdu+g3rnRnPDXYMIBjVeeHwz+RvaGDU+kb4Dto3vYGRU1wx/C7qug88HbW2h4rKqgtmMYLNBfDzC8OEIWVkIQ4ci5OZCt24I4sHxl6vBYDAYDAaDwWAwGPbccHk499nvo1grZqQ8cp9nNNdpdbzrfxebYGOOZU6XyITWdZ07ljbTqoQ6cAXgksFd/7R8jzvImhXNQGhCtvISN60tCsUVXjyAZJepcKnkNQcYmmTZ+ca2OM1yGs/5nsMkmJhtno2u67S2BIiMkttNRnfcqd0oLXLx1ScVxCdZOf2CbAYMieWZt8eGJ7sbODSOO65eiabpBAM6zz+SR1yiFU3VQl3XfaOQZZGP3y5DU3WiY8y4nUGyc6KYdkwGow5NpP+QWOTtOrInHZFK9Ja4hTETE8O3zTghk+oKL1XlHo46LoPYuNDjtTtk/u+hoQSDGl99Wsm7r4S6tRVFY+XSRpqb/MTGWejTP5o3v5gY3s/8j8pDmcsOGV2Hhnof9bU+JElg49pWevaJ5IwLe5HZ3cHGtS38vrSJhCQLmqozdUYaffpH0dyk8Ob/ivB6gpQWuYiLt5CQZKFbdgSFeU4g1OsnSQJej8pn75dz+vk9O7wm1/zfAFLSbbz4+GYqyzwcN6cb04/L5Mcva3C7Qt3VWT1Cn6M+A2LwuFUAWpoUbHaZnNwocgdGE1RDXdqOCJnNG9rQVJ2P3ixlyvQ0IqNM2Gwy46ekhN5PioL2wAPo69cjjB+PdPHFAAw+JI6P3wrlLTvbJC47cyl11T669XRgs8mcdkFPEpKsdMuOYPmvDdxz0xrMZpHIaBNffVrJtKMzgNAEigCqqvPlJ5WYzaHX8b83rGHoyHji4re9X3/+toZli+rpOyCGi67qu1vv467OKDQbDlq6rkNrKzQ0QCAQisGIjEQYPx6hf3+EUaNCxeXU1AM9VIPBYDAYDAaDwWAwHAC5ci655O717aqajiiAIGzrNr3TeyclagkArXorV9uu3uv73VOqDm1biswALX5tJ2t3HTa7REY3BxWlbgBGjEtg7cpmrCYBjyTiKXERk+UgM7J9Wau1ReHtl4pQ/BonntGdtAx7+LYZ5hlMMk1CRkYMmrjn5jVsWttKWqadm+8dHO4gtlgkzro4h/ISN20tAb7+rIpBw+OQZTH8ekdGmejeK5K6Gh8A0bFmZFkgqAvYI2RstlBecu9+UWxa2wrA4BFx3PPUtkzmzgwdGd/hOrtd5vIb++3wPrIsYnfIREWb8LhVBCAx2brDLOvJ01L5fUkjRflOxk1O5velDbQ2B6ir8RERKRMZZWLhD7WcMbcXA4fGMXBoHPfduiYc3xEM6jgi5C2vk0zfAdEceUwG38yrRBQFcgfFMHJcPA/dsZ5AQEeWBb6dV4ka1Jl5YibxCdsKrR5PkDeeL0DXQ13ReetbOeWcbG66dzC/fFdDZg8HYyclA3D2Jb0wmUT8PpXkNCvLFzcyanwi516Ww8/f1lCU56ShzodO6ICKxSphMndsMNR/+AFtyZLQ8hdfIIwbhzhoEJOnpfBidwdqUKesxEVrs0J0jImmeoVjTknhmNlZ4dfOYhXplRtJSYGL4nwnrc0K335eyeEz0xk4LI71q1oIBlQ0NZQrbrGGcq8D230WiwucvPj4ZgDWrGgmOc3GiLEJO3ydDxZGodlwUNEVJVRYdrlCh8fsdoSePRGOPBJxyBCEgQMRorv+0VmDwWAwGAwGg8FgMBycfqrw8viqVkyiwI0jYhiyJf6gVqsNr7P98oEkiwLn9IvklY1OIk0iJ/eOONBD2i2CIHDTPYNY+EMt8YlWsno4+OTtMuLiLbQqGtlRMpcfGkeCrX3R9uWn8vl9SSMAVeUe7n36kHa3b+0yX72mKVwArir3sHjLZHdbLfqxlraWAAAb17RQUuiiV5+odtuac142Lmdokr2Tz+5BTKyZkkIXSalWli1qIC7ewpHHprN+dQs1lV5GjU/caZH5r5h0RApX3tyfj94uJT7Rws33DMZi6XxfdofMrfcPCV9e+Vs8Lz2Zj9UmkZ4VKsyrwfY5wSUFrvBycYGTy27ox+Kf62is9zN2UjJnXNiTvgOjKcxzcsjYBHr1iWTxgnqWLWogGNBZsbiRYEDnl+9rGT0+kcGHxDFibAIvP5VPfa0Pn1fF7Qoy7ZjQa7B5fSvffFaFySwSHWNm0LA4YuMs/Ov6XIoLnNz+75UALK2vZ82KJlYvb6KlWUGSBFLSbEyalspxp3bDau3kOTCZ2l0UzKFID0eEiUnTUlixuJHKcpG4BAvRMWYGHxLXrtCvaTr33bIWk0nE2RYgMspEZncH386vone/aKbOSCWjm53XnyukqUGhKN9JMKBz9qU54TxugLbWQLtxtLUonb5eBxuj0Gzo0nRFAY8nVFxWVTCZEBISEKZMQRg8GCE3NxSHIQi73phhG7MZnnxy27LBYDAYDAaDwWAw/MO1+FWKWoP0ijYRZdlx1OJL650ENAhoOq9tdIULzadaTuXZ1nfwNGcyMWn2/hr2Lh3Xy8GsbDvSHzqwu4JAQOOFxzaTv7GVMZOSOOmMHuHbIiJNHHlMRvjytGPS+eazSvpmR3DdhT2JjzZ12N7W4nBoeceFu/hEC6IohCffS0y2trs9LXNbJ7TFKrXLUg5vI8HCDXcNCl9ubVHoHxFDQpKV3O1ydgcPj2Pw8B0OZa8QRYFTz+/JqZ3EU+zK0JHxPPFaPD9+Xc2n75SRmGzlmFOy2q0zaVoK8z+sQBBg4hEpJCZbeeD5EXg9argTfOS4REaOSwzfZ+Lhqfi9GiWFLhob/Kz5vQnFp6H4VH75roab7xvM/A/K8ftCec7RMWbOuLAXAO+/VoKm6fh9Kp++U8agYXHh7Xo9anhZ03TKily4XUG8bhXZFIrqyOrhYMCQ2E4frzB5MmJBAfr69YjjxyP03RZZcfmN/Sjc7KS+xsv8jyqx2SVOn9v+OVUUjZYmBVkWiU+wIEoCwaDGmuVN3HrF72T1cHDL/UOIiJRJzbCTmmHH7pA5/YL22xkwJIZho+P5fUkjvfpGMXZy0p68bF2WUWg2dDm6ywVNTeD3gyyHcpb79kUYMgRxzBiEMWNCE/oZ/jyTCS699ECPwmAwGAwGg8FgMBi6hDqPylULGmlVNOKsIo9MiCeus25IIMYi0rwlgiJmu4L0ZP1o3lkxAskPL22W6Dc+QI9OiqGd8Qd13i9w4VJ0ju/lIMm+687XhnofFSVuevWNIiJy5/upcAVZUeunX7yZ3DgzbX6NMmeQ7Gj5gE4OuOC7Ghb/HJqYb9575QwZEU9O36hO1z3t/J6cck6PdnnK29N1nZGHJlC4uQ1RFJhzXnan65UWufhufhVDR8VhNov0GRDTLrJi6cJ63ni+EE3XGTE2gRknZIZzkXdk6cJ6nnlwE5qqc+ycLI4/tftuPPquZfK0VCZP2xY9umJJA6uXNzFgaCyzz85m9IQkzBaR1PRQEV6WRSKjdvzemX58Bmt/b6auxktzIyh+DV0n3AW8cU0LZouIJAkIosghYxMwbXkvxiVY8LhDGc2tzQqvPpPP6AlJ9OkfTe7AaMZPTWbJgnqS02xERMq0tARoawlgMonExpvRdpIQI4gi0oUXsmFNC+tXNzNwXUt4Aj5BEOjVJ4pefaIYMzG50/tbrRLTjknn608r6d0vCtkk0lDnx2YPlVjLit3krW/lmFO68fB/1uFqC5DdO4Lzjl9ITJyZ0+f2JCnFRrfsCK68uT/BoNYuq/tgZxSaDV2CHghATQ3U10NCAkJGBsLUqaE4jJ49ITOzyx15NRgMBoPBYDAYDAbD38Pqen94wrwmn8a6RoUJ6bZO173+kBhe2+jELIViKbbKbwngViREARQNVjcouyw0b2xSMIsCX5V6+KrUC8DaRoWnJu88q7WizM1/rlmFz6uSkGThzseG4YjofF+17iDX/tKETw3lSt8wPIan1rTRqmikOiQeGh9PZCdZtvvDH3/n7+pn/46KzADPPLiJJQvqEUSYe2XvTguFiqJy3y1rcDlDRcwTz+jOYUduK64WtQa49+Vi7G0BJEHA79M6RGZ05pvPKtHUUHf0lx9Xcvyp3Xn1mXwW/lBHzz6RXHFzP2y2g6cEV5Tv5PH/bkDX4edvaoi5z0zv3D2LKU1Nt/PISyP56etq/vfYZoJKqLsZICs7gkOnJPPt51U4Ik3omt6ui/qKm/vx8Vul1FR52byhlboaHwu+q+W+Zw4hIcnKBVf04YhZ6fzf1SsJBjQyu9mZfGQy61e10qd/NMfOydrRsIBQ/Mf9t65F03Tmf1jBnY8OJbP77sfKnHJOD2RZ4IevqmlqCHXOlxS4GDA0BrNFwhEh8d6rJRTnu4iJMzH/wwp694sib30rV5+/jO49Izh6dhYnnt79b1VkBqPQbDiAdE0LdS63tkIwiJCUhDBzJuKECQiHHYYgG2/PfUZV4ZdfQsvjx4O0b3KiDAaDwWAwGAwGg+Fg0CvGhCxCUAOzCD13UiBOj5C5cUTH0/J7Rsv4ghqNPo1Uu8SgBDOKqnPXb82saVAYnWLlukOiEbdUU59f28a8Yg8AVmlbhbXKHaSk0MnmDW30HxJDeqajw77WrGjG5w1FCDTU+Snc7GwXL7C9EmcQ35YiqKbDV6WecFG92q2yvlFhdKq10/vuis+n8vpzBVRXeJl2TDoZQ2KRBEjZwUR0AKtXNPHRm6VEx5o486JejJ2cRMGmNsZMTOq0qFtW7OKD10uwO2ROPT+bqOiO8Y+KorJkQT0AugaLf67vtNDsdgXDRWaAmipveHlxtY97lrWwtlsk9igLwwpasVh3rwiYlmknf2PbtuVNbXz/RTUAG1a38NPXNRx1bMbONrFXBYMaP31dQzCoMWlaaudZxTtRW+1F3xLTrOtQW+Xd40IzhA4kjJ+aQt6GNjatbWX6iZnMPCGT2HgzkiRy6/1DWLKgnoxudoaP3nZwJTnVxkVX9+Wz98oo2uwEIKBoNNT5SEgKvVfzN7ahBnUEQUAUBfI3uoiOMVNf66O1WdlpF3pFqTscm6KpOuWlnj0qNM//sIL5H1ZQXODE5QzSd0A0Gd3tHD4rndETEvn+ixp++LKapgYfzlYFhNB7r6neT8SW75afv6nhxNO77+lT2uUZlTzDfqVrGrS1hf54PAhxcTBoEOK0aYiHH46Qsf++eP/RfD6YPDm07HKBo+M/XAwGg8FgMBgMBoPhn6JHtIn7x8WzrlFhcKKZ9Ig9L5csrfEjCAIWScBmEsiIkFlQ6WVlfajjcVG1jweW69R5NUYkW/ik0E2rohFjEZFFAbMe6oSeYhO545pVqEEdi1Xiv08O75Ah3KtvZDhj2O6Qyey+4990/eLMJNkk6rwqkSaBKZk2VtYr6ISK6t2i/nxpaP6H5fzyXWjiw4WrmpHO6YUpwsQlg6I4sru9w/qqqvHkvRvx+0JF8ojIUi66qm+H9bb32N0bqK/1ARAM6vzr+twO65jNEpndHZSXuAHI7t153GZsnIWJR6Tw8zc1OCJkDp+ZFr7txXVt/FbrQ4yzIMoiveMkTp/bazeeBTjjwp7EJ1rwelSOOi4jVFzcjtW2f5u7Xn2mgJ+/qQFChe6rbhuw0/VLCp2sWtZETm4U/QfHMviQOLJ6OCgrdpOeZWfYqPid3n9nZFlk4uEp1FZ5aar3I8lCuDM9OdXGMbN33H08dlIS382voqVJoU//aHpudyCi3+AYrDYJn1dFlASELccE1KBO/sY2uvfcceTqoOFxxCdaaKz3k5hiZeDQzvOcd6S60hsef0NdC2t/b6ZbtoPho+OJT7TywWvF5G9oQ1V1LFaRQ8YkMHB4LKXJLjxbMqZ79Nr9wva3n1eyZEE9ffpHc9KZ3bv0Gf9GodmwX2yfuyxERITiMWbORDrqqHbB6waDwWAwGAwGg8FgMBwIObEmcmJNrG1QeG+zi5EpFrpH7V7GMkBBawCLJGCxSTgVnUt+bKCwJRCOqGjxazy+uo2gpvNevgsB8Ks6kWaRa4fHcFqfCBRNZ+WPtfwWDHVb+n0qJYWuDoXm3rnR3HL/YArznAwaHrvT7s1Is8hjE+MpaA3QLVIm1ioRa5VY36gwPMlC6k66j3dla8EYoLotSHpQRwe+KPF0WmjW9VC37VaKfydhuls42wKdLv/R9XcN5OdvaoiONTN+Suf5ugDnXdab407tht0hhzt9A6rOhuYAug6qWSQxO4KbTk5DEnevoGc2Sxx7Srfw5ZhYM2de1ItFP9aS3TuSiYen7NZ29patXcAAhdstd6ahzsdd169G8WsIAtx0z2D69I/m/x4eSlODn7gEy27FO2hffYX2008Iffognn12u2LoE/dsCHeSv/1iEZdc2/FgQWcSkqzc/9wImhv9JKVY20WnpGXY+e+TwykucJGcZuXB29fR0qRgs0sM2EXhODrGzN1PDqeq3EN6ln2PY02mTE9l5dJGfF6VxGQLWT0iEEWBT94po3e/KIJBHVEEVQPZJDByfAJX3zaQQEDjhy+rCQQ0ps5I26185qJ8J68/VwiEurjTs+yMm7zj9/eBZhSaDfuMHgxCQ0MoGsNqDUdjSEcdBTk5COLfK4fGYDAYDAaDwfD31drayrfffktcXByTJ0/u0t1Efxe6rh/0z7Oi6pilg/sx/F2UO4P8VOGlW5TcLnt5a6Hn5wovtR6VjAiJe5e3ogPv57t5enICiX+YmK+0qH2UQ3RMKMphUrqNH8u9KBrIYigbOcIksLlFpdmnYpEEApqOADT7NXpEythMAiICc3o7iNiSkzxgSCx2h4zHHSQ61kxObucZwVsnLdsdEWaRIYnbitEDE8wMTOgYQbGnjjoug7z1bVRXeBg4Iw3nluei+w66pGVZ5LzLevPOy0XExJo56czuu9zH6XN78srTBdjsEiec3m2H60VFm5l10s6zebeKi29fmJdE6BYpIwsCflXnpBzHbheZt9fcFJoUzmqVmDojjakz0nZ9p33g0CnJvP1iEQATpu68KFlR6g4X/HU9lF/cp380siySlNJ5Tvkf6SUlqE89FVpevx4hMxNh6tQt29RRlG0HFPy7cXBhe1arFJ6A8I8SkqzhKI27Hh9GwSYnWdkOEhJ3HQVjt8u7/fn5o159ojjq+HTefqEIj1ulrsZHSpqN+AQLsXEWIqJkzFYJ1R1E0+DLjyqYNC2VhEQr61c1Iwjwy3c1VFd4GT0hkYuv6bvDv++2RuRs5fWona7XVRiFZsNep7e1QW0tqCpCQgLChAmIxxyDcNRRRu6ywWAwGAwGg6FLamlpISIiAnm7f69+8cUXfPbZZ6Snp1NYWEhlZSWyLPPqq6+SnZ3NqaeeSk5OTodtLV26lJdeeono6GiuvvpqkpO7budRV/Xhhx/yxhtvkJiYyO233056evqBHtIe0XSde5a1sKTGT3a0zN1j4sJFRMP+51I0rl/YiDOgo+k6qgaj4k08cNtaCvOc2PtEUXFoMoIo0OJXCagQbQm9XmXOIE0lLlb91kifATEMOSSOx+5eT0OdHwBV3RblMCDBzHNTEmnwqryf7+K7Mh+iAKoOfePMtPhVnAEdVYcYs0CSXcRukugdYwpPxresxkeJS+Xy+wbjq/HRs09kuJDdFcXGWbjj4aEAuAManxZ6MElwdI8dR3kcelgyhx62+9+LE6amMH5K8j498CQKAreNiuXtPBdxVonz++84dmFHXnpyMz99HYrkuPY/A8nO6biNTetaWPhDHT16RTBl+r4rQh91bAYDhsQQCOidjmN7vftFk5Juo6bSS0SUiaEjdy8mY/PGVoo2Oxk6Mp5Et7v9jdtdFgSB8y7vzRvPFxIZZeLks7rv6cPZLVHR5r8U8bGnFv9Uj9kikZ0TSVurwpTpqZx4Rndsdpl3Xyli84Y2tC0Hlmqrfbz3aglBRaO+1kdttRePO0iPXpEsWVDPlBlp9OnXPgN7xZIGFnxXS/eeDg49LImlCxvIyY3i0J1063cFRtXPsFfoTmeoc9nrBVFE6NsX8eSTEcePR8jMPNDDMxgMBoPBYDAYOqXrOvfddx+LFi0iISGBe++9l+TkZBoaGnj22WfRdZ1169axbt06LBYLoigSHR1NU1MTBQUFXHHFFfzvf//D4XBw9dVXk5aWxoMPPojP56OqqoqXX36ZG2644UA/zIOKx+Ph1VdfRdd1qqureffdd7nqqqsO9LD2yNoGhSU1oUJkUWuQ78u9HNPTmBflQGnwqTT5NfKaA3gCGs+ubSWoqRTmhSIF1v7WiJRqx51qp8QZwCyKSC6YmmWjvtrDjdeuIkoScJgrGHxBDt/G24gWJbJrPO2iHAKqToJNYl6Rh8XVfhp9Kok2kZwYGVkUSLBKDIy3YJIETu3tINIs0uDTGJtqQRAEfq3ycc/yFgCizSLPHpZwUB2gcJhETu27+7mze2J/nN2QG2fmP2M6n1BxV1qaFX76OpSJ7HYF+W5+FXOv7NNuncYGPw/cvo6AorHg21Bu876MQNjdye3sDpk7HhlKWZGb1Axbp5Mt/tGmdS3cc9MadB0+e7eMe54aTsThh4ejM4TDD2+3/pgJSYyZkPSnHscfNdT7ePiO9VRXejj65CyOm7PjLvd9qXvPCKrKPVhtEqMnpHPWxaEDz7XVXpb8Uo/XE+pm9npVYuMtCEBNlYfifBc+n4psCn22BQEiItuXZ+trfTxx70Y0VWfl0kbOvSyHuf8Oxc4uXVjPlx9XkJJu46yLe+1x7Me+1rVGYzio6JoG9fXQ0gIWC0JWFkLv3ogTJyIccQSCvfNTGwwGg8FgMBgMhn2pqakJRVFISdlxJmZTUxM//vgjzc3NvPrqq2iahtfr5b333mPGjBlERm7rACsvLycYDKJpGoFAgNTUVBRFYenSpcyePZuUlBTi4uJ48cUXufbaaykuLsbtdpOWltahOOJ0Onnssceora3l5JNPZvz48fvseThYybKMxWLB5wtN/rX9a3GwiLaICIC+5XKs9eApFnZFq+r9PLqyFQE4t18kQ5Mse1SAzYiQsUoCTr+KKArUezVa7Ns+m7EWiTVBnbbWAEFNJzdRQhJFhiSaue3LGlpbAkiCQFaUzMfLmojqG0VZiYcUUefEM7oD8PTqVr4s9ZLukPAENVoUjdYtcQF3j41lTUOAMmeQKncQQRBY2xjgokHtT9vf3LKtaN2qaNR51f1aaPb5VJ55cBOlhS4OOyqVo0/evRiKfUlRdUzi/ik0/xV2h0RElAnXlgMPSSkdoxuaG/0EtouQqKny7rfx7YrNJtOnf/SuV9xi84Y29C1fcC5nkMpyL/0uvxzp8sv30Qi3+eKjCipKQx3TH79VysQjUjpEoewP516WQ1Z2BJqqM3W7SSUL8trw+zRAQBTBZBLJ6RfF1BlpvPJ0Pm5XEEEMTQY4aHgsYyclkZ7Z/kBkW6uCpurhyy1NocklnW0Bnn1oE2pQp2izk7gECyef2WO/PN7dZRSaDXtMDwahqgpcrlDu8vTpiJMnI8yaZeQuGwwGg8FgMBgOqF9++YWHHnoIVVWZPXs2p59+eod1gsEgl1xyCXl5eZSXl+Pz+bDb7TQ2NtLY2Mg333zD4YcfzjnnnMMtt9xCRUUFmhYqDpjNZqqrq2ltbSUmJoby8nKam5sZNGgQgiDw2muvYbPZaGhooLa2lrPPPrvdvt9++22WLl0KwMMPP8zw4cOx2+1UVlby6aefEh8fzwknnNAuwuOfxmw2c+utt/L++++TmJjIaaeddqCHtMe6R5m4alg0Cyp95MaZ2mUCG/bcs2vaaPRpVDiDnPltPcMSzdw4IpZDknevuCSLAoMTzCysCh28aFM0Dj0yBasrSN76VhIGxOAXZdoUldK2IF4VEkwCb2xyUR5hwhJlwu4MIjhkHL0jMUWZiYw1Y7PFc12Bh0leje/KQ9uudKtEmQTymwP4NR2/qvNOnpu3jkpi7vcN4YLpslo/F/1hnGNTLXxS6MYd0OgfbyYzYv9+D3z3eRUrlzYC8MHrJQwbHU9G1oHrxP/fujY+K/KQZJO4a2zsX5q0cF8zmyWuv3Mg335eRVKKlenHZ3RYZ2thcc2KZuISLEyYun8nCNybhoyI45P3S9jkLoTkVooyffTjiP2yb/t27wPZJGI+QF3/ZrPE9OM6vs4ZWQ669XBQUuRCFAXGHZbEXY8NJy3DzsdvlzLokDgEoHe/KK75v4Gdbjs7J5IxE5NY/HMdqRl2Jk1LBUKZ8mpwWwF6+8k4u4qu+yk1dCm6roeiMWpqQJYRYmNDE/udfjpC7u7NFmroQkwmuP/+bcsGg8FgMBgMfxPz5s1DVUM/vD755BNOP/10mpqaeOSRR1i4cCE9e/Zk7NixfP3117hcLoLBILIso6oqgiBQVVWFIAg888wzJCQkUFRUFPq38BZms5mePXsSDAbJz8/H7XajqiplZWUMHjyYdevWhbelqipmc/tTkAOBbR2Lmqah6zq6rnPzzTfT2Bgq8Pj9fs4888z98Gx1XYMGDWLQoEEHehh/yaQMG5MyjALz3mCRhVCUikfFIQsoGnxa5OaQZAuNXpWn1rThVDTO7hdJ//jOT/uv9apkRcq4AzpJNolUh8ysk7KYdRK0+jW++7EB0Im1SoxMshBvk/itxke1TcZ7XDcGWQX+d3wabxR7WV7rJyCK/Fbrp8Wv8WuVj5wYE7HW0KSBsVaRoKbjDeigw5pGhW/KvAxPsvBWnoui1gBpETKr6v3tJugTBQFBAEWDWIuIvL/rZ39oGhb/xGR4e0udR+WzIk9o2avyaaGnQwd4V9MtO4LzL++9w9slSeTq2wfQ2OAnKtqE2SztcN2uLqtHBCMfLqek4Cesfdp4XvqBMdpw4sV9n5E866RMnK0Bqis9HHVsBhGRXaum0S07ggdfGMnnH5SRmGzj9Lk9sdtD5ddzLs3hpSc2Y7FKnHJu9g63IQgCF1/Tl3Mvy8Fi2fY+iY2zcPJZPfj8g3JS0m3MPLHrRdUahWbDTum6Di5XqIPZ4UAYNAjpzDMRRo1C2MmpiIYuzmyGa6890KMwGAwGg8Fg+FP8fj/PP/885eXlHHPMMYwbNy58W2ZmJhs3bgQgKyt02veLL77Ie++9R2VlJYsWLeL1118nEAiEC8hbC9MpKSm4XC42b96Mruvk5eW1KzJD6MdfXV0dPp8Pr9dLIBBAkiR8Ph+PPPIIp5xyCnl5ebS1tWGxWLj//vu55557gFCRediwYeHb58yZg8PhwOfzhYvMAJWVlfvuyTMYDkJXDY3m+XVOqt0qcVtiSNK3dDW+sN7Jx4VuGr0qP5R7WXpKOvOK3TywopVIk8iD4+MYmGChV7SJSpcKuk5OrIkWv0rMlgJOtEXkofFxnPFNHSkOiQq3ilkSsMgiGREylYAab+K7WoVrh8cAoaiMRVU+/KpOUAttY1iimdUNCp9sciL5NWQpFKGSGSHT7NO4cGAk35R50HSZWIvI82udPH3YtkLzt2VeghpEmUWW1ynUeNT92sV7+Mw0yopclGyJzkjLOHBxmHZZwCIJ+LfEB8T9TeJnBEEgIbFjrMbByJYYxBHdBIRiglQ6766t0+p40PsgLXoLZ1vOZqxp7F/ar8Uicc6lHSfi7UoGD49j8PBted+ff1DO8sUN9BsUw1NvjtlpFEwgoPHZe2U0NyoceWx6h7MKZp6Y2SULzFsZhWZDp3RNg7o6aG4Gmw1h5Eiks85CmDq1y2cjGQwGg8FgMBj+3j766CO++eYbAPLz8+nfvz8xMTEAXHjhhSQlJeHxeDjmmGOoq6vD5XJRXV2N3+9HVdUOxWNRFDGbzbS0tODxeMJdxp0RRRGPx0NjYyN+vx9d19E0Lbz9hoYG2traCAaDBINBHn74YQoLC/H7/axevRqLxcKgQYO48sorKSsrY+HChRx66KHMmjWLefPmYbVamTVr1m49D7qu8/LLL7NhwwYmTpy42/czGA423aJM3D02jiuGRPNRgZsos8iJOaHiS7kzSJUrCEC1W+W9zU5uX9JC25Ys3OsXNvHFsalcPiSa7GiZD/LdbGoKcP53DfzfqFgGJIQ6oGOtEhZJZGvzYKJdYk6fCB5Y0UKcVUQWBT4t8jA5w8bLG5wUtgQwi9Dm17HKArUelexome8LXdS3BgkC5mCQ1AwbvWJMHNXdjiAI9IgyEdgS0+swtf9tnRmxrXMx0iQQY9m/xVWLReKSa7vGGcsRZpFbR8Ywr9hDRoTM8b2MyTS7muMtx7NZ20y5Ws6x5mNJEjuf7O8V/ytsVEMHgB/yPcRoeTSi8Pc4cNAZjyfId59XIZtEps5IpWizk/deLQZg0Y+1fPx2KcNHx2OPkFm9rImcflHMOjGT+EQrCUlWPnqzhPkfVgCwZkUTj70y6qCqwxmFZkMHemsrFBcjpKUhnHoq4pQpCGPGIJh3PfOo4SChqvD776HlYcNAOnhP2TEYDAaDwfDP4/F4wsvBYBBFCU2Ss3r1al588UUiIiK49NJLeeSRR1i0aBFlZWUoihKOqvgjTdNQFIVgMLjLfbe2ttLa2trpbU1NTTQ1NbW7TlEUvv32W7xeL5qmIQgCFouFa665BggVru+44w7mzp3L8ccfj6qqvPLKK8yfP59LLrkkPBHemjVreOSRRwC4+uqrGTBgAD/88AMff/wxAHl5eeTm5tKrV69dPgaDoStq82t8VOhGEuCEXg7spo6FqCS71CE+4biedj4vdhPUoFuUjCe4bRJGAL8WumSWBCZl2Hh5gwtJDHXKflfuDReazZLAMdl2Pi3yYJUEju5hZ1CihckZNl5Y76TFrzIsycJ/fmvm2zIvnoCGSRRIjZBJtkvEW0U0HaqagmiyCALIisr/5UZwyqhtcQJXDYvmf+vaEBA4va+D+5e3UO4KcnQPOzN62BEFgUp3kMOzbNj2e3ZG1zI40cLgxP0/yVtXVKwWU6VVMVQeil04cJ3m24sUIrnbfjcrgit42PswHykfcY3tGobIQ9qtJ2yXySL8MZ/lb+ip+zay9vdmACpK3Yw8NBEArydITaUXs0Vi4fe1eD0qqqbz/RfVvPzEZrr3iuSiq/tSW+0Lb6ulScHv17BaD56ajVFoNoTpmgYVFeD3I06fjnTllUb+8t+VzwcjR4aWXS5wGEeHDQaDwWAwHDyOO+441q5dS0VFBccddxxJSaEuqgceeCBcBL7vvvv48ccfKS4uxuv1YrPZwnnMoii2i87QdX23isx/VktLS3hZkiSqq6vxeDz4fD5EUeTqq6/m888/JyMjgxkzZrBixQogNLHh559/DsAzzzxDQ0MDAM8++yxPPvkkXq+33X7+ePmvcrvd3HXXXRQUFDBt2jTOP//8vbp9gwGgqDVAg1flowI365tCGeaVLpUbRsTs8r7lziABDa4cGsO6RoXcOBNn5UaQ3xzg/QI3ZhFGJln4IN/FsT0dRJpE4qwiTb5QS3H3qPYlkfMHRHFsTwc2WcCxpdDtMEGZM0BQg6U1PnpGy3i2tCRbJCFUZLZJjEmxcGZuBB+vaqGsVkHSQLPJpP6hUJoeIfN/o0On1L+5yckvWyYofGJ1G8OSLEzv0TWKiIauY0VwBf/x/AcNje5Sdx6xP4IsdJ1y3v98/6NNbwPged/zPB3xdLvbz7KcRZPWFI7O+Dt3MwOUFLrCy6WFLi64ojfjDkvml+9riI41ExtnxuMOouk6NZVeFEUjEIC89W3cf9ta/nV9Lja7hNejctRxGQdVkRmMQrNhC93thooKhKgohMmTkR54AMGYJM5gMBgMBoPB0AXFxcXx6KOPdrh+a7FY13WKioooKirC7/ejaRput3s/j3LHVFUNd2VrmsbGjRs577zzOOecc1i1ahVerxez2UxhYSE+nw+r1YrVui3Tc+vy1KlT+e2339i4cSMTJkxgwIABe3Wc8+fPZ926dQB8+umnTJ48mZ49e+7VfRj+uRZUerlveQubmgL0jDFR7Q7SPVIGQaDCtesDP5WuIFctaMSn6lglgUcnxpMeIZPfHCCgw9HZdmrcKuuaAqxrCuBUNBJsEjnRJmrNKqOSLRyT3bGom2BrX9TJaw5iEgVMIgQ1GBBvod6r06poZEXK3DkmjpEpFsxSqFPz3NHxVC1ooNmrkhprJilmx2cGB7Vtyzqgdp7Ys0MNdT5WLGkks7uDfoNi9uzOhoPGsuAyNEJvlhK1hFqtlnQpHYBfq3yUOoNMSLeSHnFgSnwOYVvjWoQQ0eH2JDGJexz37M8hHVCHHZXKp++UIQgw+chUBEHgwn/34cJ/9+GbeZX89HUNmd3tWG0S/3tsM8GghtsVRBDBZpeprfbx2Kuj8ftUonfy/dFVGYVmA3pdHdTXI/Tvj/Tf/yL0748g/r2PMBkMBoPBYDAY/n7+/e9/87///Y+qqir8fj9ms3mvd/n+Vbqu09zc3O66QCDAihUrqKqqwu124/f7CQQCzJgxg8rKSsxmM3PmzOGTTz5BEAQuuugiIFRwvuSSS2hsbKS1tRWXyxWO2tgbbDZbeFkQhHbFboPhrwhqOo+ubKW4NYgroFHhDOIwCag6mEQ6LQD/UV5zAN+WyqxP1dncHCA9QuaRla2Uu0LdgnnNAXLjQoWaz4s9OAM66xoVzKJAjVtlcqaNZLuEJITe400+lQ/y3by5yUlRW6jwfd0hMXxQ4KbJp6IDDT6Nt6YlIogCCVaJjMj2ZZVp3Wws6xPJ5uYAkzOs5MaZUXSFzepm0sQ04sRtE4Qd38vB5pYA5c4gx/Z0kGTf/c5FjzvIf65dRUtTKDroqtv6M2RE/C7uZeiKdF3faQbvIGkQ85kPQKqYSqIYimJYUOnlgRWhs3jmF3t4bkpCuBN/f7rKehUv+F9AQOAC6wWdruPzqbzzUhENdT5mnphJ3wEx+3eQ+9EJp3Vn5KGJyLJAanr777IjZqVzyNgE7r5+NfW1PsZNTiIqxsT3X1Rjs8kkJFvpNygGq1U66DqZtzIKzf9gus8HpaVgtyNMmID8xBMIe/EfpgaDwWAwGAwGw/40atQoRo0axRNPPME333zDkCFDWLhwIaIohnOcDzRN0zq9vqWlhZaWFmRZJiEhAavVyurVqxk3bhy6rtOvXz+OPPJIrrvuunBB4s033+SFF14gLy+PHj16kJuby2OPPYZjL8WiHXXUUVRWVlJQUMARRxxBenr6XtmuwSAAoiAQaRZp9KkIAoxOtXLbyBgkUSBuNwosA+LNRJgEXAGdSJNA//hQQVndEokjCkIoszmgUe9VSbRJeIIaqqbj1XS8QY2X1rexvE7BIQvcNiqWx1a18luNn/VNChZRYLMa4KsSL4tOSuPsb+vRdB1vUOf1PDcPT+i8qGuTRe4eu62YrOgK13muo1AtxCbYuNd+L9lSNgCRZpGbRsRglQQkcc+ya2urveEiM8DmDW1GofkgEwxqPHHvRlb91kjuoBiuuq0/ZnPH9/5Y01juEe6hUqtktDwasxB6rxe0BMLrtCqh9/mBKDSnS+ncbr99p+t89GYJP3xZDYTeq0++MbrTx/p3kdltx38P//pjHfW1ocic2iof513Wm6tvH8iSBfXEJVgYckjcDu97MDAKzf9AuqKEspiDQYScHMSzzkI86aSDahZLg8FgMBgMBoNhR6ZPn87ixYsBGDlyJI2NjWzevLnTiQC7iq0FaEVRCAQC+Hw+2tracDqdBAIB1q1bh8Vi4bzzziMhIQGAl156iby8PNxuNzU1NcTFxVFcXNxphIaiKJj/MLn3O++8w5dffkmPHj247rrrsNvbd17Jshzunv67aGpqYtOmTeTk5JCYmHigh/OPJYkC1w2P5vVNLgbEmzgiKzQRXoR510UyRdWZX+whoOncNy6OMqdK3zhTOPLissHRPLG6FUkQuGxIFDf/2oRJEnApGq6Ahk/VkQSBRp/Gr9U+ZFHEGdB5c5OLCpeKLIamK1P1UEHcbhJIdshkR5soc4YiPSzS7v92LtaKKVQLAfDqXhYFF4ULzc+saeOLEg9xVpG7x8R16I7emfQsO5ndHZSXuJFNIkNGHtzFqX1JUXU0XcfaxSZXXL28iZVLGwHYsLqFpb/UM35KSqfrDpAHMID23+3j02x8WeLFp+rkxpnIOEDRGbujrXVbUdznVQkGdMwHXyrELq1Y0sD3X1SjKBo9ekUwZmIS2TnbGjq//6KKZYsbcLuCOCJkJFkgNt6C3S5z2JGpB3Dke0/XfRca9gm9rQ2qqhAyMhAvvBDxmGMQtjslzmAwGAwGg8FgONj17NmTl156CZfLxYMPPsj8+fORJGmfTvi3NwiCgCiKDBo0iNLSUurq6lAUBV3X8Xg81NfXExERyr9saGigtLQUv9+Pz+cjGAwSHR1NVlZWu22qqsrdd9/NsmXLyMnJ4c4778ThcFBeXs6bb74JhIqv77//PjNmzCAhIYG8vDwaGhoYMWJEh+L0waypqYnLL7+c1tZWHA4HjzzyCKmpf48f9gejkSlWRqbseRzLU6tb+aEi1A24oUkJT6znD+psbFZItUs8NyV0EMGpaAQ0MIkCsVaJzAiZGEuQoAYRJhGHLODfcpJBvE3iyG42vizx0CPKhCDAIUkWrh0eA8DVw6L53zonkgAXD4rqMK6vSjy8u9mFO6DTN9bE5EwbkzNtpAqpRAqROHUnAL3F3gDUeVS+KAlltTf5NOYVezrd7o6YzRK33D+YvPVtpKbbSE41ftd3Znmtn3uWNRPQQq/bUd27zmSLEZHt58WKjNqzebJyYk08NyWBcrePpdb3eMhfx7HmY+kj9flL49JbW9E++ABkOdSUaP/rz9mskzLZtLaVliaF40/rht2xZ+XIfDWfd/3vEivGco7lHOxC13kdt1q9vJEbL1mBzxektspHYoqVn76u4f7nDqEwz8lrzxbw6091KIqGIMCcc7OZfnwGyak2vN4gmzeEPstJKTYaG/zYbNIeP09dwcE3YsOfoqsqFBcDIE6dinTXXQjxxmk1BoPBYDAYDIa/J6vVisViYcOGDXTv3h2fz0dRURGCIKCq6oEeXqd0XSclJQWr1coJJ5zARx99FM6Y3trl/NRTT3H11Vfjcrno2bMntbW1BAIBjjjiCG688UaiotoXqlatWsWyZcsAyM/P56effmLGjBlIkoQgCOi6TktLC8888wwffPAB/fv3Z/369QD069ePe++9929z5uOGDRtobQ3lmbrdblavXm0Umg9CRW3bDhgVtoaWg5rOjb82kd8SwCzCnWPi6BdvJtIscnS2nc+KPESaBA5Ns/Jlaegzpes65/WPZGW9QqRZ5Jx+kUSYxVBntUnsMClgdrSJe8Z13jXsVDSeXtNGi18jr1lhY7PCqgaF9AiJ3rFR3G+/P9zJPEIeAYDDJGCVhHDOdLx1z7ttbTb5oD/Nfqsmn8oDK1qp86ic2ieCKVl7p3D+zmYXypaDCa9vdHapQnOf/tGcPrcnvy9tZMCQWIaMiKdBa+B95X0sWDjFcsouC6pxVol5fMA85SNQYVVwFa9FvIZJ2L2itVt383PgZ+KFeEaZRgGg3nsv+paJYKmpQbr++r/0OAHSMx08+vIoNE1H3MOYGF3XucNzB6166PtbQOAS6yV/eUx7U0uzwv9dvZLNG1pRFA1RBKVMQ5IE8je08fSDm1j1WyN1NT5kWSAy2oTVKjFoWByNDT7+dfoSWpsVUtPtDBwey+9LGrFYJf59a/+DbqJPo9D8D6ArChQXIyQlIZ53HuLJJyPspdw2w0HKZILbb9+2bDAYDAaDwfA3JAgCQ4YMYeXKleTk5GCxWMJdwCaTCa/X2+XiNKqrq4mKiqKlpQVd17Hb7Xg8HgRBIBgM8uabb3LmmWfSrVs3YmNj2bx5M9nZ2dx8883hSI3txcbGIggCiqJQU1PDihUrOPzww0lLS2Pu3Ll89dVX+P3+cIH6s88+Izs7G6/XyxdffMHQoUOZPXv2TovNuq7z008/4XQ6mTp1aocIjq4iJycHq9WKz+fDZDLRt2/fXd6nqamJO+64g7KyMmbNmsW55567H0Zq2JlpWTaeX+dEB47sFipGVriCfFfmocGr4TAJ/FThpd+WzOYLBkQxOycCqyyg66Es2zX1CrVejafXOhmdYuFfg6PC7/Hue9hVCiAKIImhiAYIFcJ0oMGr0TsWMqQMZkuz293HYRK5fVQs80s8pDkkju/1z/yNvqrejyegs7zWz7rGUOb0E6tbGZtmwbYXoi4SrBJ5hGIb/njwoCs4YlY6R8zaln9/l/eucNRKs97M1bard3r/Bq2BTeomdHQEBFy6Cx8+TLR/H3+ufM7HysdkiplcbbuaSCESXde5yXMTRWoRAHP1ucwyzwpFrW6hV1burYcKsMdFZgAVlTa9LXy5RWvZiyPaO+prfVRXeJFNIoqioaqg+VVKCl3M+6CMqgoPXk8QQQBNDz0PaZmhvyvvun4161aGJgn2eVVKi12kZdjx+1S+/qzSKDQbuha9rQ0qKhCys5EeeABxyJADPSRDV2A2w//934EehcFgMBgMBsM+d+utt/Lrr78SFRXF0KFDaW5uprq6mlmzZtHY2EhbWxu6riOKIpIkoev6AY3Y0DSNzZs3Y7PZ8Pv9mM1m4uLiqKurIz8/H1EUue222zj11FNxu93069cPURSprq7utNCcnZ3NFVdcwa233oosyyxbtoxnn32Wyy+/nJkzZzJz5kyef/555s2bB0D37t3RNI1NmzZhsVh48803sVgsHHfccTsc85tvvsm7774LwMKFC7n//vv3zZPzFyUnJ/PII4+wZs0acnNz6d69+y7vM2/ePIqKQkWYjz/+mGnTphmTIu5juq7jCuhEmIROD3DMzHYwNMlCUNPptqUo3OrXaPZrqLpOm6LT7G8/6WaUZVvB8sYRsbyT5+KNTU50XWdJjZ/NLQH6xHaMiVlR66fMGWRcmpUk+46LlA6TyL+HRvPmJheiANEWkQHxZg5Jtuz0sQ5IMDMgIbTfIrWIX3y/kCPlMNY0dqf3+7v4IN/FqxtdAGxfUhaEUD723nDp4CiiLSK+oMacPhF7aav7To1WE16u1qp3uu664Dpu995Oi9ZCvV5PN7EbJ5pPJFKIbLdeo9bI877n0dGp0+r4yP8RZ1nPwoMnXGQGWKeuYxazEE88EfXFF0EUEf/w3f+O/x2WB5czTB7GqZZT98Ij3jVZkDnHcg6v+F8hUojkZMvJ+2W/e6J7zwgiokw01PsRBND10B+TWeD9V0uIT7Tg92tExchYLDITj0jh6NmhqKv6Wh8mk0ggoOHxBOndLxq2HANPTT/4InGMQvPflO73h49CCePHI991F0JGxgEelcFgMBgMBoPBsH+ZTCYmTpwYvhwbG4skSSQkJFBdXY0kSWiaRlxcHHa7nerqnf+w3x9UVcXlcoWXPR5PuPNa0zReffVV4uJCp8uLYqg8oyjKDrc3ZcoUnnzySQoLCykuLiYvLy98m67rJCQkEB8fT/fu3bn44otZv349N998M7GxsQBU7qKjbePGjeHlvLw8dF3vsnEbGRkZZOzB7yLHdmeCyrKMzZjfZp/yBTVuWdxMXnOAPrEm7hoT2+kEbunbTXrW5FN5K8+FLEC0XSLWIjEsaecF3ha/yu/1Cpqu0zPaRKylYxF5YaWP+1a0APD46lamZtiYYWpk4JJvICEB8fjjEeRt45iQbmNCui2UqR7UcZh2vxu3SWviBs8NePVQrMct3BKOMdjbmrQmfgz8SKqY2q6g7XEHsdml/frZ/a3WH17WdJ1hSRbqvKHojL01cV+kWdyj7OsDbbZ5Ni/7X0YWZE4wn7DTdX8I/ICiK9gFO1lk8bTjaTKlzA7rCQg06o14dS/x4rYIVYfgYIg8hFXBVQgIjJPHAYTm8ho/HiQJITo6vP7vwd950x/K9s9T88iRcsJRMPvacZbjmGWehcT+fY/urqpyD4nJVuqqfXjdQUQRNA3UoI7ZLJDZ3YHZItLWEiA23sLEI1KwWkPfO1OnpxFQNNpaFE6f24sp09P4+tMKomPNzDih4+vZ1RmF5r8ZXdehrAwUBaFHD8QzzwyFt8vGS23YjqbB1h8Eubkgdq3Zdw0Gg8FgMOxfCxYs4IEHHmDFihVUV1fz8ccfc+yxxx7oYe0zUVFRDBkyhA0bNoQLzQAtLS2oqookSZjNZrp160ZRUdFOi7h7myzL7Tqqt45tq61F3N9//50hQ4ZQWlrKmDFjGDZs2E63a7Vaqa2tRRAEamtrw9d//fXXvPzyy0Aot9hms3HYYYdx/PHHs2DBAhwOB9OmTdvptidOnMiaNWsAmDBhQpcsAvxZxxxzDI2NjZSVlTF9+vRwgd+wbyyt8ZPXHIo5yGsOsLjaz+TMnRf3n1vbxoamAEl2GXdA44y+ERyxi3zf/JYAaQ4JT0An0ix22q28qTn0uW/wqhS1BpA1jZHP3oTX4sEiCaAoSKef3uF+giDgMO3ZZ6BGqwkXmQGKtWJGsfcLzUE9yPWe68Nds5fql3K4dASP3b2BVcuayOjm4KZ7BnWYpG5fGZpoYWNT6PUelWrllpGx+2W/XdlxluM4zHQYsiDjEDrGqbzue51X/K+QKWYy0zwTAEVXqNfredz3OEeajiROjGOgNBBZCNWBlgeX49E8lOvluHRX+H4At9tuZ5W6ijghjmwpO3y90Ml33fbv0c4u72tbH8+B9P2XVSz8vpYxExM5Yta2g5YVpW5MJpHM7nZamhWsVgFF0UnPdJCQYsVskfB5NXr2jcJqlfjhy2qOP7U7AGdfksOEw1OwO2RS0kLfXWddnHMgHt5eceBfJcNeo3u9UFiIkJKC+O9/Ix59tDHhn6FzXi8MGBBadrnAyOw2GAwGg+Efze12M3jwYM4991yOP/74Az2c/eLcc89l48aNFBQUEB8fT58+fVi2bBk+nw+AyMhIrr32WlpbW3nttdcoKirC5XIhiuI+jdaQZRlVVXeYHS2KIlFRUciyzIwZM2hpaWHAgAG7LO6mp6czaNAgRFFE3q4JpaqqKrzs8/loamoiKiqKa665hjPOOIOoqKhdZi4fccQR5OTk4HQ6GThw4E7Xzc/PB0J5yQcDk8nEhRdeeKCH8Y/xxwzdxN3I1PUEQ5+VJLuEXZaZO3DX3auxVolUR+hz0D2q87LImFQrX5R4UNRQd3KkpuBwthAwmUKF5r2YXdtL6kWOlEO+mk+kEMmh8qF7bdvba9Fb2kUz5Kl5ZG0azaplTUCoWPbL97Ucdez+ORt6Tp8IekbLeII6h6ZZO9y+LriOGq2GMaYxnRZdDyalRS7Wr24hd2A0PXpF7nTdaDG60+trtBru8N6BU3eyTl1HrBDLVbareM73HLqu82vwV972v81QeSi5Ui7/tv2bVDGVDeoG6rQ6FBRK9BIObzucW2230lvszfLAchRdIUaOIV1IxyLu+GyA0fJoDjUdGo7OGCvvecSLU3fykPchKrVKjjcfz1Hmo/Z4GwfKymWN3HLZ77icAT56qxSzWWTStDQABg6LJX7LmRSp6VbaWgKkpJl5/LVRdOsZybJF9fz4VTVV5R4AMru3fz9n5+z8PXEwMQrNfxO61wtFRQjDhyPdfDPi0KEHekgGg8FgMBgMhoPEUUcdxVFHHTw/9vaGUaNG8c4779Dc3Exubi5LlizhlltuobGxEUEQSE9P57jjjsNqtfLcc8/h9/vRdR1VVdttRxTFDl3HO7I76/p8PiIiIvD5fASDQSRJQpJCpwrbbDbi4uKQZZnp06fz6KOPhnOcH330UTIzQ6fY6rrO0qVL8Xg8TJo0CVEUOfbYY1m6dCkAhx12GBs3biQ3N5cjjjiCH3/8kaamJiwWC59//jknn3wySUlJpKSk7HCcbW1t1NfX061bN2RZpkePHrt8/G+//TZvvfUWAHPmzOHUU/dPvueurFixgg0bNjBixIjdmiBwX3rrrbdYu3YtY8aM4eijjz6gYzkQ+sebuXJINMvr/AxP2pZfvDNn9o2k0tWMO6Bzet8InlnThkmE2b0jiDR3fubmZYOjiTQ58ak6Z/TtPLe3f7yZpycnkNcc4LWNTuq8Gk2TpxGx4ScEmw1x1qy/9Fi3ZxbM3Ge/jxKthBQxpUPG7t4SL8QzSB7EmuAaZGTGm8YTHWsKZ8oCxCXsPHZkbxuZ0rHADLAgsIAHvA8A8InyCY86Hu0SHa1/RlWFh/9cu4qAoiHJAv95ZCiZ3fc8L1rTNVy6K3y5Qq9gsmkyCwILWB5cTrlWjopKo9bI04Gned73PIliIslCMo004icUVbJSXcnxro4HlfsJ/VgYs5BYMZavlK/4OfAzfaW+nGk5E0EQkASJ623X//knAvjA/wErgisAeMb3DKPl0cSKXaOT/efAz+Sr+Yw3jaeP1Cd8/QPuB3hdeZ2ImmG0OWcRTGtAF1Q+/6qQCYenoOvw0pP51NX4SE61YjLH4nYFkSSRX3+qx2qTee/VEhSfiskiMvOETI467u8bbXtwfkoNYbquQ2lpKCpj4EDkO+9EyM090MMyGAwGg8FgMPyN+f1+/P5t2ZptbW07WbvrSktLIy0t1I00duxY3nzzTcrKytB1naFDh2KxWNB1HV3XsVgs4QiNrbnIJpMJURTx+XztOpAFQejQkTxhwgSqqqooLCxsd5vFYmn3XEKo2Lx913FkZCSZmZkEAgH69OnD7Nmz+eqrr9i0aRNZWVkoisLmzZvDhebHH3+chx56CJ/Px6GHHsoFF1zAFVdcgaIoBAIB3nnnHRYuXMjll1/O4YcfzgsvvMCDDz7I4sWL+frrr9m4cSNPPfVUeP+VlZXhgrwkSZSUlHDDDTfgdrsZMGAAd955Z7vxdqa+vp57772XlpYWMjIy+PHHH7tEoXndunXccccd6LrOxx9/zJNPPhl+T+xvv/76K2+//XZ4XDk5OeT+A3/bTcmyMWUX0Rfby4k18dLhSQBcv7CRDVuiGGo9KjfvIIoh2iJyxdDOu0a3l+KQSXHIjE+34g7oRB59NXr9mWC3I+zls0JNgokcad92+guCwB22O9igbiBRTCRVTIVMuOS6XJb+Uk+vvlGMOjRxr+xLDwbRP/4Yvb4eceZMhKysPbr/yuDK8HKpVkqL3kKC0HHC04NBSYGTgBI6yKgGdYoLXH+q0JwmpTHFNIXFwcXYsHG6ORTdMss0iy+VL/HgIVlIplgrxosXDY1WrZUCvWDbRnZy8ssGfQN3eu7kMttlPOUL/R2wTl1HhpTBFNOUnY5tyS91/PpTHb36RDHrpMwuHaFUroYiRHqLvWnQG7jNexu/BX6jVW8lV8rl68DXnG0+myd8T5AXzKOEEgDEkRswv/ErwSg3utXPk4qNN35II7Ulm2oVEqTh9C0cSkO9n6QUG2pQZcWGcgpNm/AJDmTJihrUOXRKMnbH37cc+/d9ZP8AeiAABQUIycmIJ5yAeMEFCJF/n3Z7g8FgMBgMBkPXdM8993DHHXcc6GHsdampqaSmpra7ThAEUlNTKS0tRRRFzGYzDocDSZLCHc7BYJBAIFTckmUZu93ervguiiLl5eWYTKZ2RWaTyYTdbu9QaNY0Db/fj9VqxWaz8dJLLzF69GgSEhLQdZ2zzjqL+vp6mpubEQSBgQMHtouseO+996ivr0dVVebPn88333yDoijouo6mabS2tuJwOFi+fDlTp07FYrHgcrnChYGamm2n1i9ZsoR77rkHTdMYMWIEt912Gz/99BNutxsIFUTLysrIzs5mZ15//XUCgQA+n4+ioiJm7cVu0L+iuLg4/JoEAgHKy8vbFZp9Ph+LFi0iNjZ2lznYf9XWCSC32voc721r6v0sr/MzKMHCIcn7t3v1r/q9zs+CSh+9Y0xM79Ex0qXGo3a6/FeJgkCkOfT5EBL3TiH2QJEFmUHyoHbXjTo0ca8VmLfS3nsPbcuBE33xYqSXX96juaNGyCP4PvA9Ojo9pZ7ECl2j6/XPyB0UQ0ycmZYmhchoE/2H/PnH8nLEy/wa+BUvXg41hSJWPgp8hIqKX/fTQAN27GhsOXvmjylMWy/voA68ILCABDEBDQ2R0EFVt77z76KqCg/PPLAJXYdVvzURn2hh3OTkTtc90XIiZVpZODpjb3czB/Ugnyif0KQ3MdM8kzSx/YHD7wPf85j3MVy6iwatgVKtlDa2/X1dEizBjJl5yrxwB/hWmqziG5IPjREQ6UWVm6hzNtNc2oDYJ5q27EJaro0hSU6kqVEhYPLSFigiUO1Bu+R7Jr9zE+m2ZGLjd32mxsHMKDQfpPSmJqiqQujdG+n//g9xzJgDPSSDwWAwGAwGwz/EjTfeyFVXXRW+3NbWFu6m/TtKTU1lxIgRiKJIWloaXq+XQCBAcnIyeXl5bNiwgdbWVnRdJyYmJhx9sbUDWpZlRowYwSGHHMKNN94YnnAwOzubMWPG8OGHH+J0OsP729pF7ff7CQQCXHPNNdxwww2ccMIJOBwOnE4nuq7Ts2dPcnNz+e9//0v8dnOzyLKMpmkdYj5UVUUSRSZpGpM2bGCN2cyxS5Ywfvx4jj/+eDZv3oyiKMyePTt8n59//plAIICu6yxbtgyXy9UuJiMiIoLETgpvDQ0NlJeX06dPn3DGc48ePYiIiECWZS6//HLy8/PJz89n2LBhO43p2JdGjx7N+++/T3NzMxkZGQzYOo/JFrfffjsbNmwAYO7cufu0QD5p0iR++eUX1q1bt1sTPP4ZpW0BblvSjKrDJ4Ue7js0jty4g6PoUeMOcudvzQQ1+L7cS4NX5ccKL6oOVw6NZliShdk5ETy7tg1JhJNyDu5M34PedvnvektLaJ6gPWiMG2say0PiQ9RoNRwiH4Ik7Dqvu6uKjbNw1+PDKC5w0aNXBFHRf/4zJyLyReALVgVX8ZTvKR6zPcmygkQK3KORMr0ItkZKKe1YYN5NmqDxa+BXTIIJAYG+Ul+mmqbu9D5tLQrbn8TT0rzjCXQjhUhut9/+5wa3G65yX8WHyofYBBs/B37mjYg3wgdR3/W/y02em2jT2nDjxocP/Q9PlI7eocDcjgjEu8KFej3KjdKrAjnWha5D03VvYXnyNCRnNF7BjU/ygF9AdUtYrlrALT3uwmw+eN/Lu8MoNB9kdEWBsjKwWBCPPhrxggsQ//CPIYPBYDAYDAaDYV+yWCxYLAdXJ+RfMWrUqHC36fTp05kyZQrfffcdd955Jy0tLbjdbkRRRNf1cNE9KyuLyspKAoEAl19+OUcffTTPPPMM8fHxOJ1OoqOjSUhI4JdffkGSJERRDP8YjomJwePx4PP5UFWVwsJCrrnmGhYsWMALL7zA6NGjefzxx5EkicmTJ4eLzCUlJbz//vvk5ORQVVVFVVUVJpMJSZJQFAWLxcIxSUmc39TERpuNxg0bEAcO5Oeff2bq1Km89tprBINBoqO3RQoIgsDKlSvRdZ0hQ4bgcDiYOHEigiBQXFzMxIkTifxD8ai4uJjrrrsOn89HRkYGDz/8MGeeeSaNjY00NjZy5plnUlpayg033ICmaURGRvL0008TExOz11+7dQ0K+S0BRqZYSI/o+PM3MTGRZ555hsrKSrKysrBat+XFKooSLjIDrFy5cp8Wms1mM3feeec+2z5AhUtF3VJX0YEyZ7BDoblVa+Uh30PUa/XMscxhgmkCAK9ucLKkxsfgBAsXDozEFdDxBDSS99Ep4F+VeHg/301ahMQ1w2Jo8GoEt4s4fyffhbTlM/Ps2jaen5LI9B52xqdbEQVwmDrPZ96VdQ0Kr2x04pAFLhsS3WGCQsPuEWfORF+2DN3jQZw27U+dfZ0j5ezzOJH9JSrazODhcX95O0VaEYsCi9iobkREZI7zSsxF9+AVzSgN3ZAzfkBVBUj/GUx7dlZEOumki+lAaILKBx0P7tb9+vSPZsS4BJYtaiCzu4OJhx+YA4eNWiPfBr4lSDA0YWJwHfV6PYkksiy4jMvcl9GsNxPkL0zoq9O+G1wEHApBsQXT6my05FYapv5C5EtHoitW5JU90C0B1B/70O+IVBISt/0d42wLIEnC3y5G4+/1aP7m9OZmqK1FSE9HuvJKhGOO6dK5NwaDwWAwGAwGw8GksrKS6upqBgwY0K7gePnllzNq1CjMZjPDhw8HYNGiRdTV1eH1esMdyrquEwwGWbduHSaTibi4OOLi4vjkk0+oqalh06ZNWK1WfD5feB+rV69GVdVwfIMoigSDQZKSkigvLw9PHuj3+1m5ciUtLS14vV6GDx8eLgI3NzcTCAS47bbbWLNmDQ0NDaSkpHD44YdTXV2N3W5n+vTpjBkzhrIHH6TXsmWosgxFRbCl6zkyMhJHJ5mzDQ0N9OjRA0VRsFqt4d8fEyZMYMKECZ0+j0uXLsXn8wFQUVFBYWEhAwYM4O677w6v88EHH4Qfm9PppKSkhCFDhvyVl6+DNfV+blncjA68l+/imcMSiLF0LBo6HA569+7d4Xqz2czgwYNZvXo1ACNHjtzlPoOaTpuiEWsRu+RvtSGJZjIiJCpcKkk2iZGdRGe8qbwZzsd9xPsII+WRbKwX+KAgVLSqcHmwSgKfl3jwqzqzetiZOzBqr46z1a/x9Jo2dKDOq/Jevotz+kUyJNHMqnqFZLuEXYbittD71ypte653NAHg7rp3eQutW/J0n1/bxk07yHk27JzQty/Syy+D233Qx410JTHEsEnbhJvQ57GcAuJT5qGxFuQ2As29oKUvWJsg+TcQdm+y2lwxl+ut1/NB4ANkZI43d5wscEcEQeCyG/qhKOoB7daVkUkVU2lVWwlu+e8813lkiplUqBXU6/V/fSd/LDQDoiAhCCKyWUc0CUiKmaRkK253kLZAkGCvWiJW9id7wVFwQug+X31awdsvFiFKApdcm8uIsQdn/nhnjELzQUD3+6GmBnw+hLFjkR9+GGG7U+MMhj1mMsE112xbNhgMBoPB8I/mcrkoKNg2WVBxcTGrVq0iLi6OrD2cwOlgtXbtWm677TaCwSA9e/bkwQcfDE9wJ4oiY/4QVRcZGYnL5QrHXAiCgKZp4RzkQCCAqqr4/X6Ki4vJy8sjLS0Nn88XjpIoLy/HZrPR1taGLMtIUugHuqIoxMXF4XA4KCwsJBgMYjKZyMjI4K233mLZsmW0trYSHx+PyWTi3HPPRVEUiouLaWxsBEKv6cyZM5k+fXq7cfe45x7U224jqaiIqpwcNmVmMn78eHr27Nnp81JZWUllZSUej4fm5mZef/11zjjjjJ0+l3379g1PiBgREdFprMrw4cN555138Pv9JCUl0atXrw7rfPnll3z00Uekp6dz9dVXd+ic3pVNzYHwSdGugE65U+200Lwzt99+O7/99huxsbH069dvp+vWeVSuX9hIg09jZLKFm0fGIHaxYrPDJPLohAQq3UHSHBJWuWNRdvtTyfUt/6l6+8exsNqLf0tr9LxiD2f3i8Qs7b3HKgCarlPpVtF08AY0ZFHgP6NjafJpRFtEaj0qz61tQ9Vh7oC9N1dRQNv2+BXtT+YPGAAQ7Hawd8zSNvx5btykCWmU6WVIgkScxcomTx1q4yTQTJCwElQzeBNA1zpmMf/h8hjG8EbMG3QTuyEJErMsszAJJiKFPf9MHcgi8zxlHiuDKznKfBS5ai4u3RUuLM9X5u+9HTmtYFNA1kATkGUJHR2rVUbq5iT6x37ELjyM+CQrUX4NoVrAVN4Pi1XikIEZ4c189m4Zuh6aHPLzD8qNQrNh/9GbmqCiAiE7G/G00xDnzNnrs9sa/oHMZnjggQM9CoPBYDAYDF3E8uXLmTx5cvjy1vzls846i1deeeUAjWr/Wrx4McFg6HTawsJCqqqqdlpkP/HEE3nyySdRFAVBEHA4HO1ymQGCwSBer5dgMIjZbMbpdGK320lPT0eSJGJjY8nMzETTNKKjo/npp59obW0lMjIyHJ8xZMgQGhoaSEpKQpZlPvnkE+x2O5qmMXPmTDZs2EBRURGiKGLa0kAgyzKpqamIYsciohAdjfzYY+iqyhnSzosCK1asoLm5GU3T8Pl8ZGdn89577zFt2jSSkpJ2eL8hQ4Zw1113UVBQwKhRo9pFcWzVo0cPLr74YgoKCjjxxBOJiIhod3tTUxPPPPMMuq5TU1PDhx9+yNlnn73DfdbX1/P444/jcrk4++yzGTx4MCNTLLyf78an6qQ7JCpWLeKl+Z+RlZXFJZdcslvxLyaTiXHjxu1yPYBvyzw0+ELdg7/V+ilsCZITu/+bOiorK6mpqWHgwIGYzR2zYC2yQHb0jsc1xzyHSq2SOq2OOZY52AQbw5N0pne3s7TGx+AEMzEWkY8KPQAk2ST+ZErFDkVZRDIiZNY2KlglkYLW0GdTEATit0RZpEfI/GdMxyiC3+v8vLHJRZxV5F+Do/b44MLlQ6J5fl0bDlnk7H57r4BtMPyRW3dzr/deCtQCppmmcbb17F3eJ1VMZZRpFBHBCBQU4sV4Njb1BUEHMQAtW87OiC6CnXwuHTjYGLORTKn9gcA48a/He+xvq4KreN73fPjyvfZ70dG50XMjmq7hxYtDcPzp3OrtyRsz0SN8oAvYC7sRc2wJZtFMb6k3xa1uAit74amTKaxy0qNXBDNOyMRsFjnq2Ax69d525kdiig3XlrkZklOtO9rdQckoNHdRuqZBSQnIMsL48cj33IPwN55gxWAwGAwGg8GwTUFBAYWFhUyYMAGbzRbumN1XJk2aFI5u+Kfq378/8+bNAyAhIWGnhVQI5TZnZmZSUVEBEC7qbu3kBejevTtNTU1omkZUVBQDBgzgqquuYtWqVQwfPpzm5mY+/fRTsrKyuPrqq/noo4944IEHiIuLo7S0lPj4eGJjYznkkEMoLS2ltLSUpqYmBg8eTGJiIkcffTQ+n4+ioiIADjvsMIYMGcKiRYvo168fU6fueAInYRdFZgh1VkuSREJCAq2trZSXlyNJUrtYke3puo7L5eKDDz5AURROOukk4uI6L1p8+umnvPDCC0AoW/q///3vTt/ju3r/v/DCC6xatQqA++67j7feeovuUSaeOSyBMmeQeK2Nyy98FE3TKCgoIDIyktzcXHr16kVycvIun4vdkWLf9vPaLEKcdS9XX3fDqlWruOOOOwgGg/Tp04f77rsv3Cm/u+LEOP5r/2+76wRB4OJBUVw8KFQoCWo6EWaRJp/G0dn2ffL95DCJDEoIHQyo86q7WDtE03XuWdaCb0u3dYTJxZVDOx7o2JlxaVbGpe2bws8PgR/4WvmabCmb8yznIQtGSeZA0ysr0T78EKKjEWfPRtjB99u+8KXyJauCqwD4UPmQCaYJZEvZHdab17qITd5aTos5jFXirwyWBpMsJFOr1bJWXYsYm4/a3AsQIOM7SPgdIso67nDLx/RI6UjeinqLWPHvEQvTrDd3uHyo6VCutF3J8uByyv3l5Kv5SEioqAgIHSYB3F1qSgu2z0Zh1iwMm2HBLDtooQUJCZ8LzKu7oQQ0QMDZFqC+xsdLHx+K/IezRy6/qR+fv1+G2SJxzOy/15ljxrdaF6PrOjQ1QV0dQkpKaLK/M8/skvlehoOYpoUmlQTIyoJOul0MBoPBYDDsf42NjcyePZsffvgBQRDIz88nOzub8847j9jYWB566KEDPcS/rXHjxnHnnXdSXl7O2LFjd1hM3UoQBK699lrefPNNTCYTERERrFq1Co/Hg9PpJCYmBl3XMZvNmEwmFEXhnHPOYeLEiUycOBGn08mCBQuYO3cuQ4cOpampidNOO43U1FQ++eQT2trawsXuZcuW4ff7iYqKorm5GV3XmT17NqmpqVx00UUkJibi8XiYPn06LS0t4fupqhqO/wDweDy8//77KIrCiSeeSGzszosMo0aNYvLkyXz88cc4HA7sdjuSJNHa2kpUVPtM3pUrV3LvvfeyYcMGIiMjiY+PJz8/nwcf7HwyqeXLl6NpGps2bWLZsmUoisLdd98dft7j4uK45JJL+Oijj8jIyOCEE07Y6VgDgUC75a0HZxJsEgk2iZoaNZwJHQgEeOmll4iPj8dms/Hwww+TkZGxo03vtilZNjxBjcLWIIdlWMOdt/vTr7/+Gu7Mz8vLo66ujtTU1L2+H1kUOCknYtcr/gXH9rTz0O+tqDqc0GvXZ/UGNZ2fK7zUeYNEbTmFf2u8R1dQo9XwqPdRdHQ2qBtIFVM52nz0gR7WP06JWsJDvofw634utF7I4NueRq+rC93o8SBdfPF+G4tZ2HbGgYCAhY5nWTzX+Bm3Nz2JDjze8hYDEoMEZTcb1Y0MlgcTIIBl4PN4agaCEITYvFAus6Rt6+ANWIkOdGN8dA4POB6gr6nv/nmA+8lYeSxfS1+zXl3PYHkwo+RRAEwxTWGKaQpfKV9RRRUuXJgwESPEYMXKIdIhzA/Ox4u38w3r2/1fFbAv74+pRxv2y1cw3jQeD22AzK2WW1m3xEXcpzIba000SX7QdVqaAhTlO7n7hlWYzRItzQFmnZTJoYclE59g4ayLdz3RpapqlJe4iUuwEBXd8QyVrsgoNHchuqKEupgdDsSpUxH/9S/EAQMO9LAMf0deL/ToEVp2ucCIYzEYDAaDoUv497//jSzLlJWVkZubG75+9uzZXHXVVUaheR8bMmTIHk1Id/7559O9e3eqq6uZNGkSv//+O++99154MsDNmzejqipZWVn07t2bWbNm0dbWxg8//MBrr72Goij4/X50Xae8vByv10tiYiLdu3cnJSUFv9/P+vXrwznQWyfVM5vN4YnpLBYLp556Km63m8svv5x58+bhdDrp1q0bJ510EnfeeWd4vE8++SS//PILqqqybNkynnrqKZYvX055eTmTJk1i8+bNPPvss2iaxsknn8yxxx7Lv/71L0wmE1988UW4aL11or/tvfbaa3g8HtxuNy0tLcTHx1NVVbXD527YsGF89913uFwuoqOj2bx5M0uXLmXixInhdY488kiOPPLI3XotzjnnHOrr63E6ncydO7dDo05KSgqnnXYan332WbsOX6/Xy+rVq8NRI3+1wWdW9oH9d3W/fv348ssvAUhKSiK+C8zt0+rXWN+o0CNaJtWx+yWI8ek2BiVYCGg6CbtRtL9veQtLavwoKjT5VIYlWTij774thu8Jn+5r10Xp0T0HcDT/TOUlLu7hCariSgB4zPsoLza0hW/Xa2v363imm6ZTrpVToBZwhOkI0qX00Dh0nfyWAFFmkR9da8LvGrGlnCELrLTkeFgzOEC9Vk+lVkmcHIGUVICiiuiCiCYFEdQIAkETYiCSyLZhTOVY7s0YRy+pYx7+gfKp8imfKp+SJWZxre3aULzFn2ARLNzruBdFV9oV7wFqtVoyxUzWCmsRdAErVoIEMQtmfIKPMdIYlqhL8OBB2PKfRvsJFAWXDdFnwRS0knLNWVzwvwjOiz2FX4O/kiFmUPZJLOteLQagzwCdqTPS+OazShrqfFjMEq89V4jJJNKtRwS1VV7SMm18/kEFoihwyrk9UPwa9bU+cgdGt8u5VlWN+29bx8Y1LdjsEjfcPYgevbp+nI9RaO4CdE2D+nqor0fIzUW65hqEyZONLmaDwWAwGAyGf5hvvvmGr7/+ukN3ZU5ODqWlpQdoVIYdEUURv9/Phx9+yIcffshFF13E22+/zbfffsu//vWvcHdua2srZ555JqIocuONN1JUVMTy5cuBbZ24ZrOZ1tZWmpqaKC0tJSkpiZSUFCwWCx6PB5PJhN1uJyYmhkAgwPLly+nTp094LOvXr2fNmjW43W40TaOmpoYlS5a0G29lZSV+v58NGzawZs0a5syZg9frRRRF3nrrLerq6igsLAQIZ1Q/++yzrFy5kvLychISEjj77LPJyenYhbU1hzk1NZWamhoADjnkEFavXs3gwYPD6wWDQWRZ5rjjjiMYDPLII4+EO6tVVeXjjz+mT58+u5x4748yMzN54okndrrOKaecwimnnEJ9fT2XXXYZbrcbWZapqKjghBNOIDIykttuu63d4ysvL8fhcOwwAqSrmTRpEpGRkVRWVnLooYd2mtG8NzX7VFbVh4rI3aM65j67FI1/L2ig3qvR5FPpHWNieLKFiwZGIYsdf++2+jWeWt1KjScUlSEIoW7mCem2XY5lZX0oHz3BJtE31sSVQ6P5vc6PT9V3mkm9v3SXunO0+Wi+CnxFD7EHM8wzDvSQ/lEWfFfDi49vZuWxDehDXXTvGYEkyIizZ6O9/TZYrYjHH7/Px7F9FJYsyFxqvbTd7W/53+LhFa00VQ4kVc/CHDUNl5JIVNxS7n+wjCxvBboYJP6yPnw+po1IIZJeUi/KtHoqFDdWpTfJVguxdj957gC6akWyu5kbP7xLFZnrtDpe9L2Ijk69Vs9HykecYdk20ayqarQ0B4iJNSFJu3cG9h+LzEE9yA2eG2jWm+kn9iNbyqZerydPzSNLDMVVzLXNZWhgKM/5n8OPHzNmYomljjqUgAq6AAEJXRVwFHZnuGkYs9qG89ijRQSUZM64qBsVZdXhfQoIHDenG6npdt54vpDflzbi96kEFJ3iQhcp6TZefDyf8hI3AIV5bTQ3KWiqTk5uFDffOxhxy3djdaWXjWtaAPB6VH79qc4oNBt2TW9oCMVkJCYinHoq0hVXIOwiD85gMBgMBoPB8Pfkdrux2+0drm9qatqticsM+98nn3wSzmT+9NNPGTduHBEREVx22WXMnz8fSZLo378/iqJwxhlnsGLFCrKzsxFFEbfbjcViwe/3h7uFvV4vqqqGJ+DLyspi8+bNAGRkZCDLMoIgMHDgwHbjyMzMxGq1YjKZwsXcMWPGtFvnhBNO4JprriEYDJKSksLy5cuJjo4mJSUFl8vVrlPZ7/fz22+/MX/+fNra2ggEAiQlJVFQUNDhOWhqauKCCy4gIiKClStXkpmZidfr5fvvv+fHH3/kpJNOYvbs2dxxxx2sXbuWYcOGccstt3DSSScRGxvLihUr6N27N88//zxutxtBEPjvf//LgH10dmdiYiIPP/wwa9asIScnh6uuugpN02hpaeHdd9/llltuAeCZZ54Jd3LfeOON4S7yrqKkpARZljscmBo+fDjDhw/f5/t3KRpXLWikwachi3DP2Dj6xrUv9BS0Bqj3aniDGgUtAXyqToNPo1uk3Gn392sbnSyu8VPuDFLnURmaZObh31sZkmAhyrLzYtPIZAu/VIXew71jTPx7QSPeoI4swkPj48PFZkVRWLt2LSkpKaSnp++lZ2P3XGC9gAusF+zXfXZ1mq7xrP9Z1gTXMFoevVsT4v0Zi3+uQ9eh94/HsEn+kB458cy1zkU6dQDizJlgNu/TfOZgUOOxuzewZkUT/QbH8O9b+7frXgUoVUt50/MeRWWX4G6LoDrox9aUyMD4KUSsz+FIfw1mk06AADl5xxGVO5Cvou7HJAkcbjuUNHM236nf4pBkZplP5EPpY1wBnQQ5itFR23KAvUGNWo9KukPGJB2YBkeB9vsVt5u50OMJ8t8b11BW5CIrO4Kb7hmE3d55+bK60oPVJhEb1/HfSC7dRYPWAEC0GM0geRAXWy/mWve1lKglKCj4dB8JYgJj5DE0a82oqDzueJw5zjnUNLuQfslFT3AStakPae+dyPTLuvH+6yUU5oUm8nv+kTzmXtmHFYtDBeUxE5OIijZzxKx0IqNNnHvcQkRRQNd0BHTOuiSH+R+Wh8dYXOAiast3U/7GNpoa/CQkbYmQircQESnjcobikLJ6HBxnohuF5gNEDwSgsBAiIhAmTEC6+mojJsNgMBgMBoPhH278+PG89tpr4bgDQRDQNI3777+fyZMnH+DRGTqTlZVF3ZZ8z6SkJK688koaGhqwWq1ceOGFOBwO0tLSuOGGG4BQ1259fT1ZWVkoikJCQgI+n4+YmBjWrl1LQ0MDsizj8/mYNm0aBQUFJCYmcsYZZzB27FhWrFhBjx492nUzQ6iT+MUXX+Thhx+mvr6eKVOmcPEfskYnTJjAAw88wB133EFeXh6tra1UV1dTVVXF4YcfTlxcHN988w2qqjJ9+nTS0tLQdR1N08L/r/3DqeXPPvss8+fPx+FwcMEFF/Dzzz8DoUnpUlJSSElJ4ddffyUjI4O1a9cC8Pvvv/Pbb78xbtw4pk6dytSpU1m1ahVud6jDS9d18vLy9lmhGSAtLS38+CIjI2ltbQW2dWYHg0G++OKL8PKXX37ZpQrNb7zxBu+++y4Ac+fOZdasWTtcV9d1ltf6sckiAxL2XodzSVuQBl/oFPOgBqvqlQ6F5h5RJqLMIp6AhiAIRJpCxaQdZScrWuh6HT188rqmw6ZmhXnFHiJMInMHRBJr7RilcfWwaManW7HJAt6gzmfFnvDYNjUFyI42oaoqN910E3l5eciyzO23375HcTmGvW9hcCFfKqG4lw+VDxkiD2GIPGSv76dX3yjWr2rB3pLASWuu4fYzh4Zva7U4+KHcR5LNx6Hp+6bYvGJJI6uXNwGwflULyxY1MG5y+4lIZWREaUsX7ZaPiKrrRMkO7Em9MfXNRS7YjCZaudfcj81reyNab+XU4T6OjRyJTbAxWz0Gh+AgUUxkuDycQrWQMaYxRImhXP0Gr8o1vzTS6NPoGS1z77g4/KKT//n/h0t3cZrlNHKkXWcH/1WJYiIXWS9injKPLCmL48zHhW9bubSRsiIXAGVFLlb91sjYSR0nbX39+QK+nVeFJAv86/pcho9OaHd7jBjDGHkMi4OLMQtmppqmYhNsPOx4mCd9T/Jd4Ds+UD7AhAmLYCFFSiFJTGK0aTS32G/huuTr0LJbiXzoRMbJY7F3szF2UhIlBa7wPnRNp0//aB5+cSRtrQppGaFmgepKDwu/r8VmFwkGJHQdZpyYyWFHphIVbeK5h/MQRZgyPZXvvwh1RCemWImO3fYdanfI3HTvYH79sY70LHuH90tXZRSa9zNd06CuDmpqEHr3RvrXvxCOPdaIyTAYDAaDwWAwcP/99zNlyhSWL1+Ooihcd911rF+/nqamJhYtWnSgh2foxDXXXMNHH32EIAh0796d++67DwjlGOu6zsSJE/ntt9/QNA1RFOnduzfTpk3j6KOPZtGiRZSWlnLkkUcydOhQ/vWvf7Fp0yZqampIS0vjxhtv7BB9sLPMYpvNxpgxY8jKytrhgYmJEycyZ84cnnjiCfx+PzabjZSUFHr37s1tt91Gc3MzMTExSJJEXV0dw4YNIz8/n+bmZlJSUpgzZ054W06nk/nz5wOhbvzvvvsufNv2kwUOHjw4XMDdKiYmpt3lnJwcUlNTqa6uxm63M2LEiA5jDwaDVFRUkJSU1Gnn/58hCAK3334777zzDjExMZx77rkAyLJMeno6lZWVAHTr1m2v7O/P+vHHH3n33XdJTk7mqquu4uuvvw7f9s033+y00PzIylZ+rAh1+p6VG8GJe2kSv+5RMvFWkcYtHc2DEzsWsaMtIg+Pj+P3eoXV9X7WNCj0jDExvXvnr9+pfSIobQtilaB3LFhEkRNzHDy1po0m37bc1OsPielwX0kUGJMaKhK2+FXirCJNPg2HSQiPra6ujry8PCD0fvr111+NQvMB9sc83D9e3luOP7UbKWk2nG0BJkxN2bY/XeeGhU1UukNxLU3+SI7eB1nrkX+IlonoJGomXUpnrnUu6sB1rFk9kSTBil+FGIvAaX1isUy/mx9WP8mvNie/V1uI8IHN1w17SyS2+FC8THepe3h7nRXtF1X5aNzyWSpsDbK+McAPUc+zILAAgBKthFciXtl7D3wnppunM908vcP1iSlWBAF0PRSfk5jSMTpH03S++zw0D4Aa1Pn+i+oOhWaAG203UqQVESvEEieGIpDMgplmvRmJ0AGrIEGutl5NnV7HYabDkAWZuda5xAlxbBi3gST3JAIbExk+Op4evSI548KePP/oZhS/ytmXhIrybleQgk1OJEkkJs7MXdevprrSQ0DRSU61Eh1nYc652QAcMiaB4e+F8vMFQWDwIXHUVHkZNT4Rk6n9mRsZWQ5OPqvHn32KDwij0Lyf6LoO1dXQ1oYQH48wdy7SaachZGcf6KEZDAaDwWAwGLqIAQMGsHnzZp588kkiIyNxuVwcf/zxXHrppaSmph7o4Rk64XA4OOOMUK5kU1MTkZGROJ1OJEkiIyODSy+9lJqaGnRdJzk5mX79+nHRRRdhMpk6FC8vvfRSHnvsMXJycrjiiiv2KF/X7XZz/fXX43SGTufVNI0pU6Z0uu5JJ53EggULaG1tJRAIkJycTE5ODqIohieP03WdTz/9lMjISKZMmcIVV1xBampquwKyzWYjOjo63A08YMAABgwYwHfffcfIkSMZOXIkVquVCRMmIAgC559/PitXrmTkyJH079+/w/P4yCOPkJeXR1ZWFgkJ7QsGiqJw8803s2nTJmJiYrj//vv32mciJyeHW2+9tcP1d911F59//jkxMTHMnDlzj7erKAorVqwgISGh01zr3eV2u3nsscdQVZXKykrefvttevbsyYoVKwDo2bPnTu+/uNofXl5S499rheYIs8jDE+JZWaeQHS3TYwc5yEtr/ayuVxidYuGGEbE73WaqQ+bxSR2LRW9uctHoU3EqGin2XU8MGGOReGxiPHnNAbKjTCRuuU98fDzJycnhzvw9zQI37H3j5fGsMq1itbqaMfIYhkpDd32nP0EQhE47Ql2KHi4yA+Q1B/bJ/vsNiuG0C3qyalkjA4fFMXh457nvs8yzmDUAliX4qHSrTEi3Erelg/9j/8e81PdngppOqW0NfTc9RJTk4JDk3Y/WyorcVgY0iZAWIeHSt3XoOnXnn3yEe0/v3GguvrYva1Y0M2h4LDl9ozqsI4oCqRl2qspDZy6kZ3V+8EoQBHpKHb8jJ5kmsTq4Gh2d8abxTDJP6nC/k6wnhS4cu+XPFlk9IrjrsWHhy7XVXm694nf8PhWLVeLym/rhbA3gcMhkdHMQE2dmzrnZjBibCMDCH2pZsaSBQ8YkMG5yMkNGHPhJW/cmo9C8H+guF1RWIsTEIJx0EtL55xsFZoPBYDAYDAZDO4FAgCOPPJJnn32Wm2+++UAPx/AnxMXF8dBDD7Fy5UpycnLIz88PT4wnSRLnn38+o0ePDq/vdDopKSkhISGB1tZWunfvzrPPPrvD7QeDQX7++WcWL15MTU0NvXv35pJLLkGWZRobG8NFZoDi4uIdbicmJobHHnuMxYsXU1xcTHZ2drhT+ssvv+Tjjz9GFEVKS0uRZRmXy0V1dXW7uA5FUXjkkUcIBALExMQwY8YMTjzxRGRZ5rTTTuuwz1dffZUFCxaQm5vLEUcc0em4HA4Hw4YN6/S2zZs3s2nTJgBaWlr45ZdfOPnkk3f4GFtaWjCbzbvV+fz999/z2muvER8fz/XXX09ycqgYtXXywx3RdZ2nn36aRYsWMWjQIK655ppw1rau69x2222sX78eQRC46qqrmDRp0i7HsrN9NTU14ff7wwcV5s+fj8lkYvr0jh2B3yxdzWvf/Er/eAv9B01nReiMfQbtxegMgDirxJSsHU/Ut6zGx//Whd6Xv9X6yYqS6RO752M4PMvG/y1pRhKhuC1AuTNIZuTOyxkxFolRKe2L0mazmfvvv59ffvmFjIyM/ZJlbdg5SZC40nblAdt/lEVkeJKZFXUKkgAT9lF0BsC0o9OZdvTu5YKPSLHyx/M6avTQ3yeyKNAnIcBVI2WGRSWEC9G7Y2iShRsPiWFDk8LoFCupDpnT1dMp0Upw6S4usly029val0aPT2L0+J3PX3bdnQP5dl4lEVGm3X5et5pimkJPsSdO3ckA6c/FNLmcAdaubKaqzIPfFzpY4feptDT5kWSB5Ysbsdkkbn9wCKMnhB7L919UcfX5v6GqOvPeK+fx10bTb1DMn9p/V2UUmve10lKIi0MYNQrpyisRjb/IDF2BLMMll2xbNhgMBoPBcMCZTCbWrFlzoIdh+ItSU1PDnbbbT64nSRJpaWnhy01NTVx11VVUV1dTUFBATk4OWd26cfs9D5AWG9lptN7jjz/OF198wdq1a0lKSqK0tJQePXowfvx4YmJiGDRoEGvWrMFut++yqBkXF8eMGTPaXffWW29x6623EhkZSdT/s3fe8VFUexv/zsz23fROCIQQQq+hKyhFQLDrtSO2e/Ver71cFa+9K6hYsfeKeEUFAQHp0msIgQDpPZuyfXfK+8fCQuggivrO9/NRZnfOnDlzpmzmOb/z/KKjaW5uJiMjA+CA9syZM4clS5YA4PV6yc3NjYis+5Ofn8+0adPw+/1UVVXRrVu3w1qAHIzU1NRI4kQ4vJXF559/zieffILJZGLixImHFK8hLJi//PLLKIqC0+nk448/5s477zyqNq1bt44ff/wRgKVLl9K3b19GjhxJaWkpP/zwAwsXLiQxMRFN01ixYsVxC812u53+/fszdepUzGYzmzZtwmQyMe68C1hVHWCHS6PTPsGRhXVurv1uFyHSmV8W4m7LfG4beT5Wg8CgtENHPlZ5ZHY0yXSJNx7UA/l4aAi0tEFoDKh4PJ6ISD5u3LijitxvZZfI3Sdqs8pzZKH5UMTHx3Puuece17Y6f03+2z+OvPogCVaJdMcf9/34TOOZLAktoVlr5gzzcEbG7k3wt6MxRJlbJjfZjMN0+MSZg1tZGNxqr6DeQerAB44P0DTtT2XrGp9g5pKrjz+Ic1+bkf1pbgrS1BCkdVt7pE80TcPtknFEGQgEVB6+cx01lX5CofBzzmgUsdkNxMWb8LpDdOwSA5rG21O2UZDXxIVXZvLjt2Uouz3qqyt9VJZ5daFZ58hoTU0oDz4IdjtCu3aI48cjXn89wjFMfdPR+U0xm+HVV092K3R0dHR0dHT248orr+Sdd97h6aefPtlN0TkBdO/enfvuu49NmzbRv39/2rTZKwqsX7+e+vp6GhoacLlc7CyrZHXGmaz5spAR3dry2MB4zIaWL/ybNm1CVcMvtM3NzQD8/PPPvPnmm5hMJu655x6uvfZaEhMTD/BEPhKFhYV88MEHeDwe3G43VquV3NxcJEmiZ8+eDBkypEX5/cWIw4kTqqqybds2GhsbMRqN1NXVHVPbIBxd/MQTT7B48WJycnIYMGDAQctpmhZJkhcMBvnmm28OKzSLoogkSShKOBrNaDy4/cPB2F8gNZlM+Hw+7rvvPpqamiKWKUlJSfTs2fOo6z0YZrM5Ukd9fT3NLhePbpApbJIRgLtyYxiaHo4s3lzjI0RYaFJEI0WeALe3sfLLytVcP3UxqdlduefikcSY94pRpS6ZOxbV41c04i0iU05LbLH+eBmabmFOiY+ChhC9k0zkJpt55KEHWb9+PQAlJSXceuutR6zn1HQLM3Z5qfQodIg10v0YIrOdfoVKj0JzUCHFZiDrEBYfOr8Op+rkNf9ruDU30iBBywABAABJREFUE8wT6GzofLKbdNRIokCPpKO3nzhZtBHbMqLsJba7mzg1Ix12TyZYUx3gkRUNaECGw8CLpyVgko5dMP4zicy/Jdvym3juwc0E/Aq9ByRw28QuyLLGcw9tYuumJjIy7Vzx9yxqKsODyUajyJCRKXTtFYfRKPDiE1vYsKaBYCCcSDc51UrAr7BlYyNJKRZsdgNej0xsvImBQ5NO8tGeeHSh+QSjzpuHMmkS2o4dAEi33Ya0X7ZnHR0dHR0dHR0dnYMhyzLvvvsuP/30E7m5udjtLRMSTZ48+SS1TOd4GTx4MIMHDz7g+6ysLAwGA3a7HVmWqbKmEzDHUVpayqbkZFbXBDilVcsp3Keccgp1dXWkpaVhs9no27dvxKc3GAwyY8YMnnjiieNqp8/nw2Qy0bZtW6qqqsjKyuKll17C4Ti4n++oUaPYunUr27ZtY9iwYWRnZ7dYL8sykiQhCAJWqxWbzYbf78fhcBAMBo+rjR07dozYdzQ1NfHBBx8QDAa54oorIlHkgiCQkpISSeKXmpp6yPognPTvP//5D++99x7JyclcddVVR92ebt26ccUVV7B8+XK6d+/OkCFDqKioiHhWd+7cmQ4dOjBhwoTDit1Hw2mnncaSJUtQFIXevXujmh0UNoUF+6rqaiZ9uQLHaRn06dOHAW3jaNc6jaLyKhxGgcFZyVx66aXMXbwcISEDyTKLCtXKexP2Dh6srw3g3x1l5/SrFDQE6Z8avv5KSkr4+OOPsdlsXHPNNcc0iGExiDw/JIGgokWEr507d0bW77t8OGLNEs+cEo8rpNLKbsAgHp0gtqU+yIPLnayrDSKJ0DHWyH394lpEc+qcGN4MvMkKeQUAT/qe5KOoj05yi/44BGSNL7e7aQ6qXJhtJ9V+fFLcD7u8fLNdBuxsrW7krRFJJFol1tQE0HaXKXXLVHuV4474/z0IBBRMJvEPK2wv/qk6YoWxbkU99XUByoo8bN0UfraXFnko3ukhKcVCbbUfQYCBQ5Pp3juONyZvxVkXIBhQCQQU0KC22kd9rR+zRaJ3/wRGn5tOYrKF8y5rg93x1xv4+uNeeX8yNJ8P5d57UZcsAbcb2rSBkhLdi1nnj4mmwZ5IksTEcCpXHR0dHR0dnZPO5s2bI4LUtm3bWqz7o76Q6RwfmZmZPP3006xfv55Fixbxv5Vb8WsaTU1N1NbWkGQ90Jvy+uuvp1+/foiiSPfu3QH4xz/+wS+//EIoFPpVYma3bt0YNWoUixYtYvTo0dx///1YLIcW44xG4wEWE3l5edTW1lJWVsaXX35JXFwcjzzyCAkJCWRnZ0esRPaN7D5eXn31VZYvXw5AcXExL7/8cmTdww8/zNdff43D4eCSSy45Yl35+fmUlZXR2NhIdXU1sbGxR92OSy+9lEsvvRSA2tpaDAYDvXr1Yv369TgcDm666SZycnKO7eAOQr9+/Xjttdeor6+nc+fOiJJEVoyBVTurw17axQt4bFExb7zxBmkpKcy4qg95dX7WzPqSR+95HlVV8fu8UFuOI6MDO0vKWtTfJd6EQQRZBbtRiET9BhWNB556noaysOd3IBDgP//5T7jfnEGKm2X6p5qP6BG7b3TlmDFj+PLLLxEEgdGjRx/V8X+y1cXn2zzYjQIPD4ijU/zRRTTPL/PhDmm4d09tD6iwosr/lxaag4rGV9vdNAc1zm9vO25R81jxa3utgvz4D1Pyr0mVWsW80DzSxXRON57eYt1jmwr4fFclRsHA6ros3htxbH7Ce2jcx4pGVmGLvxgMZeQkdUPYBRqQbpdIOYqEmb83ZSUePntnJ+tXO1FCKhntHNz3ZA/iE/54keQZmXsH+WPiTETHGIlLMCMIYSkFIC3dykOTerFhtZP0NnayOkQBkJxqobzEiyyHbUhUVcPnDZ83r0eheJebrr3iuOW+v24iUl1oPgGo69ejvvYa6rx5EB8PHTogCEJkRElH5w+H1wvJu19e3G7YL1pKR0dHR0dH5+SwYMGCk90End+RPRG6AwcO5PuhQ7Gv/gpju560L64hJ+7govH+FgzZ2dksX74cs9nM9u3bKS4u5qOPPsJisXDdddcRFxd32DaUlJSQl5dHjx49uPnmm7n55ptbrNc0jXXr1mEymejW7dAJk+bNm8eLL76Iqqrk5+fTpUsXnE4nX331FXfffTePP/448+fPp127dowYMQJVVRHFQ1szeDwedu7cSdu2bYmOjj5gvdPpPOgyhKOYb7rppsMe9x78fj/Tpk0DwO1287///S8ipB4L3333HW+99RYA1113HVdfffVxWZgcjlatWrXw+X5qcDxPl6zCVDiDKE81MmFbjZSUFJJtEhsKlrHw++m4XC78fj82iwUfApb4FMaPGdqi7vaxRiYNSWBbQ4ieSSYSrRJFzSEmLmtgQfJo4oR8skoX0tjYCLScqv/ldpFXhyViNRyd1cb48eMZMmQIRqOR9PQjC25BRePzbR4APCGN6YUe7u9/dEJzVrQRgwhWg4iiaRhE6JH4xxO2TiTv5rn4ocgLhCPVp47YOzXfL6tYjvI8HSsTzBOoUCtwa25usNzwm+zjj8rWRg93Nb4AsfnUB2QSSqoZqI3i9t4x2I0i/2taiosk0GCVaxea1uqoBo+3K9tZIa+gs9SZXEMuYzNtLK3wU+5R6JLewCTpXlSfSpojjcdPnUytW6J/qvm4bDOOh+amIFUVPtpmOTCbDy9uv/pMPtu3NlOwuYmoGCMms8S8mRX8bXy736Wtx8IZZ7XCaBKprvBx2qhUTCaJtlkO+p2SyJzvKujYNXq3TYbIkBEtZ80YDCJRMUaaGoJ43CEkg4AiaxGBuqEuSLdesb//Qf2O6ELzr0CrrkaZPBltwQI0pxNat0Y4yB9BOjo6Ojo6Ojo6Ojo6h6Jt27ace+655OfnY3ZvYFDyyKPeNhgMkpmZCYSF0ieffJKKigogHH06ceLEA7ZRFIUXX3yR5cuXs2PHDtLT07FarUyZMiViQbGHV155hTlz5gBhgfDiiy8+aDvWrl0LhCPvA4EAsixjNBoj0cF7RPXNmzdz+eWX4/f7uemmmxg58sBjdblc3H777VRXVxMTE8PkyZNJTm4Z4X3ZZZfx9NNPEwqFuPrqq4+6v/bHZDIRExMTsbtISjo+v8wZM2ag7VYSfvjhh98l2ZzNKHLr2P5ULPyaag/k5uZGrEWASOLErKwsSkpKOP3007niun+S3aUrbeNsB9SXFWNs4V/8wy4vzUGVNm3aUKSq5Li2cuWVVwKwsS4YCayq9alUehSyYvYKmD6fj8bGRlJTUw8qqO25Zo8GowhxZjGSWDDpGKI1x7azYTEIFDaGsBsFusSb6J381xaaKzxyZLnKq6BpGooGj69sYE1NkA6xRh4bFIfdeGIF53ZSO950vHlC6/wzsLDMx5Nr61gvn0JUQgbuVjNwazsRqgJ8td3DhM4Oktqup75xOKoq0TlrF4Jw6hHrrVFruM97HwEtfB8/YXuCHtYevDEiiaCi8UloFluC4XuiUq3EHlNNj/j2B9SjaRqrldWYMdPD0OOEHXdluZfH7l6P2yWTkWnnv8/1wnKYmQ0et4zBELbLUOTw0+OPGM0M4d+xYaNb/haWl3pYuaSO2DgT1RV+vvxgF2ddlEFMbMtBL49bplVrG6mtrJTsdGO2Smzd1ISqahiMIuddksHZf/v1s3r+yOhC83GgFRejLl+OOnUqWnExpKRAp076dEYdHR0dHR0dHZ1fxbBhww77N+X8+fN/x9bo/J488sgjfPPNN1gsFi688EIWLlxITU0NI0aMID4+/pDbXXzxxWzZsgW3282ZZ57J22+/jaIopKenR8TT/Vm0aBE///wztbW1VFRUEBUVhSAIbN++/QChedmyZS2WDyU05+bmsmjRIgRB4IwzziArK4ukpCTGjx/fotzHH3+M2+0G4O233z6o0Lxp0yaqq6uBsBfz6tWrGTt27AH7++yzz1BVlcbGRn744QeysrLo3PnYEpCJosjjjz/O9OnTSUxMjNhgeEMqDQGV5oDC+roQ3RNMdDtMArqMjAyqqqoIhUKYrHbe39KMrMLfOjhOSFK9/ZFlmenTp1NbW8v9999PbGwscXFx+BWNzVV+0h0GRo4cyerVq8nPzyc9PR2LxULFzq2MOKVfpB5N01hVHfZ37Z9ibvH8Sd0t6CYlJdE2LYn3HhyLzRj+rl+KmW93unHuyCM9zkG6PSWyXUlJCffddx/Nzc3079+fBx544Fe9KwuCwKOD4vi60EO8WeLyjgf3DT8YO3fuxFpdzYQ+fTCbT7yoVeNVWF7pp1204Q+TTO689nby6oMEVfhbBzuCILC+JsCamrA3+vbGEAvL/Ixtd+Bgg86xs7jCj0kzESPE0FjXBjHJSkJT2Jdf1cL2CQ+0Po/XY9/HocbxSOydB61H1mTK1XKSxWSsgpVNnnIaXVasjrDQvEPZERGKTZJAb6033wS/QUMjRUwhXTz47IAp/in8FPoJgCvMV3Cp+dITctyrl9XhdoUHNUqLPOzc5qJLj9hDlh9/QzZvv1RAt96xZGZH0XdQAsPGpB2y/B8FRVGRJBE5tNezoGSXmw/fKGTezEpundiFnrl7f6NHnZPOupX1VFf4uPaWHJJTLXzy1k5WL68jLsGEx6Owq9DFzOmlrFxaR1q6letv7Uh2x79O0KouNB8D6ubNqF99hfbTT+EIZlEM22SYjj7jrY6Ojo6Ojo6Ojs6h6NWrV4vPoVCI9evXs3nzZiZMmHByGqXzuxAXF8e1114LhKNj99gwzJ07l9dffx1JOnikWE5ODh9//DGhUIi///3vmEwmioqKMJvNh0xst6eu6OhogsEgBQUFpKSk0L59OBpO0zTee+89Vq9e3SJx3x5f6IMxfPhwUlJSqK2tZeDAgYf0d97XSuJQXsjt2rXDZDIRDAYRRfGARIN7MBgMuFwu7rzzThobGxEEgccee+wAe5EjkZmZyW233464Wwwtag5x/1InNT6FCrdC+xgDoigweUgCe3LQtYsxUu6W+anQyYofvoTaetLbtmPNiuXs8qcx78eNZGdns6NJ5qlTDj1QcLx88cUXfP755wC8O3MR6X+fROcEjTq/wub6EA6jwMunJ/Lwww+zePFinn32WZqbmyktLaVHjx6RPnprs4vvdoVtFsZm2vhnj71ix/nZdlSg3K0wLtMWEZn9sspPpT5qZr2DO28pDofE7Lh/cM455wDha7a5uRmAlStXUlpaely+3LIsYzCEJYvMaCN39ok9pu2XL1/OU089haZpdOzYkWefffawdi3Hiiekctfi+kik9YP9Y+mXevK9n/skm/lwdDIBRYt4Z8eZRQSIRKHHW34b+4yTRbFSzKO+R2nUGrnGfA1nmc763fbdNd7EiqoAOWIO8bFuRltf5ifNQnqigYuyw4MiI4wjGBE34pB1BLUg93rvZbuynXgxnguaHuWtNckUylcR02YF3TtuZaBxYIttehl6Mck+iRK1hL5SXyzCwa+9PQkaAZbLy0+Y0Ny2/d4BH7NFIjXdetjy/QYnovbbwVJ5BV2kLowx5R73vrflN1FR6qXPgASiY8J63Ob1DSz+qZq27R2ceV76EQe3AgEFRdawHcLD3O0K8eyDmyje4WbQ6cnccHtHzr44g3kzKwmFVFJbWQkGFBb8WAnA99NKSUgyc9UN2Tzzel8Wz6smFFKx2gzU1fgxmUQ8LpldhS4evmMd+RsbqasNYDCKrFvp5PvlZ2A8wbMMTha60HwUaMEg6vTpqK+9hlZRAVFRkJmJYNC7T0dHR0dHR0dH58TxwgsvHPT7hx9+OBIFqvPXZ99EkJWVlbjd7sN6/e4RzxoaGkhMTCQhIYHBgwcf0lN5yJAhbNmyhUWLFtG6dWtiYmKw2+2sXr2a9PR0Vq1axTfffAOAqqqMGTOGnj17MmTIkMO2u2vXroddr6oq//rXv7BYLHi93kMK4WlpaTzzzDOsXbuWrl27HjaZXmlpacQ3WNM08vLyDio0ezwe5syZg9Fqg5xT8YQUKj0qsWaRwsYgX2z3IolwT58YZA1cIQ1vSKPSIyNrGklWiZfWN7Go3I9ZguwYI2tqAvgaanCFOiLGZxNyNdC5s4FgVDJep5NQKES5+7cRDvbYozQHVcoaGkj2+1lRLbDFGWKPvPJRvounTk1AluUW2+77eXVNYO9ydaBluVCIv3XYKyYpisLq1auZ3xzNMl8cu9YvR5MV0h0SixcvjgjN+/ou22y2I/qEH4z333+f6dOnk5SUxOOPP35ApP3RsGLFioidSUFBAU6nk8TERCCcuDE/P5+OHTuSkpJyuGpaEAqFkCQJURSpcCsRkRlgizP0hxCaAexGEfteFxTaxxq5vXcMSyv9dE8wMTDtj9HOE8Vnwc+oUWsAeMv/FqONozEKxiNsdWyUu2Ve3dBMUNX4e7coOsaFBc7zs+2k2CTq/QrDM1KwG0WuOEbb4S3KFrYr2wFwqk4+qFuIwCi6Sl0JVbbj9dwUooSoA7brIHWgg9ThkPWuWLGCBmcDde3rSE1Npad0bINw++PX/MwOzcaChZG9R3LHg13Zsc1F30GJR7TBKFFKeNL3JCoqC0ILiBfi6W/sf8xtWLuinpeeyEPTwuLuEy/n4nbJTH40DzmksnxhDXaHgdPOSD1kHRvWOHn5qS2EgipX/L09o84+MBr85zlVFBW6cbtC/DCtlFNHJPO38e246MpMzhs6j3WrnBhNIv1PSeSFxzbjdcsU7XTz1osFpLexYzKFn/3BoILPK6Oq4VhVg0EkGFAJBFRkWUMUNZx1AdavctJvcPj5pGkaPp+Czfbn1Bz/nK3+ndDKy1HnzEH9/HO08nKQZejYEeEEjoLq6Ojo6Ojo6OjoHIkrr7yS/v378/zzz5/spuj8Dpx22mksXboUWZbp27fvQZPh7Y/ZbOaiiy5i2rRpOBwOzj///EOWFQSBG2+8kdGjR3PLLbdEvjcaw8KMoiiR70RRJDc3l8GDBx/38ezYsYNHH32U5uZmrr32Wm699VYqKysPawmSnZ0diWQuKytj9uzZpKWlceaZZ7aIVGvXrh1paWlUVlZiMpno27dvZF2dL3wciVaJRx55hPz8fNZKbWgYlEjAEocGkQjlPbmzHlvZyN+7RaNqGt6QglfWqPWqeEMaxc0yIVUjoGhsbwxhFAW82JDNGibZiya5KWk1gLYVv1CRPQqjwUC6XeK+pU56J5m4OMeBrIaT2dX4FM7MMOEqKSAuLo62bdsesi9WrlzJjz/+SLt27bj88suRJImzzz6b1atX4wm5Se4zHAC5oRpNiyegaojAbvtWhgwZwpo1a9i4cSMDBw6kT5+9iSZ7J5mp9IQjmvskh4WzxsZGJk6cSFFxCdl9T+WW226nfayJ5557jqVLl1KcPghzn7FEZXSkaddmNGgxqDF69GhUVaW4uJiRI0cSFXWgQNbgV2gKqrSNMhwQeVhfX8/XX38NQE1NDf/73//45z//ecj+ORQ9evRg3rx5QNjaZI/gXVtby6233orL5cJqtfLiiy+2SLJ4KGbOnMnUqVOxWq088MAD5HTuSma0gaJmGZMIA1L/GNYZh2JYhpVhGYePOv2z4mDvgIhVsGL4DaSu1zY2s6k+PMNj0tom3twnyeLgVr9OuE8VUzEJJoJauP4M2rEppGIzCHSLiTuoyHwkKioqeOqppxA1EUNHA6P+Nopr+l5z3G3cud3FLR+8T42jmMTxOyhKKOKGfjfQq1/CUW1fq9WisndgplqrPq525G1oiCTWq6n0U1fjJ+BXkUN7666r8UeWi3e6efOFAgIBhav/1YFuveKY8UUJwd2DRNM+Kjqo0BwdY8RZF6B4pxsE+PD1HTzzehwul0zJTg+KrOH3hfji/V00NYbwemT8PgVRhOpKPzGxJlRFpbk5hCQKmMwSPfvG8/iUPvz0QyUNzgCu5hCOaANt2jmIiQv//rpdIZ66fyOlRR569Yvn1oldkKQ/lwapC80HQdM0tNmzUZ55Bq2sDAwGSE1FcBy9F5SOjo6Ojo6Ojo7OiWL58uWHtCLQ+evRr18/XnvtNZxOJ52OIRfMhAkTuOCCCxBFkQ0bNrB161aysrJYvXo1CQkJLRLFQVikvfbaa5k/fz7tszuws9Ugbl1Yx+np3TnjjDNYs2YNffr0YdCgQb/qeD777DOcTicQ9mVetmwZmzdvJjY2lmeeeeawIl8wGOS+++6LRC2HQqEWifasViuTJ08mLy+PjIyMSF3f7/Tw5mYXADd0j2bbtm0oooHqXpegGqwRCwFl94KqhZPONQc1nl/TgCsUXqcBclAl1iyhaRDQwBPUQACLAUKiGVn1EPT6EeMyCVhspBpCXDu0C30yonh+XdhCYkGZj3U1ARKsEgvLwyLIm889TpvGrTTFtqXN8ItRUnPoGGfi3n6xWA1hYaG+vp6nnnoKWZZZtWoVMTExnHPOOXTq1In3338fj8fDtLXFvPjUnVi0IKbW/QmdcjWSKGDYfdkYDAbuuuuug/bvjd2j6Lnbe3pQmpkVK1bw6aefsm3bNnZ5RVbPnMemlFN5/NxcVqwIT8FPq9mAs64r3S+/jY61qxndIYGhQ4dG6hQE4QBP7X3ZWBvgkRUNBFUY0srA3b0BMSFynVssFsxmcySZ4aEsVo7E8OHDiY+Pp6qqilNOOSViGZOfn4/LFb42fD4feXl5RxSaZVnmnXfeobm5GZfLxWuvvcaUKVN49tR48upDpDsk0g4xBV/nt+dqy9UECdKgNXCZ6bLfJH+WrO716A0p2mFKHjupYiqPWR9jmbwM6rvzfUlbXEGZZKuRhwYc+4wAAKfTiaIoiIgk5ieSVpyG0O/4+2Xyo5vZVSejEI4ULri54Ji27yH1oLuhO5vkTbQWWzPUMPTIGx2EXv0SmPdDJaqqkd7GRlKKBaNRJHdQAmuW15OYbG4RzfzxWzsoLfIA8PZL23jxvQEkJlvYnh9+NicmH/xvqyEjUvj0nZ001AeISzRTVe7D7ZJx1voRBFBVDU2Dmmo/FouEuvv6EEUBVQO/TwkP2mrh35dgQMHnk3n9+a08+Uou516SwapldRQVuunVP4GczuFZS4vnVUfau36Vk4K85sN6X/8R0Z+E+6FVVqK8+irqrFngdoc9mA/hh6aj86fFYIA9Po+6BYyOjo6Ojs4fhgsuuKDFZ03TqKysZPXq1fz3v/89Sa3SORmkpaUdl11AVFQUEydOZOPGjWiahsPhoLGxEVmWmThxIsOGDWtR/vzzz+f8889ndrGXVzaEX7x3Nrl5acI/ueWWXzf1XNM0XnzxRb788ku8Xi85OTkIgsCmTZsQBIHGxkYWLFjAFVdcccg6mpubIyIzQHFx8QFlHA4HAwYMaPHdtzu9ETH5250ehg8fzswFS5AkA4IoIR9QC2gaNAb2iblTVQQ0NKDUBQlWgcaAhko4Atod0gABHAngSEDVVEBgXXx/tq1yIuapBFQNWQVBgICsEVQ1rBKY1SCV2zfTkJ1LQ3o/1pWqtDaE8MjwyvpmfIpGhsPAUJurhdVFQ0MDADsaQ0xe5yGkakQt/4kODhUwULNtOR1HXoojKoaQBsVNIaZubsYja1yW4zjAMkEQhEg05pIlS3jmmWeoqamhpLwSJbUjoiThMdiZXeylZ8+erFmzBlPIy51ZPi49tw1waO9lzekEjwchI6PF93NLfQRViDLU09n4BG5nMyZzLqaoBxEECbvdzgMPPMCMGTNo1aoVF1544SH3sT8VFRW8++67iKLIddddd4DvPUCnTp2w2Wx4vV7MZvMBCSQrKyuZPn06+fn5+P1+ZFmmpKSEZcuWoSgKqqqyfv16zGYz5557LrNmzUKSJG644YbDRqb/FVE0hY8CH7FT3cko4yhONZ56UtrhEBzkSDmsl9dTppbRhS4nfB9/7xbNpLWNBBSNm3oc2sroeOli6EIXQxeermhE0fyk2g14ZI3jte3t0qUL/fv3Z+XKlaSnpx808erRoqoaHrdMophItVqN4jIyzHhss1yMgpEnrE/QqDUSLUQjCcens3XvHcejL/amstxH995xmEzhem69vyvNTUFsdgMGw95OE8W94rq0e+rKhH9m44g24PMqnHtJBm++WMCKxbV06hbDLfd3wWyWEASBy6/L4m13+PnbrkMUjigDJrONgaclseDHKgyySmKymWBQo02Wg/yNjaiqRky0kYuuyuTzd3YSDIbQFA1EaHQGqa70UVXho31ONBmZBwazxiXszQEnCEQinf9M6ArTbjSXC/WNN1C//RatthaiohAO4wWmo/OnxmyG998/2a3Q0dHR0dHR2Y/o6OgWkViiKNKxY0ceffRRRo0adRJbpvNHZNmyZXzzzTekp6dz4403YrFY8Pv9bNy4EQhbYPzyyy8EAgFUVWXy5MkHCM17CO4XoRc4jog9j8fD999/j8lkYty4cWzdupW5c+ficrmoq6vD4XAwdepUnn/+efz+cFRvxn4i5P5omkZcXBzFxcUkJycf9X2QEWWgyhu2zshwGLj55ps544wzeKvEwqfFAirhpHaeEFgkMIgQbYRyb2THIAhoCEiKDKpCjW+vAKCq2t7MasKe/+2+d0UJjxAF8j59qEGeMxie8q2BJII4+GqafS4URUU0WGkKKJS7BZ5c1YBJgjZRBqL7JjJ69Ghmz55Neno6PU8/k6+2u/l6uwdnQMUsCWwPJUSMA9qlJRIbE4UkicSZRc76ropar0LbaAMrKgNckG1jbKadbokHJrTfVFBITUInjFEZpIZ+QenQjdqsIRRpsfxU6uOVf9zFkPwVEWHf5XJRX19PmzZtDkiyp65ahfLkkyDLiGPGIN10U2RdZlRYhugatYREcx2SaEYNrUWTtyEYw6Jvr169DioS72F7Q4iyXdv48vVPCQVi+c/EK+jQsRWTJk2KeJy7XC6eeuqpA7ZNTk7mxRdfZPPmzXTu3JnWrVu3WP/AAw+wceNGCgsLURSFQCBAKBSK+D1DWPB/6aWXeOmllxBFEbPZzGeffca0adPIzT3+JGd/NmaFZvF1MGxzslHeSI6UQ7KY/Lu2oVqt5gHvA/wU+gkJic8Cn/G28DaDjL9uJsb+ZMcaeX140pEL7oNPCTBtm5/1tSGSbQbObmejS8KB994edjaFE3kCoGn4FI3JaxsZnmE7ZnsOURT573//i9vtxm63/6oob1EUuPLv7fn4Lch0JHP9VW0YYup85A33QxAE4oTji9DelzbtHLRpd6BIuycx4L5c/a9s3pmyjUBAZfwN4YS3NruB8f8IWzNtXt/AknlhG49NaxtYMr+aEWeGZzgMHZlKUoqF+toAuYPCsy7MZoln3+jHrG/KmDezArNFIqdLDI5oI736xrEtv5nYOBMZ7eysWFRLVYWPhvoAoaBKVbkPgPQ29kMe28AhyTjrghRubWbAkCTSMw5d9o+KLjQDWk0N8k03oW3YADYbZGXpif50dHR0dHR0dHR+d97XB4J1jhKXy8Vzzz2HLMts3bqVhIQExo8fTyAQwOVyUVVVRatWrbBarfh84ZfbmpoavF4vNpstUo/H4+HDDz/E5QvQsfv5VMgWhmdY6Rx/aDHkUDz99NOsX78egJKSEsaNG0ddXV1kn1arFbPZzI033sjnn39Obm5uC8uF/fF6vdx99900NDRgMpn417/+RadOnQ5a1ufzUVJSQuvWrbHb7dzZJ4bpheHpxxdkh0UWW3o26/JqgSB2g8A7I5KYutnF4vIAJgn8KiS567lpwbtsTsvh++5n4DNZUEWRA2R3bb/l/TWcg4g6YsBPkttJkyUKn8mEnNYZpbYEKT4NHHFIgkCZW8YV0iAEzcEQ+c4gD/z739xwww24FJF/zq9jZ1Mjm+qCIECSVeKMIWdxbr8kqqurGTduHAFHMmZJ4OFfGtijh+9qkhFFgZ8KnfxS7uG9Ma2IMbcUh1cmnkpp20QURWVgVhce/vc13PBzI2ZJINYsstapct2IEQAUFhYyceJEvF4vubm5PPjggy3EZm3WrHCOI0D98UfEf/wDYbcH+AXZdqwGES3Yls5xpt06vRHEsNfr+vXrKSwsZODAgQeIwAAvr29iTomPtXN3YpmdjjHgpXDTTGb8fFXEEgPC0fCH4lAzBqqrq1mxYgUVFRUtIukPxh7hWVEUvF4vFRUVXHPNNVx66aUkJiZyySWXHDaJ51+BZm1vHysouDU3yfy+QvPr/tfZLG+mRq1BRSVaiOZN/5tHLTRrmsanBW62N4YYkWFlSPqJ8bH+IfgDDxcso6RgEEpzJkYlikXlPl4+PZGsmAOjVD/Z6uLzbR40TaNnoglFg3W1QVZUB1ldE+T1mMTjsmdxnCAL2BFjWzH8zLTfxJbktyQt3cYDz/Q65HqrTdrvs4FAQMHtkklINNO5e2xkndcjU1HmJb2Njb9d1Y6/XdWOTeucfPlBERZnADmksHBONZXlXlzNIdAgOdWC36cgGVQMBoGAPzwAWlfjp6kxSFaHqAP6dOz5Bz73/kz8v1dT1XnzUJ59Fm37dmjTBuEgiQp0dP5yaBp4d4dr2GwH/UNYR0dHR0dH5/cnKyuLVatWkZDQMrlOY2Mjffr0YefOnSepZTp/NEKhUAtLhT1i8uuvv47dbic2NpbY2FjGjx/P1KlTMZlMdOjQAau1pYjyxhtv8PPPPwOQvm0rn77xxnG1R5Zl5s2bR0NDAykpKezcuZPs7Gwuuugi3nzzTRwOB4mJiaiqyptvvonX6+WHH37AarXSrl27Fh66e6isrKS+vh4I+/YezDYDwqL7nXfeSWVlJYmJiTz//PNh4b1zy3e71dUBdjSFUDSNOp/GA780clOPaPaoxIVNMheu/4buVQXEeRvZkZzJ2tbd0ISjnLsuCESyVO3393X7miLumv8GSS4ndY447jjvAQIGCRIzUBCwyH7ax0RT61Op96kRHVvcXY8mGnhwST1Lyn24AzIqIoIGTQGVTglmzu17LvuT7pBIdxjw77bsMG1fyob572Ow2FmX8QSn9wnbCyyr8LOpLkBRyEb37j0IBAL0yRpMp0QrOdFNbNpZRpOmkdEpK1L3/Pnz8e5+n1izZg2VlZWkp++TUKttW1i1KtwV6ekRkTncNQJj29mAMch+FVXehmQ+HVFK5uXvl/LK048RYxZp//XXvP766y08mjVNY26JD5+sEnAbweDAGPDi80LJLg/XXXcdkyZNQhRFRo0axTPPPENsbCxXXXXVAdf+voRCIbZs2cKZZ55JbW1ti3vraAkGg2zatIm8vDysVitLlizhww8/POZ6TiRO1UmIECliym9S/1jjWH6Rf6FIKWK0aTRZUtaRNzrB+DU/cUIcElJEaLZw9NG/c0t8fL4tPCi1rjZIdqzxqATdlVV+3t/iJsYscnvvGJL3EyzfD7xPMNCLkKYQMFYhyQ6CisbOptBBhea5JeFnuCAINAQ0hmVYyHOGgLBffGNAJe0kB7f+GpFZ07TfTaTevL6BtSvq6dQthv6nHD4KvX1ONFf8vX3EOqN1Wxt3XLcSV1OIgUOT+Odd4TwJjQ1BHrlzHfW1AZJSLDw0qRflJV7+88/VlO7yIEoCdrtETJyZ6ko/wYCCI9qI2yUzaGgSq5fXo2mQmm5j3cp63nyhAEXW6Ds4kVvuO/FWLyeT/7dCs1ZTgzJlStiL2eMJezGbjn3UXkfnT4nXC3tGNt1usP/5pmPo6Ojo6Oj8FSkqKgonj9mPQCBAeXn5SWiRzm9NKBRi3rx5GAwGhg0bdoDYeiji4+MZP34806ZNi/jYaprG6tWrKSkpITk5GaPRyIQJE0hMTKSuro5x48Yd8KJfV1cXWd4j6h4P06dPx+fz4XQ6aWpq4tZbbwXgnnvuITMzky1btnDqqadiMBgiAmVpaSlTpkyhVatWrFixgrvvvrtFnRkZGbRt25bi4mKMRiP9+/c/6L43bNhAZWVl5HjWrFlzUIuNzvEmjKJAXUgjqEK5W+GnEj8GUUDRIMUm0TPRjCRAenM1Pcu3sDaj28GDMgT2i2puGfMc52kgye1kV0IGIYOJ3mWbSXGF+zfZXU+ms4ytia1BVUEy4fV6qN+6g8bUbqi7q5cEgfW1AbY1BNneGGJztZumoi34LHFgiyHeYSPBKpFoPfCaKS4upu3OFWixnbl8QCZ94jTGnf8+ADH4+GXODE7v04U11QGeWt0IQJVXJiPKSHSUiVPTw1HHGes+oaDQidXfwM+V8Yx68kkA2rTZ680cFRVFXFzL6fDilVcixMaiNTYijht30PMGYLCMBcKJAzfXBXnv5000BlUagypWQzPl5eUthGZBELAbBVZWhwh1Tse7ZQ6Kcxtd2pxLZnsHjqgBfPHFFwBcddVVkahkVVX55z//edA2+Hw+zjrrLJYuXRpJQPhrUFUVj8fDwoULI9+5XC4CgQCJiYm/uv6jZVFoEZN9k1FQuMx8GZebLz/h+4gVY5lin4KqqYhHOyBzgrnOch3P+Z5jkDAIr+IlxZDCNZZrjnr7xkDElR1Vg+bgkQVdTdN4bk0TfkWj1A3vbXHxn76xLcrEC/Ekt95CfXU71EAsSVaJVg4DfZLNB60zO9ZIfVVg97KBUW1sLCj1U+qWOSXNQqc/oVfvHhaEFvCq/1UsWJhonUhnw7Hbbhwt5aUeJj2yGUXW+On7Cv7zuIGuPQ9v1zH6nHRGnxMeKPvgjUJcTWGB/5dFtVx4ZSYpaVY2rXVSXxs+P7XVfjavb2TrpkaaG8NlVUWjrjZARZkPWdYQd487mkwifQcnEpdgprbaz0XjM1m3oh5lt7XS6mV1uF0hHFF/3vO7P//vhGZN01CnTkX9/HO04mJISkLo0OFkN0tHR0dHR0dHR+f/MTNmzIgsz549u8V0a0VRmDdvHpmZmSehZTq/NZMnT2bJkiUAFBQUcNM+XrZH4uKLL+biiy+OfP7222+pq6vD6XTS2NjIHXfcgSiKnH322Yes45JLLqGwsJBAIMBVV1113MdRX19P69atiY+PRxRFTj11b1Kwfdvo9/vJyMigtLQUr9cbESzXrVt3QJ0mk4lnn32WvLw80tPTadWq1UH33bZtWwwGA7IsIwjCIe+VLgkm3j0jifO+q0IQwmLu9qYQX56ZwswiL9/v8vK/Uy4kxxliXmo3ChIz4ZDimbDXLmM/kVnQVBxeN02WKITd6/LSclAFEVFTabDGUJLQGtXs2C1Wa2iaQoEvFs2nIRHWtmVNoyGg8tAvDaBprNtViRIKEk0d1uZdpHcfyGmZUVyY3XJq/NKlS7n55psxGo0kJydzzsMP07VjL4a0T8bZ2IhRFEhODtsbFDWHIttlxRi5LMfBgFQLHXaLWk3lu0itKwWgsnKvCDtmzBgkSaK0tJQRI0a0sGMBECQJ4dwDo6wPRWlpKR/N/AUloQ2S0YIS8hOX2pr27dsfULZHoolNVW7q82YQDG4gs7OEZp+NyRxOdi4IArIs09TUFNlm30GUnTt3UlJSQp8+fYiOjuamm25i8eLFhEKhA/b1a6ipqeHmm28mIyODFStWEAwGufjiixk/fvxx1VesFFOv1dND6oFBOLKUMyM4A4XwwOX/gv/7TYTmPRyLyKwoKiuW1CFJAv1PSfzVUa4dpA686XgTAFkLR6IfTf/sYXRbG0sq/OxqlhnWykRO7LELfvs9AgB4wPoAn0mfce7wBsaqY/H6bLSNNhBlOnhf3d0nllnFXkQBzmxrwygJvDosgYCiYTGcHBH/RDHVP5WAFiBAgA8DH/KU4UDv9BNFTaWfgE9h53YXPp/Clx/s4pHJR+8LnbJPwlSb3UBUdPh6yMi0I4oCqqohSgL5GxuZM6Oc+toA7uYQGiCKYesNo6Lh88pomkaTM8CuHS7ufbIHCYlmBEHgh+ml/LKoFoCkVAu247BE+SPz1zqaI6Dt2IH82GNoa9dCMAg5OXoUs46Ojo6Ojo6OzknnvPPOA8ICyYQJE1qsMxqNZGZmMmnSpJPQMp3fmi1btkSW8/Lyjmqburo6Zs2aRWJiImPGjEEQBOp9CvNK/UhJbem9e+Za3759j1hXr169+PTTT1EUBYvl0NPNFUVh1qxZuFwuxo0bR3R0dIv155xzDitWrABg3LhxJCUdfLqyxWJh8uTJFBYWsnTpUr7//nuAQ0Yr22w2+vXrd9hjyMjI4IknnmDt2rX06NGDnMMkdT+ttZW+KWbynCE0DbrEGekQZ6Sby8RPpT5c0Qm8M/I6PL4gLu34xB1zKIAzKg5VELHIQYJGM/lpOdx77r20qytlbUZX3JY9th67DZ4NZgRHAoIcBEQwGIg1i1gkgXK3gsMIcXipcdeT0LyDnr4C3rpvDPHx8S32XVdXx8MPPxyZASGKItu3byc3N5cnHn+Mb775hoSEBC655BIWLFiAFhSINXWmMaiRE2vkbx0cmA17hb+//e1vvPTSS1RUVESiy9u2bQvAGWeccVz9sz+BQID77ruPhmY33qwxpFx4B73jRV64qN9Br8l4bxV1OwvxVO5CdTcSm5KMrATw+/2UO5v5aBfsaFZpP+pSZr3yKLIsc8455+D3+7nrrruYMWMGiYmJ5Obm8sgjj7B27doWif5OFH6/n9mzZwPha9Rms/H1119z5ZVXHrO4ujS0lGd8z6Ch0cvQi8dsjx1xmwwxgwKlAIA2YpsjlP79eOfl7ZHka1vHtWLCjdknrO5jEZj3EGMWmXJ6IqH/fQuPv4cSHY300EMIBxnk2IMgCNzZJ4Z3t7iIMYlc06XlYI+qaczaEkNZ/bWc2spCVo4DdkdJl7lkgqp2gH2G2SBwXvuWodSCIGAx/D52E78lUUIUHi1sTxItRh+h9K+jc49YFFXD45YxmSW25TVTWe4lLd12xG0bnAF69YtHVaGi1MuwMakRETizfRTX39aBbz4r4bSRKSz7uRajSURRVBRFQ5LCE1R8HhlNA8kg4vcpeBWN/31aytpfnNz7eHdGjktn7PmtiYo2Ul8bYOgZqYjin/8c78v/G6FZnTkT5Zln0CoqwlHM+/ne6ejo6Ojo6Ojo6JwsVDU8dbddu3asWrXqd51erXNyGTp0KP/73/8iy0dC0zTuvfdeqqvDQo3L5eLM8y7ijsX1lCb0ZVsXOx22fsOYPjmRqNWD1bFy5UpkWWbQoEEYjUaMxsNH8X3wwQd88803AKxcuZIXXnihxfr09HTeffdd/H7/AdGt+2OxWOjWrRvdunWjX79+hEKhQwrNR0uXLl3o0uXofC7vzo3ltY1NWCSB+/uHI91OaWVmTomRLc4QXSvyWWNOxSoZ8BqtaIKIergKNa2FvUbQYMYa8iGiEdrHCqUwqR2FSZl7Ngr/I+z24BAlNA0UQcKgKbQ1y/RNj6bMozCstYX1tSG6delCVdMuBidHc935DxIfH4+maWzesoUXJj1NMKhx9tlnYzKZsNlsNAcVClP685VpANnVAfq2a8cdd9xBKBTiwQcfjIj8486/kMfumki63YBRail4DBs2jMrKSj788EOKi4u5//77effddzGbDz79/3hwuVw0NTUhAp12/MDwLJnbr/73QcuuXr2a5e+9QnxNkASbjcZAPU6nxDXXXMMtt9zCQlc0NQOvQbPGIHo70nnAOaTUb+G7777DYDCwZMkSAoEARUVFaJrG2rVrcTqdLRIZnkh27NhBdHQ0gUCAtLQ0+vTpc1wRvEvkJWi7r5n18npcmoso4fD5pW603EiKmIJP83G+6fzjav9vQd76hoMu/55omsb8Uj+NAYVR6SZsm9bBq6+AxYLW0ID62WdIDzxw2DoGplkYmHbwwbmfy/x8tytsEbSr2U33RBOd403M3OXljU3NaMBF2XYmdPn/kSPsfuv9fBj4EKtg5Xrz9b/pviwWicuuzeLTt3diMokYjCIm85EtqVYureX157eiyBpnXZTB9be0HLBsagzywM1rqa8NMP+HSkafl46saHg9CpoGqiZgMICigCQKyCEVSRLQNPD5ZHYUuHhq4iZOHZGKxSIxdGTqb9UFJ52/vNCsNTWhTJqE9uOPaE1NYS/mo/Q909HR0dHR0dHR0fk92bVr18lugs7vzHXXXceAAQMwGAx06tTpiOW9Xm9EZIbwNbOrKYTTr2K32+nRqzfnjuvJP/q1PqSg9f777zN9+nQAhg8fzu23337E/e7YsaPFPg+W2EkUxSOKzPvTp0+fYyp/IhjV1saIDCuisDe5lcUg8sypCQQVjZ8+nMGU9CFU2hMY0FTErN6jqfCohxab9xMpVVHEYz6YyeuhomYFBEFDVFRUSSQ+6MZvtPNzmR+bUWRdTZBTWlkQBYEu/7iMs7LCddd4Fe5bWsFP77yE1tSIsm0ts2fPpn///nTp0oUCn5nWZ09gR0Ut1723lRf6mxk6dCgTJ07kzTffxOVyoaoqeXl5bN24nltuuYXOnTuTlpbGO++8w7Jly+jZsyeapkUGIpqbm3G5XMckNAeDQb766iuCwSCXX375AdsmJCRwyimnsHTpUqxWK2NHHzxSurS0lMcff5zq6mp2rV+PwWBAkiQMrVvx+OOPh5P4tR+A1u8apFAIQbJSFpNDcP1sRFFk7ty5NDc343a7CYVCFBQURLzND+aNfyJQVRWXy4Xf7ycqKuq4o8C7Sl1ZEgpb7LQR2+DAcYQtwCyYudR86XHt77ekz4AE5s0Me6rnDjz+AECfrGKRhKMW7ut8ClUehZw4I9+uLOaLUpWAxYb1iUmMrMuH/HyENm0gIQH2sa86HkJqy3s9pIQ/zynxRp4Cs4u9/2+E5nZSOx6yPfS77W/sBa1x1gUoLfJwxlmtSEjc+8zxesOib1prK4lJewcK5n5fEfFN/vHbci6e0K5FnWt+qaO60oemhgcq5JBKv0GJ5K1roKkxiKZCbJwJr1chuNv32xFtxOMKhcVng0AwoLB5XQN9B/21gwn+0kKz5nQi33kn2rJl4cRnHTr8blkudXR0dHR0dHR0dI6HPUmkSkpKCAaDLdbdcsstJ6lVOr8l3bp1O+qydrudoUOHsmjRIoxGI8NGjCSkajiMAu6QhtkoMaxDUov3nj0Ro+np6QiCwJo1ayLr9l0+HKNHj2bz5s2oqsro0aP/9O9V0iGmKpskAW9WDg/+/D4AK4aeR02KBX+FH2dARdMiZheYRUi2ilR6VRSNvUL0vokCD9tN2t4CgoAqiqBpyBo0qUaUgEp9QCXBKtLol7mpVxyvbGhiXqmPoSkiM7fWsLbZR0WnS5GNUdC9GuGbx1myZAkffPAB3ykd2FQforyiglBdKTd+8h7PPvEY8+fPx+/3R2ZSaJrGjBkz2LJlC927d+eGG25g2rRpFBYWMnv2bC688ELsdjsej4ehQ4ce84yLu+66iy+//BJFUfjwww9p27YtFouFe+65h6ysLARB4D//+Q9lZWXExsYSFRXFjh07qK+vp6mpiTZt2pCTk0NVVRU+n4/m5uaIJ7fH42HNmjWoqoqiKGiiAZrqUOyxCIJA1baN1G3ZEo783rwZTdOwWCwYDAZCoRCyLB/TsRwPiqKgaRp2ux232w2EE1guXLiQnJwcxowZc8Q6zjKdRaKQSI1WwzDjsN/1/tPKytBWrICcHMTu3Y96O3XePNT33oPYWKT77kNIDydbu+rGbHr2S0CSBLr3Pnrv3Eh7NI1n1zSxpMJPul3iyVPiibccPphwW0OQicsa8Csa2aVbmfD5s/xblVidO4L+098JK2OtWoHNhnjGGYjXXnvU7SlplnllYxOyCv/sHk2HOCPDWltZXR0grz7Iqa0sdE8MW7ZmxxrZ0RS+5tofhxf08aCqKl9//TWlpaWMGTPmqGd+/JkxmSSu/feBFkp+v8J/blzFtrxmYuNNPDu1H22zwoM2rdvYKNgc9nVvlXHggKnXIxPwq8iyhsEgMHBIEvFJFtatrKeuxo+mwbmXZvDUfZtQdw80WCwiZosZWdZITbOS0spKUsqhLar+KvxlhWZ19myUl19Gy8+HNm0QHEce8dPR0dHR0dHR0dE5maxbt46xY8fi9XrxeDzEx8dTV1eHzWYjOTlZF5p1gLBwd+GFFxIdHc0rhSJrVjSiaRrntbczuq2NjKi9r3lbt27lwQcfxOfzceqpp3LPPffQt29fiouLgSP7OHu9XgRBICMjI2KXkZWV9dsd3B+ADnf/i48yeuBDYuxZ/TkjysC9S+tZUuFH1didnEugc7yRGJOIzaRgEKGoWcYoglcGWQVV26s3i4BRFAi0iHQUI/8XEJDF8Hmrt8WGv9mtXOeVN6DM/ZIVXQbSkNKdgl0lvKRJGBpKkeNao1nioaIACpagxaXhrdrKjTOL0JIl0FT8xZsJ5i+l2G/gxqffQKysjIjMe9A0jeq6ekL5O/h69s+sWrUKn8+HzWZj1apVfPLJJ1gsFlJTj32698KFC2lubkZRFJYsWRKJev/HP/5Bnz59uPXWW0lPT2f+/Pn88ssvxMbGsnTpUnbs2EFsbCwul4v27dszYMAAduzYQV1dHaqqIkkSgiCgaVrkP7b/AvkLILM3WuV2mPMqstbyWGVZJhQKHdAHvyWaprFr1y5qamooLCzkkUceIRQKMXfuXOx2O0OGDDni9kVqETuUHaQIKQwwDvh92u10otx1F5rHE7Z5efxxxB49jrydLKO88grIMjQ1oX78MdJ//gOEZxH06ht/hBoOzfbGEEsq/ACUexTmFPu4JEMEq/WQAvySCj9+RQNVZVtlM4H4BMwVVVz26bNYgz4IqFBSgnjXXUhXX33o46quhlAIoXXryHevbGwi3xlOJPnCuiZeG56ISRKY2P9AEf3G7tG0iTIQVDTGZh7b7I/j5bvvvuPDDz8EYPny5bz77rs4bDbUt99GKyhAHDECcdy436UtJ5tNa50snleNImtUlHv57qsS/v2fsPB+2XVZxCWY8XpkRp+bfsC2RYUeevaNp7rCh8ks0OAMkNM1htHnprNzm4s+AxJYu6Iek1nc7aQkIEoiXXrE0lAf4LQzUhk+tlVE2P4r85cSmjVNQ1uyBHXaNNRFi8DjgexsPeGfjs7+SBJcdNHeZR0dHR0dHZ0/BLfffjtnn302b7zxBjExMfzyyy8YjUauvPJKbr311pPdPJ0/CIIgkJWVhdOvsKamFk9IxSdr1PmUFiIzwJw5c/D5fAAsWbKE6667jquvvpquXbsSCoUYOHDgIffz5Zdf8sEHH7Bjxw5SU1NJT0/n2Wefjawvag4xf1MR89+bjOpt4pprrjlhCeIgHIn3zTffUFlZydixY383gbtnkpmuNw1HUYkkxvv+3DR+LvXx0C8NFDaFSLCKeEIa0UYQBYg2iVzfNYr8hhCuoIo/pJHfGERRw6KzUYRTWllYWR3AE9JamGgILf8XwSiApMkY3TWk1m5ic2kbar0x+P1+MNkI7f4XJQQL3wO/C5xl0LorwbgMjLtdfY3blhD0NGJq3xtPzS66ts/B5/XS3Nwc3r8gYDSZ8asiDUGNGUoHLFGxuN1u/H5/RHBOSUk5rv602WwEg0FEUUSSJCoqKqipqaGpqYlNmzYxd+5cJk6cyP33348syzQ2NmI2mwkEAjQ1NWG322loaOCDDz6gVatWpKenRyxkXC4Xdrud1q1bs3r1apSQH759CkQJ1IPbYQiC8LuJzJIkoaoqJpMJWZZ57733WL16NaFQKFKmsrLyiPXMCc3hk8AnAKyWVzNVmkqymEwwGGTx4sXY7fbD3svHi1ZWFhaZIexFXlAARyE0I4oIRiPanojxE+jpHWuWMIjh+0pUFHq/+SzytnUIbdsiPfkkQvSByeY6xpnA70QDYiSNjniR4o1Iu0IYwl4IEBWFOGLEIferzpkTFs81DfHSS5GuuAIIt2MP8mGSSm7evJmSkhJOHTjwgCSex8uiRYuoqKhg+PDhB/XkX7p0KdOnT8ftduNwOPD7/TQ3N2NfuhR1t0e7sn07QteuCJmZx7Rvn+ajVq2lldgqkoTR4w6Rt6GR9DY20jMOtA8qLXJjMIpHlZjvRKGqGn6fgs1uCNvp77Nu3yR8JpPEORcfOmlm116xLJxTSSikUlnm54XHtyAH8+gzIJ7xN2azbkU9BXlNSJKA36eAAF63jLs5RFyCmXEXZdC5e+xvd6B/IP4yQrPW3Izy0ENoS5ag1dVBWhrsnhqmo6OzHxYLfPXVyW6Fjo6Ojo6Ozn6sX7+eqVOnRgSZQCBAVlYWzz77LBMmTOCCCy442U3U+QMRbRKRBNhSH0QDFpT5ub23FhFHATIyMiLLsbGxRO8WYfr163fYuhVF4ZNPPsHj8dDQ0ICmaURFRbFo0SIuu+wyKtwydy12kvflBzTk76BrgpHXXnuNYcOGYTCcmNfM6dOn88EHHwCwbNky3nvvvROahO5wGEQBw3754U7PsLIww4qmaTQHNf69oJZVNUEa/Ap+WSPKJHJZjoOpm5pJtIkIjeFoW0mEvikm7smN5c3NTcwt9eHaxxVHEEDUQIGw4KWpGFBIjzJR4xPwW2KpietI0BKL3xwDIQWcpSAZQFXB7YSgF9HXhCPUTGJCLM2qjM8nEzDYsKVkE2pYhbJhPtaMTmwp3I7P7SEmJoYuXbqQmZnJgtUbqVWtmPudiRzw0zb3dJrnfIkkSZjNZn766Seu2C2sHQ21nlruffpeyvPKcTqdWK3hfouPj6e+vp6GhgYkScLtdpOfn88rr7wSiTSWZRlJkiIJ+gRBQJIkPB4PZWVlGAyGSPK/b7/9Fr/fz5o1a9i6dSvNzc1omoaIhrjbXqPFeTUYiI6ODov1vwMWiwWr1RrxhvZ4PBQWFtKxY0eamppISkpi2LBhR6zHqTkjyzIyTVoTySTz5JNPRuxvrrjiCi699MR6MgsdOiCkp6OVlyNYrQhHmbRTEEXE++9H/fhjhNhYxENECWseD9rs2WGr0xEjYP16BIcDoWPHSJmZu7ysrw0wINXCiDZWkm0S9/aNZX6pj94V+WRt+gWMRrTiYrT58xHOO++A/QxaM5f7ZsymyBzH0AHZRKWMgPh45Ppa5Px8BE3D0K0bwj7PyxbtlGWUt99Ga2pCiI5G++EH2H0//LN7NC+sa0LWNG7ueXBv5xUrVvDEE0+gaRrTpk3jtddew2I5OgsFTdMoVouJF+KJFveK6F9//TVvvPEGFouF2bNnM3XqVEz7BFmuWbOGp59+Gp/Px86dO+nYsSOjR48mPT0ddeXKljsJBA5o79SpU7Hb7dx99920adNSgK1Wq7nHew9O1UlHqSNP2p5EDUg8fOd6qit8SAaBex/vQceu4f5QNZUn3p3DL9P9JEjxTPhnNiPObHVUx/9rqK708dT9G3HWBThtVCqXX5/FqSNS2J7fTGycmXMuObSwvD/DRqfx3ivbUBQNWdHwuGQ0DXZuc/HMA5tobgxidxixWAQCAYiNM2OyiNTXBRgxrhWduv063+8/E38JoVnduBHl7rvRtm2DlBTo0gXhN8oaq6Ojo6Ojo6Ojo/NbYTQaI+JKcnIyJSUldO7cmZiYGEpLS09y63T+aBhEgdPSLZS4ZMySgEkSqPTKZEbv9f4877zzMBqNVFZWMnr06BZCxKHwhlQ+3uqhsuOZWLYuINi1Nc0pbXGp1bRt2xaAwqYQAUVDNJrQAE9IIyFq7/V7IqioqIgsu1yuY05C91shCAIxZoEbusewdE4NBlGgdZSBSo/Cjd2jmVYYjgBNtknUeBUEYEeTzJqaAK8PT+bq2VX8VOQihAiiASUiMivgaQJRQg56KVbicNisSFYHhd0vwSCKiMEQirMMfn4XYtIQUrPRHAmIWX0xrP0WRQ7RVLASz/ZNCN1HohntNK6bDU01KEoQt7MCKT4NzWSNRA/n5uZS7VVY5bHTuHImdpOEmGCOWPbExcVRW1t7VH0jyzJOl5PxM8azfvV65KAMAejQoQOBQAC73U5KSgpFRUVs27YNALPZTFlZGaqq4vF4EEWRUCgU8SPv3bs3S1evx+RWaagowoiP4uJirrvuOgCsVis//fQTsixjNpuJjY2lbdu2lJaWUllZGbbU2I2qqjidzoO2/bfA4XBEBl5UVaW6uhqr1UpjYyODBw/GbDbz888/c+GFFx723hltHM3C0ELK1XJOM55GtpgNhL2e97Bhw4YTLzRbrUiTJ6Nt24aQkYGQcPTJ+8RevRB79TpsGeXhh9G2bg1/eOst2D0AIN14I+K4cayrCfD6pnDk/fKqAOkOiU7xJgakWujnr0K+8ebw9jExCN27hxP5AZrbjTZ3bvj7YcNQf/iBfk3l9KMYYUUFwttvU+9T2fbZLAQxbHFh7TeC3odop/rcc2ibN0N5OVpcHOwjZneIM/La8MP7lu/xBweora2lqqqKzKOIIJZlmcs+vIzNJZvJGJ3By/1fpqPUkY0bN/Loo49SVVVFUlISAI2NjS2imvfYI1mtVtq1a0dKSgoej4fa2loSx4xBWLsWtm1DGDGihbAP8MILL0TKvvvuuzz88MMt1i8KLcKphu+jAqWAAqUAe2km1RXh2TOKrLFhjTMiNL8eeJ3PZ7lQVAMuklk4x/G7CM0//VCBsy4soi+cU8W4CzN47KVcHrp9LTWVfj59eyd3PNgVw/6jigera2YF61Y6kWUVtHCktCQJaAKUF3uw2iQqSj3IsopkEJFllTZpdv5+e0fO+dvRC9p/Bf70QrO6aFH44VRWFk729wf4w0NHR0dHR0dHR0fneOjduzerVq2iQ4cOnHbaaTz44IPU1dXx0UcfHVPCOJ3/P5zW2sqCMj8a0MoukWYLv+IVNYdwBTUyzQGaXW4WNNr4do1I3wonE/vFYZQOPfPzrc0ufir1EZ07mpK0nqSoMiaTCSHaTo++YT/Lbgkm4swiGSMuxSD7yY0N8Perx59QoXncuHEsX74ct9vNiBEjjjkJ3fGyfv163nvvPRwOB7feeutBp6QDnJpu4aWh8byVF07wdk6WjVYOA8NaW1hQ5ifeLCKrGkFFAznEuqIqkvrFYilaSXSdgSZDFHJ0KhjCYr2oqqhyCDQ/eBpQbbGogM1iJmg04astRi1cCyWbEb1OzEEXFm8lblnAkXsGUtMu1PxF+LxelFATLJ9GKKMHyIGwiK0qoPhRXE6McamY/PWMHTuWzp078/777yOWV2ARJNLTkpE0A1FRUeTn51NQUEBGRgbz58+nV69exMTEUF1dTVx8PG//UsxPM2fQr20C0Yqbzz//HMkukR/Ix1vqRbJKWGItxMfHk5OTQ3p6Or/88guZmZlkZmfy08afcFW78BR7iImKoW3btlRWVuL3+1EUBafTyTnnnEN1l7NZdf+1CJIBzA6+//57JEnCZDIRCoVwu90oioKqqni9XrZv305jY2MLkRmIWGbsseYQRfE3tdHYE6EdHR2NpmmoqkpWVhaqqvLZZ59FxEZJkg47YyVejOd1++sECGAR9kbCDhgwgKVLl0aWfwsEmw3hCILx8aJt3x7+V9Ngw4aI4KkuW4Y4bhz1/pb2J07/3nOlPPoolJWByQQ+H0KvXoi7va6VBx/EvaUAv6IRU16JKTMTrbw8vC6jDfcucRJauYrmNkPol1BO0ObAPfKSQwvNK1eGLScFIbyv3UkdD8XixYtpampi+PDh2Gw2+vfvz/fff4/T6SQtLY1WrQ4tssqyzKJFizAYDBTWFrLoq0UANK5r5Pu3v6djUkdmzpxJbGwsNTU11NbWctZZZ0UE5z2ceuqpfPvttzidTurr67HZbDQ2NgLw4IMPYnjssUO2Yd9ZKQebodJG3CucmgQTKWIKjnQr8YlmnHUBBIEWNhHr5HWY26Xi3RxLk9r0u/kUxyXs1QdNZhGrTWLq5K2sX+XE3RxiwxonrqYgj72U22I7TdNYvbwev09m4NBk1q2s5/F71hMKqYSCKrHxJkae1QqfR2bu9xX4/Qo+n4IggMkiYbNKGIwiV/yjPWdfdPAo+b8yf1qhWXO5UN97D/WLL9BqasJezCdoipaOzl8ejyc8PQnA7Qb7gf5JOjo6Ojo6Or8/Tz75JC6XC4AnnniCq666in/+85906NCBd9999yS3TuePSJ9kM5OHJlDqkumbYsZsEJhX4uOl9U3hSONvniFQto3CphDJfUoRxl7Nsko/p7W2HrLOWl9Y3LFardhTMmjt2Pue5QqpOEwi8RaJl09PZHtjDFnnP0a85cTn/Wjfvj3vvfceLpfrABHlt+SZZ57BvVtIeuedd7jvvvsOKOOTVWq8Cme2szMgLdyXybZwH9zRJ5bruqp4Qir/nF/L6u0leN67g7m1uxgyJQtzUjr27LNRNQ2vS8OR1g5fSEVwluP59nkYeHHYY9jTiGqzEWMWMW/4gfyF36NV7QSTFUkyYIlPwrDxR6La9CS9oYYoatksy/j9/rAPsc8NNUUQ8EDQHxabIewx21zDeRdfSHJyMjfccAMN8R3w2lWE+hKqq6sJ+P00NjYiCAKhUIh3332XWbNm0b9/f1q1akVRUREeUwxbq5vxO6uZXbETm6hiMEgYTUbcATdilIjiURh37jiev/N5YmNjAViwYAGCIPDQJw8RrAuCB1RUGhsbcQVdyMgIooDZaqapqYm33nqLMkd7jLYofDWlGIxmZG8jBoMBRVEi/+4RjL1eL6IoHlREFgQBURSJioqKrA/sZxtwPOxJSrjnXwCTyYQoiiQmJlJbW0v79u3JzMzE6/WiKAoOx16x7Wh8mgVBwEJLu4W7776bYcOG4XA46Nq1668+jt8bcfhw1LlzwzPS+/aF3b9/wu6B1VNbWfix2EdpWT3do6BvSgrqihWob7yBtnJl2DrGZAKzGXG3UK8pCs5NBRQ2hX2wnfM2MOa1RxDbtQNVZd2A0aS+/An9ls+kKSSwvUs/fh51BbcZmlCXLEHo2RMhKqplO3v3RsnLC3tNt26NVlMTOd/788UXX/Dxxx8D4USYzz33HN27d2fIkCFMnz6d5uZmPv74Y6699tqD9skLL7zAokVhcTkqJgojRkKEUIMqSd4kKtVK5o+aT2GPQtIWpJG5I5PHHnvsgLYkJyfz+uuvU1NTw/333x/528Ln8xEIBJg9ezaSJDF69OgDxOT//Oc/vPPOO9jtdv7+978f0MYBxgHczd1sU7ZxiuEUksVksMFDk3qxbqWTNu3sZHfca/MxwDCAijt+oGl2OgPsfbnqvOyDHvuvJRhU8Lhl4uLDAvPoc1rh98lUlPoYfmYaC+dUsXRBDeWlXnweGVES+O6rUrI6RtNQF6BT91jGnt+aaR8X8c0nxVSUeYmKMdK5Www2uwGjUcRgEDlleDLPvN6XXxbXsnRBDcGgiqqEI5xjYo0kJVs4bXQql179106ceyj+dMqs5vOhTp+O+tFHaDt3hr1mc3J0qwwdHR0dHR0dHZ0/PX379o0sJycn8+OPP57E1uj8WciONZIdu9cu4+dyXyTZ3NbtO8jenXfJWx2eSu0wHv7d6W8d7BQ0hK0x/tU9msUVfhoCKiMyrKTZ975CxphF+qb8tjNKLRbLUXuZngg0TUNR9kZR7ru8hyqPzD1LnDQEVHJiDfQsmU1+3mZOOeUUzjrrLLbUB/loq5tok8AHo5N5cvNnvFBZhNquH6s9fgaZ6uix9Qs0BNL7DUdNSqJPgsST90/Cv2slSs0O6HMOhtpC2px6JukhI+410zAWrkWxJoKqIplNKKmdGBDMZ/N331MVCFASDGIwGCJCp6Zp0FBOOP3V7itCkDA6YshMicNsNvP444/jlzW0sZfD4o+QNAVHnIM2SdERb25RFNE0jWAwSHFxMeXl5URFRbFrVzl1pSWEXE7QNFSjEZvNhqZpxEgxJKcnYxEtjOgZjkb/5JNPWLlyJd27d2d+3nxWlaxCtarQvLfvVVUFE2iyhk/x4ff7+bmggibNiagESGjVBqvqp1VmTyoqKqirq8Nms0VEtn0F3z02K8bd7YqLi0NRFNLT08nIyKC8vByTyURVVRXbtm0jGAxyMAwGA0ajkaioKOLi4iJJCPdcGyaTiYSEBDIzMxFFkcLCQhRFwev1Yrfbyc7OJi0tjddee42cnBw2bNhATEwMM2bMYN68eURHRzNu3Ljjul4lSfrNIpl/D8Sbb0Y844xwEFRSEtrPP4eT8p1yCgAWg8izUgGhL55FVBTE5stQv/8ezeVCSE5GUxSw2aB9e5SnnkIxGBCHDSO/6wCMy5agIbA0ewD9MZF8ySUAJDeHMFRX8MjgawlKBi6p28DDjnIynniEgKhiTG+FNGUKwj7PHfG++yA5GfWLL8DhIHTWOby8romGgMplOQ66JOy1JMrLy4ssFxQUoCgKkiSxdetW4uLCNh1Lly49pNC8cePGyLLZaGZwymC2Vm+lU7dOjDKP4pPAJ5jam2jlaEWoTYjJCZMxGo0H1FNQUMCaNWvo3r07//73v3nllVewWq1cffXVTJo0ieXLlwOwfft2brvtthbbdu/enRdffPGw526ocShDjUNbfBcXb2b4mLQDyl5vvp4+SX3gSugj9flNcqmVl3p46v6NNDeGGDwsmRvv6IQkiVxweWakzJL51cTEmrDZDPi8MlarRDCg8MV7O0lKtbJ+lZPUVlZ+nl3FiiW1+P0KgiBQmN9MbIIJRQlHNFdX+Ni0toEefeJISDLj8ymEgiqZ7R1kZNrpf2oSV//rtxHT/wz8qYRmrbQU+T//QVu3LjxtoV07hKPwGNPR0dHR0dHR0dH5syDLMj///DM7duzg8ssvJyoqioqKCqKjo1tEwOnoHIrOcSbW14ZFs+6njsSUN5c2UUY6nDaSCzs7yD2CONwzycwnY5IJyAqzvp1Ol+IShowYxSm9e/wezT+pCILA7bffzttvv01UVBTXXHPNAWX2CO8AvyxbypoFnxJlEtm8eTMdOnTgiV1xNAf3RNI2M31tEfKIGyG+NQFVwZQsc3nXGN746Au+XrOLxB1fYI7z0sHswyUq+OqLCP30Gqa+4ygt6kSV4iemeAeiHEQw29AECIlmTHFpFCz8hvLy8ohwY7Vaw5GvFkvEtgExHGktRCdDXAoWg0RZbQ3vvvsuoVAITRBRtywCRxLGkAd7bDznnXcWd911FzfffDPl5eUYjUaMRiPx8fEoisKWLVtwud2Empsj/RIKhbBYLIwcORKz2cysH2fhs/h4bN1jLGq7iIrPKnDWO/l44cc03t4IA4BG4GEgFYQSAbVZRVRFRKtI917d2elLoqnrReHI5fRqum2fTnpaJrfffjs333YH5dV1eOqdGKS90obFYqFbt264XC58Ph/Z2dkkJSXx2muvsWvXLhoaGpg0aRJr1qxBkiRyuvUgo9cp+JtqaSzbhdfrBYgI1lFRUaSnp3PppZeSmJiI3+/niy++oKioCJvNRqdOnbjzzjsZOnQo27Zt45577onYfuwRuy+//HI6deoEhC2SAG677Tauuuoq7Hb7CfUenzlzJvn5+Zx66ql/eBFaEATo3Hnv5zFjDiijzpiBuFvUV7/+GsHhgGAQ3G7E4cNBEFBXr0YrKoLERNRAAMsV/+KbpK5UpWYS1b4t8Za9g2uZ0Ua2DTgDKl3YBPix2wi0mcvoW+/HKEI3KpBKSiAnZ2+7jMawb/Rll4HPx9RqKwuKw37EhY0NfDomOXIPDhkyhPXr16NpGoMHD0aSwvdft27dIpHr3bt3b3GM+fn5NDU10bdvXwYNGsSsWbMIhUK4XC6Sk5PJsefg2+rjpptuovPznRESBFJTU7EIFtId6Qf0WVlZGffddx+hUIgvvviC5557jk8//TSyvqCgILK8xyv9t0QQBHINuUcsV1HmZUdBM527x5KYfGwDjPNnVdLcGI5iX7aghvMva0tKWsuZOyPHtWLtL/Vk5TgQJTCZJLxembJiLw31QbI7RdPYEKR0l5tQUEVTQUPD71coK/aiKhqaBquW1nH1uYt55eNBfD73dOZ+V4HJLJLZ3kFiioWvPyrm3n+t4fRRqVw8od0xHcdfgT+F0Kz5/ahff4369ttoxcXQps0BUxl0dHR0dHR0dHR0/uwUFxczZswYSkpKCAQCnHHGGURFRfHMM88QCAR44403TnYTdf7grFq1Ct/GTZzfYSAJ6W0Zeea/qS0/B7PZTFragZFmh8IkCcyeOYuPPvoIgNUrfqHbO+8QExNz2O0ONZ38z8SgQYMYNGjQIde3idrnNTrgwbyP37XL5cYv7+2j4mYZNTkLxCTQVARRwmOLY8GC2azy2AmlxOOOzuKb8o3EVFURDASQJAmDwYwtqRWurUuhYCEejwej0YjBU4m7/VCUjkNotsXjMrZClEoRBQFZlrFYLERHRyNJElFRUWGhWTJgye4Dw/5BdFw8u5bPxelXCM15HcFZhqbICCu+QjCY0RzRnHfl+dx0001A2EZkzZo1ETG0qqqKZcuWAWC1WHDtIzQLgkCXLl3oMaQH73zyDrJNJigGKf6wmK92fYVSp+BP9CM7ZDCCiIghzYBhloGAP4Cmaog3iWg1GlKMROvcseT72hASzWhBF0JMKg1+lXNyc2nTpg1eayIqhWiAKhmIttvo27cvHo+Hrl27MmXKFIqLiyksLKRv377ExMTQq1cvJk6cyM8//0woFEJRFIoag1hbZRDSDMS0MSGUbiMQCCDLMlarlZycHMaNG8dVV11FRkbYb7W4uJiE3Ynn0tLSGDZsGMXFxXg8Hq655hpWrVpF9+7dGTduHF6vN3LvNTQ0MHPmTGJiYjjzzDOJj4//dRfrfixfvpzXX38dgEWLFvHKK69E2vxHQdM0tC1bEGJjEdIPFEn3oK5YAaWlEB0NTU0RH2bh0ktRr70WRBGtsBBCIdgzwz0QQCsups/UZ8mx2Nl59b/pdEpvDGLLZ1Kn03Ip2VgJqoocHct2KUAu3xNTXUqoOoBx2jSke+45wJ61ymDn9V0Ki8o9SALYjCJeWUNWwbjbPeiMM86gbdu2zJ49m8zMTILBICaTiZtuuilib3L66adH6pw5c2bknPXr14///ve/DBw4kOnTp7NhwwYKCgrIy8sjNzeXYDBI6sJUoi6Jok6t4zLzZRiFA6OZi4uLCYXCoquqquzcuZOcfYTz4cOHM23atMjyH4GyEg8P37GOYEDFEWXgsSm5JCQe/QBMUspeYdpqk4iKbtkv1ZU+3pi0Fb9f4dJrs+g7KJE535WzcE4VZcVemhuD2B0GBp2WxNcfO6iu9FFZ5kOWtd3WGHvrUhRocAZ56I61fDLzNMb/I5utmxt5/uHNlO7y4PMpZLZ38P20UgYMSfrdPKn/KPzhhWZ10SKUqVPR1q4Nf9Gxo+7FrKOjo6Ojo6Oj85fk1ltvpW/fvmzYsCEiYgCcf/75B/VJ1NHZl82bN/PYY4+haRoGw3e88sor2I127LsTjh2Mmpoann/+eRoaGpgwYQKnnnpqZF1tbW1kORAI0NzcfFih+evtbj7a6ibBIvHwwDgyov64721aXR3qrFkIcXEIY8cekxXjgFQLd+fGsK0hRL9+Z/NVaAubN29m8ODB9OnTm3+VBXhxZRWqt4kLOiRTdtpYKmb9QMCRjCb7WfXJS6zdtZpQSg5ycR5y9zOoyv+Z6qJtqKq6+/yFsC7+GMnnwx8IIBsMSJKEt6kJmr6H4o2QexZazmAMlVswCwo2m40zzzyTjh07snPnTtasWUP79u25//776dmzJwUNQf67rIEtHYZgrCki0KoTmt+L6KrBoIYQQjLWgMaugjwCgQDvv/8+r732WkQoM5lMbNiwAUVR0DQNi8USsdXQNI3s7GwEm8Az7z2DYlPwWD3IO2XoBcFzgwhpAtoCDTYCQjhS0JpsRUvSCHgCoIF6torwgoBsM7OxZ1+EAgmMMQjl+Rgay+ncthUWi4V27dqR0WsQFTu2IJosRKe0pnebROrq6igvL0dVVR577DGeeOIJOu5OMLeH+vr6Fp9VUaL9hf+m9KfPaJfgIIu+zJ07l6amJtLT0ykpKWH69OksXLiQp59+mr59+3LDDTcwadIkFEXhpptuYsWKFTz55JOoqkq3bt148sknIwMuRqOR999/H7/fz+rVq6muro60Y8KECb/qOt6fmpoaICzmulwuioqK/nBCs/rss6hLloAoIt19N57+g3lviwt3UOXyTg4yo40on3+OMnly2CrVYgkLzZqGVluLMGUKQa8fnwJ1tV6SB/QiqrwYAgGEzp2hsBAcDhxAz/ULMVwSjpLWamoIvPU2i0iky5jRWHqn4Q5pDEw185ypGz+NupxLPp+EUQ2gvvMOQkoK0nXXtWj7y+ub2VQfRBKgwqPQOV7k2i5RByRX/f7771mwYAEQjla+5557kCSJNm3aUFZWhtfrJWp38OSKFSsi261atQpVVenTp08kyaPZbMZoNEYscXpl9+JUa/g5XVpaysPvPIwkSVx22WVkZ4ftGnr06EFqaipVVVXEx8e3sOUCmDBhAoMGDUKSJNq3b8+SJUtYvnw53bt3Z8xBosp/Dwo2NxHcPVPE7ZLZuc11TELzqLPTkUMaFWVeho1Jw2Zv+fsz48sSqsrDUeizppeR2sqKzWbAYBBpnxOFqmrc8WBXrFYD/7q7E5MfCeF2ybjdIZSQhiDAvrlFJRGsFonN6xpJz7Dz85wqggEVQRRoqA/Quo0Ng1HEYPxzD7weD3/YX37N6UR5+WW0775Da2gIRzHrUwV1dHR0dHR0dHT+wixevJhly5Zh2s8eLjMzk/Ly8pPUKp0/C8XFxRExQpZlysrKSD9MxCDAhx9+SH5+PhBOQjVw4MBIYqgzzzyTxYsXU1dXx7Bhww4rWPlllQ/y3WhAjU/hi21u7sqNPSHHdaLRNA3l/vvRdk9jF5uakK644pjqGJpuZWh6eFp2xh138Mwzz9DQ0EB9fT3tVQ+mz+4iGAzy3iwHY295hkIa2TbjHbTGaoKuOgwGA9ZgMy7RBqu/Ra0tCofJ7WZf6wWz2YzP54tMwUdTwdsA3iYMXYbSPXcAvTtkcN9992EwGDjjjDMoKipClmW2bNnC4sWLw96w0UmoHYciF+8ipKrQ80wskoiUvwBN0wiFQgSDQRYuXEifPn1wu93U1tbicDjweDwYDIZwhPQ+bXQ4HNjtdhzRDoR4gVJHKWqsimARkO+SIQsQgZ1ASINzdi9/B63HteaRXo/w78p/hxPzKSraBg1xkAiXGCjv9Cyprn8jlIUw7VqElP8zlv65nHnmmQiCwPvPPMDDp51L8ZolnN7aTMWWtWzfvp3U1FQSExPJy8vD7/fj9/sjiQgBRowYwZw5c6iuriY9PZ1z/3kLBa2yOOUf/+WRgXEEKneSnZ3NunXrKCoqorGxkebmZioqKrj11luZMmUKubm5vPnmm5E6J0+eHEk8uHnzZhoaGiLRyq+//jo///wzmqaRn59Ply5dANi1a9cxXXNHw+mnn84PP/zA/PnzEQSBl19+mdatW9Ou3e8/fV/zeKCmBlq3RtjtIawFAmGRGUBV0X7+mbds3VhQ5gdgR5PM2x08KM88A9u2he8JqxV69ECIjkZzOtEkiUbJjCnkQ/F4+GbYFVw3thsYDAhWK/Kdd6LttoMQsvYmY1NeeomnXamsik5FmL2di88fwD+6h8XeSXYDJYYutPkygOQKJwJVv/jiAKHZr4SfrzajyOA0I2+PTDzoDI6tW7dGlvfYVKxatSoyENi6dWteeuklTCYTPXv2ZO3uwMpu3bpF7vPLLruM0tJSqqurmTRpEkajkYyMjIhoXFNTwxVXXEFBQQGCILB8+XK++OILoqKiiIqK4qWXXopE3k+fPp3GxkYuvvhiMncPPO6JcN61axfPPvssmqaxaNEiEhIS6Nev3zGf74KCAn744QdatWrF3/72t73Pq6OkU/cYTGYRj1tG0yAh6fA2uRvWONlR0EzuwETaZjkQRYGzLjr0b9S+wnN9bYC3X9yGKAnY7AZ694+nR248HTpH8/aUbWxa52Tr5ubwudUERAMYBAiFNIwGAaNJom2WndTWNjp0Dic9bN3GDkBishlBhHYdojhtVCrpGfZj6oe/An84oVmTZdSPP0Z9/3208nKIiYHOnf/00690dHR0dHR0dHR0joSqqgdNPlZWVhaJftLRORQDBgxg2rRpFBcXU1NTw8svv4woii1EA1XTWFjmR9XgtNaWA96z9v2clpbG22+/3SL67lAYRAGrQcArh4WYaNMfOFl7MBgRmZ0GG9+ViTgK3FyQbcckHdt7p6ZpXHjhheTl5RFQNN76aQ1tL/0PZlsGCcEdlNY3M/Wzr6lY+DVa6Rb2JOVTVRXR48TgLQ+Lt5p6QL0Afr8/8l1E5FUVCAXAaCFV8DB/xpeR8/Pggw9SX19PKBRCVVUCgQC1tbV4vD48JRWoG9cjpHdCC/jA3YRicWAfdCHGLT9RV1ODz+ejrq4Ov98fSTDm9XoJBoP4fL5IW/Yk21NVFafTSb2/HjlKRpusoQW1sNJgIiwyB0BSwRIEfyFoL4qYgjYSha601nK4csWVzBZmY15npsnUROPNjYiijM2qonrnE50nMTgFJtz+OoMHD44kh8yMNvL+pX3g0j489dRTVFRUkJSURGlpKRkZGWRlZXHVVVfh8/m46KKLmDBhApqmMXfuXDp06EBmZibjx4/nmmsuRVY1JAFq651c9PK3NGDFUCdz0bBhbN26lSVLlmAwGLDZbCxatIjc3JZ+s926dYtEsLZu3bpF5P8eX15BECKCtyRJjBo16piutaMhJiaGu+++m5KSEgwGAz6fj0WLFv0qoVldtAhqahBGjEDYnczuSGjV1chXX41WWorQpQvSk0+ifvQRaBpCYiJaXV24YE5OxO8coDGgoOXnh3NyKUo4hNRkAr8foqMRunYFl4sKt4QU8PHp5f8hNbszS5uN5DmDDEgV6fnQQ6g//IDgcCCceebeRrndbHK0Ci8rChtqA6xLMGGWBLokmMga049Ql85o69dDVBTsc6yaoqC+8AITV6zhx8SuzD33ev7VIzqcfFKWD5h1P3z4cD755BNgr03GunXrIvd1WVkZ1dXVxMbG0rZtW2655RYEQWDIkCGROhITE3n22WcP2r9bNjaydHEejQ1hUVzTNOrq6qivr488C2w2G507d+bVV1+NJBbOy8vjgw8+aFFXXV1dpF3QcibL0eL1ennwwQcj/uYGg4GLLrromOpIz7Bz58PdeOi2dYgiPP/QZh59sc9BvZo3r29g0sObAZj1TTlPv973iNHP51/eFo9bpq7GT1NDkMqy8PMs4Ff4+20dMRpFFs+rYtHcKvw+BWd9gOamEKoCggDRsUZi4yTsUUZiYo1cd0sOvfsnkNUhCllWGXtBOk2NAVYsrmPIyBQuvDKTxCQLc74v580XCoiJNTHx6Z5kdfjr/y33hxGatUAAbf581G+/RV28OPxAadcO4QSa4uvo6OxGkmDs2L3LOjo6Ojo6On8IRo0axYsvvhiJlBMEAbfbzUMPPcTYPb/dOjqHIDExkddee4077rgDq9VKU1MTU6ZMifgsA7y+sZkfdyex2lAXYMKECTidThoaGrjqqqsOiELb4/V7JAyiwH/7x/HVdjeJVokrO/1xZ6MKZjPiiBGo8+bxRPaZ7EzrjVDgZs3qVZi2/ERaWhrXX389FouFuXPn8s0335Cens5tt92G3d4yOs3j8VBSUkJjYyMhkwMqynBt3YZJTSZ560w8QZlQRQO+2jL2iMwAoiji8/lQ5NDe+dgGM/Q7H2zRsPRT8LsPfgAmO8SmYktIJS2rM5999hler5fhw4ezdOnScGStPQ78HjQ5EBacgyEUREBAC/gRG8oRY1Og15nYUlOpLcpDVavQNI1AIIAgCHTs2BFJkvB4PJjNZhobG9E0DVEUyc7OxmKxsGPHDkJyCDVZDQvLGrDfqRdCoEng6whiTVgUkyWBqgYLd7jf5spzOvHq8lcxDDewotUKpspTiU2LxVEYRJ2zgWRDPFrQTvfu3Zk4cSJFRUUMHjyYe++9NzIwYjabCYVCJCQkkJSUxMMPP8yPP/7I9u3bAZg2bRqXXXYZiqJQWVkZsQKpqqoKd/1uD98v8uopje1Ec3MzavaZzPjpHf597XhCoRB+vx+z2XyAFQeEn91xcXFUVVUxdOjQFvfRBRdcwHPPPYeiKEycOJFevXoRFRVFUlLS0V2wx0hqaiqxsbF4PB6AXycyf/styttvAyDMnYv0+utHZTOjTpuGtm5d2O5i4ULkO+5A2HOdt22LdNZZEB+PcPrpXN4QYkdjA15Z47qu0QimHgitWqGVlIAgIPTsiXj++WiyjHj++XxaIrN5wVq2xmXQtVcWfZPNPLOmEYAfi71M6W8j3WYLi8X7nAfx2msZ+MFiFka1gzZtaAioPPhLAwDjbfVcMPdDhA4dEBISIBRCvPHGyLbasmWoCxcSDVxctoLLYkcipqSifPYZ6mefISQkID36KMLuWR+XXnopubm5qKoauV569+7N999/j6ZppKenY7PZuO2226ipqcFut/P8888fVVLI+T9W8v6r2wmFVEzBczEYwn8vDBkyhDZt2hxQfl+rmIaGBhRFiVyfLpeLbdu2RWZNtGvXjiFDhpC3oYH3Xt2O0Shywx0dyWx/+N8At9uN1+vF5/MhCELEwuVYaagPYrGG2+Z2yWzZ2MjQkakHlCsq3PtsDPgVKsu8RxSabTYD/7gtfC6WLqjmzRcK0DToMzABo7HlNW22iFhtEk0NIQQBECAUUvF5Ffw+BZ9HJrtTNMmpFl58Io/vp5USFW3EaBLZuc3Fgh8rmftdBfc+3p2Hb1+Hqznsl/3kfRt4e9qp+zftL8dJF5q17dtRf/oJdfZstB07wOeDVq0QjpBkQkdH51dgscAPP5zsVujo6Ojo6Ojsx6RJkxg9ejRdunTB7/dz+eWXs337dhITE/nss89OdvN0/gRYrVZSUlIoKysDOMCGZVNdsMVyYp9knnjiiaOqu66ujh+2VBKXmsEZWdFYDS1fzrslmuiWeGKTm/1WSLfdhnjeeZSvFREMJmS/lxlvTSYnCjZu3EhMTAzjxo3j5ZdfRtM0SktL+frrr7nqqqsidQQVjYBkxWqz7Y429kHAQ3DBu4RCQeqbanBERdNcuQtNlVvsf18LCkEQwhGFw6+HjO4Q8kP/C2FRy8jDCCEvaCo+TaL03Xt5UXXRvn17Pv74YxISEjAmtcFgiEEYMh5h7msYXDV43W5EsxU1owfU7EB1N6B2GIykqphMJox9zyawY21kFykpKdxxxx106tqJe1+4l7wleQgeE6JowGGzcvXVV1NcXExdXR0eqwfaA+cC++bf0oAaENeAkAmqBZQc0EQNg2yhIRjAHVT4KvFrCgYU0GFRB1b9tIpO6zvhzHHS15hLibEECAv6M2bMoKioCIBly5aRl5dHt27dIu3dYxfy3//+N+J1v4fExESMRiMmk4nTTjuNhQsXYjAYGDlyZIuutcYn43CU0djYiCgZiElKpaGhgffff58FCxaQmprKKaecctDTsr/dwM6dO3nllVcAeOSRR8jIyAhbmPzGREVF8fTTT7No0SIyMzMZOnTocde1x4ICQKuoALc7nJzvSJjNewdQRDEckbxbRBVUFfHCCyNFO8eb+GRMMoq2R/C3YXj7bdSZM9Gqq8FuR501CzSN+mWr+eaChwh2HwyELWzcITW8r1AI2WigbPJrpOaF/Y3FqiqkSy8NL/fsyV2TenB6dQCrQeTxVQ27D0xj2dw1nL9lS7jciBFIt93W8niMxgM+a2436qefhquoq0OdNg3p9tsjRTp06NBik379+jFp0iTKysro27cvBQUFEUHW4/GwZs0aWrdufcSu3bTWubsJRnKyhvDMXcNJSYmjS5cuiAcZBLj44ovJz8+noU5lzKiLUFUhor8/+uijEZuPUaNGcfPNNyOKIu9MWUFdTQCAj6bu4L/P9jpsm5KTk0lISGDWrFkYjUbGjx9/xOM4GO2yHZjMIsGAitEkkpVzcIE7d1ACM6eX4nbJpLexkd3pwGvyx2/L+ObTYhKTLdz2QFeSUiyU7HKzdEENbdrZeeylPjQ3hejSIzayzaDTksnb0EjB5iZ69k3A1VxNwKcgyxqxcSbczTJWu4HsTtHsKGjm7Ze28d2XxSgKGE0iFpuEtHvQqqkxyPJFtSjK3gFGtyt0XP3yZ+OkCs3KpEnIP/6I1tQUvnGTkhDs///8S3R0dHR0dHR0dHQgPOV6w4YNfPHFF2zYsAG32811113HFVdcgdVqPdnN0/mTcOONN/Lqq6/i9/u5/vrrW6w7pZWFL7d7IssABQ1Bar0qfVNMWAwHj1YsLCxk/POfsjOxFzZbNRec0oNJpyX/tgfyGyNkZnKB38Xn2zyISoBEo0rY6yEcobdnOrkGNHr8LF64kMFVVbQzmag8fQy37jCxtmAnVZkj0fLyQAmFLS3cDWgNFTQFfTQ3N7eYln4oJJMJJSkrHMnsaQTD3gECg8EQScAHhK0zqnfAlw8gpqXh3q0aNTY2EgwG8UoO4mNj8Gz4gZASRLA4iB56JRSvx12+A8FZgowGhb+gJmRQWVnJZYO78MX3dgKBAA6Hg+HDhzN+/Hgm+yZTlFCE2yojpLbDIBrRDBKvvPEGTb565NYyDAbOAPpGui9MHTATlLki4oUqWsdwZDOAWjacYNFYgqqR9T47Dd3nsLFxI2bVTHxdPLY6G+ffej7vrHkHt9tNr169yMnJYebMmeFzt48NBYSTr+0R9jYsXoy8dCmXOZ0Yu3ShMT2dCy64IBL9fOedd3LBBRcQHR1NYmJii/NwXnYUa/p1Y54oYCpcRpJRYeTIkcTHx3PhPuLovmiadlCrzylTprBjxw4A3n77baZMmXLE6+BEkZmZGfHi/VV07w4//ghWK2K/fghHIzID4hVXoM6Zg1ZQELbO+Pe/UadORQsGwWhEvu02hBEjEEePRjCZEAQBwz5dKCQnI119NQDKe+9Frn1jZRlnffsmZRk5rO41DLZWMKhbBtO3bqDGFaQ9XrpuWAy7n2Pabv/5CPX19HlnKlogwCl9LmCOGI6W7doczoGgaRqa04laWor61FNo1dVIV16JcN55iBdcgLZiBUKPHoi5uWjBIILNhrbbLoJ9rsdD0aFDh8h1mpmZidVqxefzIYriQSPlD0bPvvGsWR6OUu7aM4ERI3oetnynTp24+7YpvPjEFtYuEniqZh2K7Tu2b9/G1q1bIz7+lZWVEaFa3G0hpCgKonh0dkKyLNO7d28MBgOrV69uMSi3B6fTyYcffgjAlVdeiSiKvPLKKzQ1NXHVVVfRs2dPHnq+F/mbmujYNSbie7w/aek2nn69L1UVPtq0c2CxSDQ3BbHZw8n9vB6Zz97ZiaZBaZGHb78o4ZKr2/HkfRvxesKDfDfc0ZFThqW0qNdgELnxjk4AfPLWDjauacBvkjEaRXK6xLBjm4v0DBtJqRYcUUaqK33ICqiKBkEVg1HEZBcREIhPMDP0jFSKd7pZOKcKi1Xijv92O6q+/LNzcoXmjz5Ci4mB9u2PKcuvjo6Ojo6Ojo6Ozl+FPn36MG/ePOLi4nj00Ue56667uOKKK7jiGJOT6ejsITU1lccee+yg68Z3/j/2zjs+ijL/4++Z2ZrdTe+NEEoIHUJXEVQUC1bsvd7Ze8FeTvQsiAVPPZWzN+wgiKKI9CI9QAik976b7Tvz/P6YEAhN9PS83znv14sXk90pzzw7M8l+ns/z+boYnGRFE4JBSVa+3dnG31c1Y7VZ6RNv5cnD4/crmi1btowmawKg53GurXIT0ZI6Iwf+v3J+HxfHZNmxmpKYywV8+OGHpKWlccYZZ5CQkMDZl/2Ve5e30RCEvlu+pvzzp5B75TN7UxuLMsfQ1FCLSOsHsWnQUg3uOv1fB4ciMgshQFWRFr6KiIQhEoS23fuw2WyEQiHC4XCX/VksFoQQJCcnU1hYSGtrq14QMrMfwZ55sGEeUmstkgzxpgi5t77I5rcex73wHTRVRWz8BkvdNmLi4pixdhmunVewfft2hBCdIlGRWkSwLogU7UStqEOYrIRcibRnj0Zu34G4fq0uNMcCChBEV+aDwBxgLqBqaN8Ap+gCsYKCJZRIxJ+EFkgAIYj0/4qko5KQV8qYynWn8THHHMOoUaNobm4mMzMTSZJoampiyZIlJCcnd3GFp6WldcZkpFRWIsxmzMC5RUWYHnusi94gSRK5exSJ25NEu8I/jk4mMi6RstJsYmL+so8YvYtIJMLjjz/OypUrGTRoEPfdd1+XGQS7igMCbG0KctHX9XSPNnHnsFiizP/9+oe2dq0uDssyUlYW0j33HPK2kt2O6d13oblZz0OPRFDeeAPtn/9E+/xzXQD+4AO0iRMxTZt2wOzniCZYkj6A7sFPSDFrRFWUcqzbS+22lQxZt5AjTa0oCJ4PRWhWbCTJEUwxLkR9vS6Op6SgzZ+PdMQRoGmojzyCVlyMJMv8pa6OPnc/g9UkcZh9GNpr65B27kQsXYr6zTeI6GgkiwV15kxMEyYg5eejffEFYu5ciIlBOf985PvvR3z8MSQnI5977i/q38TERJ5++mlWr17NYK+XrLffRs3JQb7kkn0yn8WOHWjLlyPl5zPu2KGkZUTR3BSkYJT+TN62bRuyLLNz505mzZpFeno6t956K9EdAwOrlzWD0J/VixfuQI7fhNkSJBKJ0N7ejsvlYsKECZ3Hu+qm3txw5fvU1VVhTmynre3BLrnj+6N79+60tbXh9/spKiri0Ucf5YorriAlJYWtW7fy448/smjRIlpbWwGoq6sjPj6eVatWoaoqjzzyCB999BFZOU6ycn4+eik6xkJ0jH6/vTRtK0u/ryc23sKUqQOJS7BiMsuEQ/o9aLMrNDcGO0VmgMoy7wH3rWmCHxfUkZhkxe9TOO38bhx9Qjpx8RaCQY3UdDve9giuaDN2m4Lfr2KxyhSMTOCme/tSWeGj38BY+vSPZcBLw2lpDhETa8Z0gIHc/zX+2OiMnBzDwWxg8Efg9UJyhwOlvh6M+9DAwMDAwOAPY8uWLXi9XuLi4njooYf461//SlRU1B/dLIP/YQYk6l/OGxsbmfLSx5SaUnA4ohD9+tMW0oi17lvDIy8vj5j5H1Atx4MQZKiNmOSe/+mm/y6kOPSvxeeeey7nnnsupaWlvPvuu8THx1OSMJCwXUIKtaEIOz7MFJdV4DYX4et2HMLmA60V/G6QTbrbmJ8Xl/dG1QTUFuuu6D3YlZFttVqpqakhGAx2ef+www7jwgsv5JlnnqG5uRlZltEaywj9NA9qtyJJMsLuJFl4ePTINL7ZmcsC3wh27txJbW0tqTa44IwTsVqtTJ06leXLl5OSkkLfvn0BONp8NCvGr6BpVSmSpkFcOkJWUCQJddQlKEnrMVtkPXfZH0HaLCE1SqSGU7EMs2BKNNG+tJ2EMxIIWUM4JSdOyUlF21jKA0kIQJIFakSl+tlqUnakkNMtp1Po3uVc3uW0HDp0KO+++y47d+5k7dq1PP/886SlpXH33Xfz0UcfYbVamVxXB0uXEpBNvNz9aGqXtHBaD0eng/9QMCkyPXr0OOg6a9asYcWKFQCsW7eOH3/8kaOPPhqA5oBK1mnXUfzVFyS0FFMx5DxaghotDSG+LPFxdu/fN8O8Lajx3rZ2BHBunmO/9/TPIRYuhEgEyWaDykoktxviDz0aRzKZ0BYtQu0oPieNGwdNTYiGBv37qCQhamsRy5YhHaAGwT82uJkfzCT+zPs5c+G7HNu0hKT2dpJMJgZ4a5F69EC43Vi2bkWOiuPr7kPo4XLQR61BtLaiffGFPnv+k0+QvF60ZctAVRH5+cheLxO6dfyuzZiAnJ1F2dU34/ZrpLe0Ex0MQkaGXozQZEL9+GNEVRVIEurHH+tCc79+0K/fL+7bXWRlZZFpsxG58kqEqiLWr0dKSkI65ZTOdURDA5G77tLjRyQJ/vY38gYO7Hz/zTff5KOPPiIcDtPY2EhaWhq1tbV89NFHXH755QD07hvN4gX64FVcgoJX0SOUunXrxu23306vXr1IS0vr3GdIq8QcP4fMeGhqgW+//faAjv5d3HXXXXzxxRe89dZbSJLE8uXL8Xq93HLLLdxzzz2EQiE2bNjQGSHT1NSE0+mktbWV4uJiAL744gtO6Th3r9eLLMs/O5urttrP0u/1CJLW5hDfzqnmwqt6cv1d+Xz5UQWJyTZOP68bFqtM/sBYtmxoxeE0MWbcgWfkqKqgqsJHdZUPBCz+rp6b793tRq6v9bOjyMMNU/LpOyiG7+fW4ooxc8k1vRh5RDIj99iXLEs/mx/9v8YfKjRLe+WFGRgY/AfZNcXHwMDAwMDA4A9l8ODBXHrppRx++OEIIXjqqadwOvcvQtx///3/4dYZ/C+zZMkS2reuwJ09DrfbTTenTLRFFxv2jgMYMWIEJ/Wci+/7t3EmptFW8iFtJ7/xsy63g7GpMUStL8LoNBuOn3F41tfXs3XrVvr06UNy8u8X2RGJRJgyZQorV67E4/GgxmUin34vkUiEuWn5HCHPJsbrpt3Xiq+tTs+fLfwBAj6QZJD45TqzJIOsgMUOIbqIzVarlczMTBwOB67oGDa2qNBQhhTUi2GtXr2aDRs20NDQQDgcRtM0NJ8bvJvA6kAgoboSqSKGRr+GM8rGtm3b0DSNq6++mhtvvLEzYsFutzN+/PguTTvTeiYFlxfwdPnTfPPlciq8GkTF0Pfki/GmyFi65eMRbuxNdjyfeGif3Y7WX8N/pp/U1FTSh6bz0oUvkaFkUKvVsiGygTwlj+kuO2/HbCSghUjN3cjZOy5h7ea1yJJMeXk533//PfHx8Tz99NOoqsqVV17JpEmTKCoqQlVVAILBICUlJaSlpZGYmMjVV18NgGhrQ5MkPg4msbDnWKSWMI8tb+DlI6PJSOh6vQohKCsrIy4u7hdfy3s/p/csmnnv0hYq2qNRjriA4Vl22ir8nZeF+T8wC+CZta2sqdfFxMr2CI+O+eXZ6VLv3vDdd/pycvIBs5m1b79F+/FHpH79UM46q8t76tKlCL8fTCbEa68hZWbqRieA7GzduXuQXOKiVv1eaGryEC7eCeGO4plWK+wqphgM4u7dlzsGXUCbxYFsNvOwkOm3bhFEIpCcjFi9Wm+/3w+trZCYiHz33V2OtSoURdAPiiZoiEhYwip2QJ4yRRfbCwuhrEzvD7sdbckStPffR0pORr7xxkOOFdkHnw86rmkA4XZ3eVtUVuoiM+jnvmMHDBxIOBzGbDbz/fffd667S2jem3HHphEdY6Guxs/ww4bxwYe1FBUVcfTRR+83wzsuLk4ftOpw5SckJOD3+/H7/cQfYLDB4XBw7rnn8vnnn7Nt2zbsdjvt7e3U1tYSCunXYmZmJqFQCJPJxIUXXkj37t35+OOPURSF7Oxs3n33XU455RS++uorXnrpJUwmE7fddhtjxozZ53jF29ysXdlEdo4Dq00hGND7MClFH1AaPDyBwcMTumxzx8P9qa7wEZdgxenqmru9rbCN5T/UU1cbYOvGVspL2/G2h3G6LMgS+HwRoqJM1NX4uf+mn/D7VBxOE488O5S/3NwHVRXExBoaJ/zRjmYDAwMDAwMDAwODPzn/+te/eOCBB5g9ezaSJDF37lxMpn3/TJckyRCaDX5TsrKy8K77FufOrWiOOFLbktDE0Ty6soVVdUEGJ1m4d0Qclo68zszMTHJdqyFYp7v69hBHfikLK/08/VMbAJ/v9DF9bEJnEaW9qamp4eabb8br9eJwOHjuued+ldgshGDp0qW0t7czbtw4rNbdLrN169bxySefEBsby8aNG/VicLJMsKqIqB/fwpzcG5PkY/r5d1L36YvUVGyCL/8OFidsXwZoILQDH/xgRCeBYgFHNDSUdQrNsiyT2S2Hy6e/z5efzGLV9jqkUX0RC19Hrt+BRfUR1qCi9yTE6Cyiq9YyLFyqt7/NjSYAk4LsSsQx/CRUIViwYEFnLmx1dTU5OTmIUAjx009IiYlIPXvy1VdfUVxczLhx4xg4cCC5Si5PTHmCmakzKW104xl6JoozjqSdC/np7mz8sX6KTy1GXaNiijbhSHGQ0jOF5ORkJCRMkv48S5VTSbXombgPj9LoXdKDQnkl47JGMKR2MDdJN3VGgyQmJvLBBx90xmN88MEHTJo0iaFDh+Iym3GXlZGYkkK//bhJpZgYlLvuIrTRjVTio6amhoqKCq567wPuvumazmJ+Qggef/xxli5dis1m48EHH9xnf9qCBXr0Qo8eyJdd1iXSoF+/flx11VWsWLGCQYMGMWLECECPe6ho3z1FvzWk8ZcB0cwr89E92sRJ3X/7GStzSnxsaQ4xNsPGiFQbtd7d92adb//3aUQTB42+kU88EVwuRG0t8lFH7RPnACB27kR97jkQQr+G0tORDz9cf0/TYOdO2LhRF0gVBTIykAYMQMrPR8rNRerfH3kPd+7eHJ1l57VNbkatns+IkjW6cBwVhXzqqch33gmFhXxXE6Z+1hdUORJxKKBJsMWRQr+4uN0FCAcNQixdqm8fHQ3JyUh7iZfu2ES+OOcWxs9/j9imOoJpmdgByevdfT5mM8gywmQicuaZYDJBr16QmIjSMdDxS5G6dUOeNAltzhyknBzkSZO6vt+nD1J2NqK8HCk6GmnUKGbMmMG8efNIT08nMzOTxsZGzGYzEydORNM00tPTOWsv0X/oyN2i67XXXnvQNiUlJZGQkMCyZcsYNGgQNpuN0aNH4/V6Oe+883jooYcAfWBu6tSp/PTTTxQUFHDjjTfS2traWeTw4osvpnfv3vTp04etW7eSm5vLo48+SlpaGuaOAovnnnsuixYtAuh8rr/77rsIIQiHw3z44Yf7CM211X6mTtlAJKwhSXDeFbmUFLeTnhnFsZMyuqw797NKPn+/nMQUGzfd23e/sRxNjUGeuG8jlWVetmxsQ1M1VFUfR3Q4BT37RBMVpV//Wze14e+4p7ztEYq2uBnz/7xewW+NITQbGBgYGBgYGBgY/IHk5eXx/vvvA7qwtGDBgt/VsWlgsIuhQ4cyYcIEVq1aRZzNTL9eI1lZG2RlnR7PsLYhxJLqAOOz9KnLkydPZseOHVRVVXHGGWcc0Nl2KKxrCHUul7ojtAQ1Eu369P6ioiIqKioYPnw40dHRFBYW4u0Qe7xeL4WFhfvcIw0+FZdFOmAxQ9DFi1332uLFiztzrAOBAI8++iiBQIDS0lLq6+vxeDyALkZ6l3yGoig0uVwoGVlUVXa4ausr+DUxGXsiSRIipScMPQlaauCHmZ3vaZpGnT2DR75YRe/BJ6PZyzE11yAGT0RZ+yVpUhttmQWIjL5IkoQv7yiOzlfx+1+ipLQUTxjMPYYQ/5cXmdQnhkzPTlatWoXb7SYqKorNmzfT0txM2/2PYdm6mUS7iY1HH8U/FiygpaWFd955h9dee43+/fvjcDi45tprafRrxFllzIrEvd+t0/vIJPAkCNIfzMNcFeCCoWeixqqUqWWcYDmBFDlln/N2WWSuzssBcvQXcuDOO+9k8eLF9O3blzFjxrBo0SJ27twJ0OnSTImL41mrlRKHg55C4FqxAo49lk8//bRTFNuVbz+5l4OtLWHWryons2Y1csDNJ5980ik0Nzc3s2Tpss5r4JtvvukiNIuaGtRnn9VF1MJCpLQ0pL1EwEmTJjFpr9dMssSEbDvflPsxyTAh287oNBsn7iEwh0IqK35swOE0dxEAfw1LqgO8tFF3wS6uDjBjfCJn93by7Lo2BHBO764xiRFN8NiqVlbWBcmPN/PwqLgD3jfyftyueyLa2nQReRcd+bsAlJfrwq7NBnV1YDYjNm9G6tMHRo1CSkqC5GS0tWv1QY6sLLSlSxErVyINHEjTqCMp90QYnmLlstqVJEphPfIxIwPl6aeRXC7q03J49tsGeh0pE1Kd+NIyyHLIDOvuxfTXk5FiYhDNzYj6etStW3VHdEICbN1K5Ior8F52GZ8UFWG32znplNNoKl/Hj85sEuRNSK0+Ylwyoq4O4fHoTuxwx2yD0lLQNAgGobpaP89fQCgU6pLnrVx1FfKVV+p9KgR7yv+S3Y7y9NNQUgIZGVS2tTFv3jwAqqurGT58OCNHjkSWZY499li2b9/Ot99+y8KFCznppJP2m7n/cyxdupSGhgZ69uyJ1+vljjvuoLq6mmAwyHPPPcd1111HUlISS5cuZdWqVQCsXLmSb775BrPZzNChQwE6XdH9+/cnPj6eCy64gKysrC7Huuaaa4iJicHv93P22WcDkJKSQltbW+fy3lRX+IiEtY7+0uMpdhXx25N2T5j3X9eLApbvbOfLDys45qQ0br9qFS1NIa68MY/Djkrmsbs3sG6VXmBR00SnwVzTQGiCy67r1bnP3n2jOx3U9iiFXn1+pZP9fxhDaDYwMDAwMDAwMDD4L2HP4lEGBv8Jnn32WT7++GNAF5J3+rsKTi7L7p9jYmKYOnXqb3Lc4SlWvuuIE+gZYyLeph9n9erVPPzwwwghSEtL4/nnn6dPnz7YbDYCgQB2u528vLwu+3rmp1a+qwzgNEs8MjqenrG7p0QXFRURCoXo378/mzZt6nx906ZNLFumi4xNTU0sX74ci8WCz+fDHpuALwL+tqbOe1IIgdvtxu3evMd9+mtEZglMFrC5wGzFEW7Dt3MlmhbRheaAp8vabVuW462vJJjRnYRT78QbdBCy9OS88ffx4MkFnPf4v/CadAHTbDJx+qnj2fzj1yQnJyMETJx8Lhefl4PTLDF45CTcXj+hUAi73U5OTg6frK8nf+V6AFoCGqxYQXNzc2dm6pQpU3j//fcx26K4d1kzW5rDpDkU/n5YPBMmTGDDhg1E/N2Qte7URZVj7RnDYc5JjLT34pdy2GGHdYrAANdffz1JSUmEQqFOAYqWFpw+N7E9zMhuENu3syk9nddffx3QM+9zc3MZPXo08TaFaWMT4LMf2F6vFwrcM1ZgdZuZdQVX4A20klUypzNCpBO/v4uIKrwHLh62NzcMjuGk7lFEW+TOAZQ9ef6xLaxf3QzAaed147Rzux3yvvemfg/Hsiqgya8yPsvOiFTdzbt3LM3a+t2DSVuaw/xQFeC4blGItjbUv/8dqquRzzxTdzT/DNKgQchjxqAtXYqUl4d01FG730xIALdb/6ergeDzIdatQ1x2GVpysh4ZkZ6OFB+PfOGF1L/9AWtdWeQuXceXpQqLEvV7ffjwYyiIsvNdSj+S+vXi6I6YEkXS02qa0ruRYbIxoFcKVw1wkebo3dkMsWIF2j//ieRyIZqa9HzojAxoaGDjNdfwaTe97+vKykhu87Kt1zC2tFSQsvkHQnYJ6zvvQHQ0Unq67oaWJF14liRdfHY6kU49FeF2/2x8RnNzM3fffTdVVVUcddRR3HTTTZ1C8KZNm5g6dSrBYJBrr722M+8b0KM78vP1zzMSwWw2E+4QvZOSkjjppJMAaGtr4/777yfQEbWxy+V8IMSOHYht25CGDkVKTUVVVVRV7RIDAxAVFYXX6yUSiSCE4JprruHll1/GsVetp5ycHAYOHMiGDRuw2WwceeSRvPTSSyxYsEDv47o6pk+f3mUbh8PBVVdd1eW1Xc8di8XCufspstinfwxpmVHUVPqIibMw5ACDNZIMikkmFFSRZQmrTWbqlA1sXtcKwNS713POpd1pbgxitSq0toSwWiV8kd33fSCg0nMPMTktI4qHpw+hqNBNn/4xnVEdBrsxhGYDAwMDAwMDAwMDA4M/KU6nk4svvrjz5wEOuKKfi5V1QYYkWRiW8vsUMTos3cbTRyRQ51MZlmJB7hBb1q1b1xmfUFNTQ01NDTk5OUyfPp3CwkL69evXRSxs9Kt8V6mLKu1hwVelPm4YrGftfvTRRzz33HNIksQFF1zA6NGjO8VmSZKYOnUqmqZRVVVFUlKS7tgLR2iubyDia9ejJzr47QaBOkKcwwGITSVYV48kNChesf/Vg35UbyuEAxzW+APFda3IYT/ummaaD+/O+/f9hes/WMH25iDnF2TRLyOBhx9+mNmzZxMfH4/ZLJjzyYdszxzLNp8ZkdwTc3M5VquZm266ifmmROJTskmpK8cd0sg75RSkF14A9IEFIQT19fU0R6WzpVkXtmq8Kj9WBzj5yCPp3bs3N31Xy5oX3ocAdDvuVDg7C1z7P53m5mZCoRCpqakH7CFt40a0jz/GlpzMZZddhmSzEYho/GODmxqfRPk1XhpMW4gOWnmi2634ff4u2/v2qkVz77338tFHH2Gz2brECbxR5EPLk9EarDT0PgzT8V3lESk3F/nkk9HmzdOXD0F43ZPcGPMB39u0rqVzuXB9678lNI/PsvF1mY8qr8qQJAt9E3Sn7IFyz6OtXV+P6RhM0j78ELFxIwDqyy8jHXYYUmzsQY8tyTLKlCnIqoqkdBXUJZcL6Ywz9OJ/9fV6znAwiFA1QIDbjSTLuggdG4v7/VnckXgkzbZoFLuNHnVtkKgXVnxr0AnMyhrBNmsi9Y44jlrQwHPjEkmwK0zd8gmRzz/HajXT/ZG7sTn0mAVPSKMloJFRpxfBw2xG6tUL4uKgRe//tj2ulYr6evraXCBJzBs6kWFl65A8NYiffkJ88w3y+PFo33+PFBeH1L8/2quv6vnSNhuRv/5V74uLL0aePPmA/TV37lyqqqoA+O677zj55JM7i06+/fbbtLfr2euvvvpqF6F5T+Lj45kyZQpz584lOTm5i5Dc0tLSKTKD/gw9EKKoiMidd+oFH10uiq69loeffx6fz8fll1/OxRdfzNq1axk+fDiDBw9m1KhRtLW1YTabWb16Needdx6HHXYYBQUFBINBCgoKKCgoYNCgQZSUlJCUlERsbCyvvvpq5zF3nTvoGettbW0kJSXt47pOTEzkuuuuO2DboxwmHnpmCJVlXtIy7Dic+95rPy6o5V8vFrNuVRMed5jkFBvjJxbwzexqAMJhDYFe+K++JoDZLNF/cByjjkxk2kOb2fXIj46x7NO+tIwo0jKMos0HwhCaDQwMDAwMDAwMDAwMDDo5pYeDU3o4fn7Fn8Ed1PhspxebInFqD0dn1vMuesWZ6RXXVSAYOnQoX375JZqmkZmZSXp6OgAZGRlkZHTN3gRwmiVcZglPWFeF0x27xa5//OMfFBUVIYRg6tSpnHPOOVxwwQX07NmT5/7xMmssvfBbY/A2f87wRJm0tDTWF27D19qmiwy/NnP5YEhAJAyREFQVEv6ZYyiSwKYFGJhko6ctiLe1iEgkwqL165k0aRL9+vUjKyuLQGUlqzdHsb333+jduze33HILjzzyCCtXriSiWCg5IoOYw8+gdeF7YHdx0knHcMwxx+Dd4eWtC+8mv3A5vXulM/qccbw8YABTpkxB0zT69OlDVlYWZr/uHlU7xPd0hy4lWGKTWbfgFdQda9CEoOSDf9L3r8fv91wWLVrEtGnTUFWVc889l/POO2+fdUQwiPbIIwh/R/E8mw3lsst4Z2s7X5X68NiL2N7DwmB7X9qtFha7GjjbfBRjx45l+fLlDBw4ENF9GBfPryfWKnNnQSzp8fH85S9/2edYNkuYgCWIyABLYoASrYSqjmzlDKd+fsqVV6J0RBr8lhSMSmTl4gaAA7oxD5VYq8KM8Ym0hwXRFumAUQlCCNA08uIsXDswmuW1AfonWBiV1uHI3FMolmX93yGyS2R2u91s21HKGpFGRLFwxjmXkFRZiVZYCOXlhIuLUdSgPtwiBJKqQlUVwumkvPdQmp1xiIhKJKJiH1FAXUOEUHklk2dP46nRF7A9QSKEyoIKPx8Xezmnt4O8JfOgQ1yX5s+Dw8ewvSXMvcua8UUEhzkHcVtmJqKyEmngQOQrrkB75RVQVbSjj4YFC1AUhVNOPZXDc3Jo+XINdUETvepKMAe8IATaggWYly1DvuwycDjQPv4YqWNmhdi6Vc9qdjpR3333oEJzXFxc57LJZCJ6Dwf0nsUof64w5bBhw1iwYAFz5sxhxYoVPP7446SkpNCtWzdGjhzJihUriIuL49hjjz3gPsTmzZ2RH8Lj4fuZMzsjit544w0+/vhjJu9xLi+88AJ33303brcbh8PBunXrMJlMyLLM9OnTyc3N7TyvXr12z2g49dRTWb9+PaWlpRQUFNDc3EwwGOSuu+6iubmZYcOGcd999yH/gusNwGZT6Jm3u/+KtrTx2nPbkSS44sbevPXyDuqq/TTWBzGZJNxtYf45vYhLr+3JysUNhAIacfFWImGBxxNGjQgUk8TQkQlkdHNQW+kHCSZMSmNbYRt5fX994ds/G4bQbGDwZ0SW4cgjdy8bGBgYGBgYGBj86dneEmZemY8Mp4lTe0R1uox/LY+uaqGwwwVb7VW5acjPf1EfOnQozzzzDJWVlQwdOrRLjun+sJlk/jYmnq9KfaRFKZzWc7dA7vfrTtdAIEAoFGLz5s0UFRXx5ptvogw5gYYa/e/gmFNvIb3qK1LjnGzZshUZAeLXFzo8KHsKywcQmRVFQQiByWTC4XBwxBFHcMkllzB48GDuuOMONm7cSEtLCy6Xi3Xr1lG8o4SAOYpwwM8bb7/L3x56AICysjJ9f2oY4Wmk78gjWbviMxKiUqiqquL777/nlPHjyYvLxDfuDIYk6X3dr18/Zs6cSV1dHT179sRkMpHpgvtGxLG0JkDf+N1O9yizhEUL4bJIqEKiW5SGXdl/pMgXX3zRWUDys88+26/QTCiE8O/hUHbr2cM1jc1EAhpWUxJCtSKcFpAkusndkGWZ22+/HQBNCM6cU0dIg+aAxhtbPEwZHrfvcYDLh4b4csN6wnIbwR7zqC59mb9ub9Tf6+fi1N9gsOVAXH1bHmPGJRPlUOjTP/bf3p8iS8RY9ftVlJZCOKy7dzvQNm5Ee/RRRDCIcs01WMeZUGO/Ju3NGsKvp6OcfDLyWWdBbS2iqgp58uR9YiDUt9/WBdaMDJQHH0RKTOzyfmNjIzfffDNrXQNwpw6kb79+bGq08dKTT+ptmD2bphtvw1VRojughaaLzYoCUVHkpMTglARVNichuxPVaiMQcCM8HtoCEdJrS1mX2INwWKXRL+EOqboz2W4HjwcURS+aJwRFb87iyMIS1vUdzeKEDC6aOo3Uki1o336LWLQI5aGHkCwWTgZGnXceZrO5UwQ++9pstEWLiMQ4QQ3pOcxVVai3365nQ5vNyMcdR/uChVRtLaWy7xH0k30kR7xI+8kT3pPjjz+e1tZWdu7cyYQJE0hKSup875prrsFms+H3+7nwwgsPup+SkhKWLFnS2e9ff/01F110EZIkcc8999DY2EhMTMxBn5/SkCF6fnYggJSQAD176lna6IL43gMWkydPxm63M2PGjM79t7S0EB0dTeue2dx7MWbMmM5cZo/HwwsvvED37t3ZsWMHQghWrVrFzp076dmz536337y+hR3bPAwZmUBWtwPfkzNf2E5Npe5Q/9eM7ThdutwpoaechEIa8z+vonBDG6kZNvztGrIJthW2dclZHjQsgdse7M+yhfVs3dxGTUWAx+7ewCPTh+y3kKDBvhhCs4HBnxG7HRYu/KNbYWBgYGBgYGBg8F+CL6xx3/JmvB3OYFni3xbayjy7C2SVew69WFZubm6nO+6Q1o8xc92griK2J6SRevYUKjduwbz6c2JVXbAMh8N4vV4GFIygaJtebMpls3DbBXcRRYj3338fUySoKxP/YRRF6XQDKopCQkICqqpyxhln8PHHHzNz5kxOOeUULBYLbrcbVVWJRCI0BgWemlIA3v58HrfceD3x8fGceOKJvP7660gI7h5optau4Y23kRKlf667prH3id9XjEpISCAhoavTtiDFSsFeUSp2k8wzN1/GPQ9VQ8DNQzf+BZNp/zJDdnY227Zt61wWXi9i0yak7GykjjgUyeVCPv98tPfeQ0pMRJ48mQ8//JCFM99ku0eQfep13NH7EaKtP9FT6ckY85gux5DQRddduSdm+cCfo3DUMHLwT/iED4vUnbUbYtnlr/+q1Nd5/Re1hJhf7ifbZWJS9yjweml7YhpSTTWuc89C3jOX+BBRFPnfLgK4P7QvvkD95z8BkE8/HeXSS/XX33mnM2O6YtbzPDMSRn9WhTS3kgY5h6StW5GvvVYvtDd5MtsSc2ivCzI0WY+1EQ0NqO+/DzU1iOJiePVVTHfd1eXYa9asobW1lWBCNMFQCI/HQ51194wF6ZhjMB97LDsXryLkC9Krahu2cEDPaQ4EsJvg/K3fsKjnKIoG5vNliY/olibKLS5m9zuKkSVrWZZbQF1MCgFVMExrIXzRdbBunX6+d96JfMkliDlzGPzFW8Q2+8lbPI8fB4wj9u+fEWn3gMuF1JHJrHREBu23+G6fPkgZGYiWFrBYoGdPXcCvrITcXKS4OB668FFKGtqJyCb61RbxaGQT8plnHvTzkSRp/wMsQGxsLLfccsvBP+A91rVYLIRCoX3OQZKkLgL2AduSk4Pp+ecRO3ci9evHJSYTckwMHo+Hc845Z7/bnHjiiYwYMYLly5dz8803U1xcTGZmZhcH8/4IBAKdorfH42Hjxo1s367npqemph6wsGzhhlaeuG8jQsDsWRU8/o9hxCfsP85J2WPGjKxIXPTXnjz14CbiEy34/SqSBEISlGz3UFfj1wv9CUFjXZC4RCsZWVGceEYWcfFWzrywO2kZUbzyjP680lRBeYnXEJoPEUNoNjAwMDAwMDAwMDAw+JPjCWmdIjPoOby/lOU1AV4v9BBrlbl1SAyn5Dp4d1s7sgQndf/P5ln+c5ObcPfhZMX0wD7mGPLXzqSmpobs7GxOOOEEhCUK2+lTcNgs1L/5DJOnVmKxWEhJSSEYDBKoquLQpXEdSZI686X3fn2X+BoVFaXvf48cVUmScDgc2Gw2ZFkmISGB6upq0tLSsFqtrF+/nrY2XRT/4osvuP/++2ltbaWyspITTjiBb5odbP/mfWSLDTkqmvr6euLj4znttNMYNWoUoBfBU1UV3/Lh/PTTT8THxx8wA/ZArGsI0h4SjEqzYtpDwD1mUA+O+WRml3ULCwuZM2cOmZmZnHXWWSiKwl/+8heSk5Px+/2cdvzxqLfeiqiqAosF09SpnVEEyjnnIJ91lp7fC3zwwQfYTRID4yT6Nv7AjTl/Q3t2AWLzv1APL0a57LIufXnXsFje2uIhxipzWb8DhEUDQ01D6a50p1QtJV1OJzk2leW1Aaq0KpQoN+3iCEQ4ivuWtXQWBzNJEqkfvkVg3mIAMkqeJnvYsJ8tAneoeMPaAbOVDwXt228RoRDU1KC98gryueci2WxIsbGdpStLciS8oh2bV7/CI0SgqQn1739Hstmofv9THjn3b7hjEzk83cadw2LBatVzlisrARCzZyNuuw1pj0GFnj17oigKqfXr8TnTiIqK4tzeu4U58fXXxFSWEO2S0XZsZVV6PpKmIgtBSoufrPffZ7jFSVVmL9Y5Y7D4VWIVFdXbhGax0m534nHEIssyaQ4TsYVrYfFivWgjIObMQbr+erTqapKjFKhthfp6Rn+2ClMoqM/kjY9HxMZCYyNC0zq31Z59FlFZiXzaacgTJiBmzULExECPHtDejpSQgBQfD3s4lt0hjYhZFz3b+wxAGT/+F31WoqQE9Y03kOx25Cuv1Pd/iMTHx3Pbbbcxb948Bg0axHHHHdf53s6dO5k/fz4ZGRmcdNJJB4xSAZBSU5E68tIdwNVXX/2zx05KSsLtdpOfn4+maciyzOLFi9E0jaFDh3bJ0N/FVVddxfPPP4/FYuHiiy/m5ZdfJicnB5/PR3Z29gGF5p1Fns56nAG/SnWFj4pSL2tWFrN09duYLWFuuOEG8vPzueLG3vzrxWIkCS69thevTC8iEtZQVUhOteNuC9FYF0JWIBzSMJllPS4/rJHby0mvvjFceu1uwXzA0DgSkqw0NQRJTLYyYOj+Z0YY7IshNBsYGBgYGBgYGBj8gexviuqBaG5u/p1bY/BnJcVhYlymjYWVAaItMsfn2DvfK3OHeXdbO06zzCV9Xbgs+wphQgie/qmNgCqo8ar8a0s7dw6LZVymDbMskWhX9tnm98Qd0pAkiYSEBMwyPPXUUzz00EO89tprhMNhLBYLvb94jPwhQ/iqbBsejwefz0dmZiZ9+vShvLz8Fx/TbrcTCoWIRLpK1DabjeTkZOLi4khKSqJfv36sX7+e1tY2/CgUHHE0hT9+TUtLCxaLBZfLRVpaGtnZ2dxwww0sXLiQoqIiAFwuF0OHDuXTTz8lEokQFRVF/5U7uLNoHarXzeEFA7tMQd9T9FEUhQcffJC6ujri4uKwWvd1BopIBO311xElJcjHH488diwAnxR7mVnoAWBkqpV7RxxYdPF6vTzwwAOdYrrVauX000/HarV2OiXF1q1EdhUGC4XQVq9G6RCagU6Redc57IoBSU9LQ3z/PVrH7Ezx6adII0Yg9+/fuf7QZCtDkw9exLItqFHtNfGY62na5AaS5CS0AhOTCp/FLpoJZW3ipcBmzo7c1CkyA1R7IzTWB9jVw/XeCNn7GVw4GGvWrGHJkiX069evU+wPRDTuXdbCtpYw+fFmHhkVj9X0y131Uu/eeD/7DMXvxxYfj/bSSyg33YR89dVgs/FN3AZmTKygTqvjsyMDDJ4vkVgegtEjkSoqAGh1B4hvrsUdm8iymoAebxEdjTxqFFpLix63EBMDPh/sIbD36NGDi66/m5ULf+CBE7oxfGg2MR2FB4XPh1ZUhHC7obEBTCb8ZiuOoA/NYqVGWMgKtBIfaicr3IYnJIi3ybQlpjGwpYb8bVv5qmACsXFOAqrg6oEucnzxqB2OXiQJ0fH7UZ44EbFoEcnOekS1D9TI7hkKoRCSw4F0xBGoV16JqKlBVFZCaytScjJqZSVSQQGiqAjJbIasLAiHUa64Amn0aCTH7lkel/WJ4pn1HhRZ4tK+Bx7Q2BMhROfve/Wxx/TjA0QiKPfcc8if85YtW5g2bRqBQICYmJjOffp8Pu65557OooIAkyZN6rJtVVUVra2t5OfnHzAXubCwkJqaGkaNGoXD0XVmS0tLC19//TVr1qwhNTWV7OxsZsyYgSRJOJ1OZsyYsY9wPHbsWI444ojOdg4bNozS0lKAgw54DR2VwOxZFfi8EZwxEb5f8BPLF8hs2bKFsJpM9oCVvPDCC8yYMYOcHi4efHpI57YNtX7CYYEQglBQJT7BisccxtceQVEkIhENoYHZCh53hOi9infGxFp49PkCKsu9ZGY7iHIY8umhYvSUgcGfEa8XcnL05dJScPx++WMGBgYGBgYGB2f69Omdy01NTfztb3/juOOOY/To0QAsW7aMr7/+mvvuu+8PaqHBn4Vbh8Zycb6Kyyx3EbkeXtFKvV93OIc1wS1DYw95n2l/0Jfzc/OcFLe24o1oXNk/ms8++4wff/yRcDiMz+fDZDIhhKB79+6dgmhMTAyaEOxo9u/jTDaZTPsIyAAoFlBDWK1WrFYriqLg8Xj2Wa1Xr16EQiEqKiqoq6vj1ltvZU27nXXheNq69+OiC2/hnEyVyZMnU1hYiM1mY/To0fTr14+cjr/bW1paOOecc5AkCYvF0jkV/fwRPZj4+Ru0NDfRPSsDRTmwqC9JEqkdDsb9Ib78Eu3LLwFQCwuR8vORkpJYVRfsXGf1Hsv7w+PxdHFs19fX77tSZiZSXJweTSBJSP36HXB/999/P7NmzcLhcHD22WfrLtauJ3XQ9uxNhSfCHYubaA8LcqJNPHl4GhZJBhPEdl+KTehtb9KayHQqjEmzsrQmSIxF5rhuUXw86XTKykuJa66j8cTTGf4zhdv2pLKykkceeQRVVfnmm2+Ijo5m+PDhzC7xsakphFmW2NIcZkVdgLEZ9p/f4V58lpJCiseDRdNId7lIra4GQIqJQbnpJuZ7bwG1ge5qFvbKjRyuDYdMkPv1Q2tqQmzahBybSVW8XnizX7SE+vjjaGVllJpjkGPTiIuJInbixH1c3D9tr8f692c5ubWB9tUb4M3nISkWEYmgTpmCVlwMmzdDKIQcCOA327CGg6iygivow+0PE7ZYWTryBN2RDFhkmY29h7EtfziSBDFtPhIUeHNLO9/Zcrij/5H0374al1XBfPnl+rlmZ6O8+iq43URefBHxzDOgaSDLSFdfjemRR9DeegtRX4+oq4OyMjCbERUVSHFxIATy0Uej7tgBoOdV9++P+OEH6N8fKT8fbd48hr/0Eu/a7Sj33ov8M9nMoq4O9YEHEHV1yGeeiXLeeXqu9K739xCGN2/ezGOPPUYwGOTGa67hsCOOALcbsXEjUm4uUlYWc+fO7bzHvv/+ey6//HJiYmJoa2vrIjLvisfZxZIlS3jiiSfQNI0xY8Zwww03sGbNGtLS0jrjLxYtWsSTHbnaOTk5TJ8+vcsz5dNPP6WlpYW8vDx8Ph/jx4/n22+/BaC9vZ2SkpL9OpT3HFC/+OKL6du3L+FwuHPWxf5Iz4zi8X8MY8H81fzrremsmdmdsLcHAOGgDTVsPeDz7pRzuvH+6ztISLIhy3q0hixLeDx63QCTSUZoArvdxNaNrQwYEktba4iY2N1RQlEOE73zjSKAvxRDaDYw+LPS2PhHt8DAwMDAwMAA/QvXLs444wwefvhhrrvuus7XbrjhBl544QW+/fZbbr755j+iiQZ/IvbnPG4NqtTV1eHzeUnT4mFoLA0+ldcLPXjDGufnOenuhNsLYphZ6CHWqhyyw29/BCIaX+z0oQk4OTeKqF8RJZAXZ+HticloQiBLEm/8ECQc1gUGRVHo2bMnzzzzDIMGDaKsrIwFCxYQiURQoqKpaG7ZZ3+qqu4/GsNsAS1CTEe2aTgc7rKey+XCZDIxdOhQ3n777U6xes6cOcT/5QWi21XCmmB+ZYRJmTaEEGiaXiRtV+E8h8PBtddee9DzTYh2IEdMvP3KThSTzKnnZON0mQ+6zf7YleML6OJcR7RAQbKFTU26e3RI0sHdwqmpqRx77LHMnz+f+Pj4fRyVAJLTifLUU4iVK3XxrG/fA+4vOTmZa665Zncbx49HLixEbN6MdPjhyAcRqffHspoA7R0xMaXuCMWtEfon6uLSJdZLeDnwMlbJyjnWczqjOBr8GtEWCZtJ5q+HZ/FlxqO0anB67i+LhKmrq+v8XAGqq6t5bZObN7e2U9QSomesmVirQqLt180AKHntNfKFIDEQoKWiAvm007q8nyvnsl3dDppGTp1t9xuyjNSvH6KhgV52Ezet+ZDALbcz5uWpaDNfoxobd5x8D9JRBUTZLdxz3gn0BYSmIdauRYqKwv/JQgatW6SfZ8BH87JVxJw8AZqa0LZuhfZ2CIdBUSA2loSIl+r4VHo2V4IMzQlpvH3+XaxMyWOXxF7ljVDnjSBJEq6AF6u7lRqLg7BVpcpq466rnmFC1ToOH5LDxJN3C5aSzQY2G+YHH0Tt0wexbBkiLw+lVy+9+F1HIUNJkhB2u268CoWQzz9fj8mYNAlpwAAIBhEWC+EbbkDq6CfTU0+hvvqqni3d3o727rvIjz560M9F+/hjPSYG0N57D3niROS//AV1xgwkmw3loos6133jjTdoa2ujf2MjposuIjJ0KEQievSHxYLpiSc6i+uBHqOxy3WcmprKmDFjWLp0KS6Xi2OPPbZLOxYuXIim6UVIlyxZQnl5OZWVlZ1FBEeOHMnatWs71y8tLaWlpYXEPQo/RkXp17zT6SQmJobx48ezePFiAoEAiYmJ9O7d+6B9sYvhw4cf0nqxcRYaWjaAFMYR30BFTRZ2cwYybjIzcrnyygv2u90Jp2Vy+FHJ/DC/lpee2sqO7R6CfhWTSSYU0lAQWG0y3vYIsgxbN7n54sNyLrxq/0UJDQ4dQ2g2MDAwMDAwMDAw+C/h66+/5u9///s+r0+cOJG79iq8ZGDwn2KYWsqSsjoUNczOVW/RePgjTC+S+bbcR3FbmL8vryemeQfHa5t4+b4bsdlsP7/TgzB9rZslNbpbb3trmPtG/vpsTHmPqdpNTU1ERUWRk5PDAw880Cl0TJ8+neLiYi666CKa2/1owSAoZtAiIASJiYm0trbu5WiWdOFHNiFL0NbWhqZpnevsitEwm83k5uYyYMAAnE4nra2tyLJMamoqA5KtlLq9bG4KEWORuWVhHfboWPp3uAH3FCQPhRef2Mq2zXqWc0NdgJvv/WUCLIA8aRJizRpEaSnyiSciZWcDMLmXk+7RZtrDGmPSfv7zvf7667nkkkuw2+0HLA4oJScTPv5Efqj0E1UdYEya9ZBihCRFQbnhhl92YnvQY48p8naTRLpzt6h7ouVEjjEfg4KCSdLbLUlSp8MWwGaSObPXoRcF04Tguwo//ojgyPz+9O3bl8LCQlJTUzl8xAguXeUj2iLTzWXGLEvcODiavgn7Fmg84P4XLUJ96SUIBDi8tJRWqxWP2Yw1LQ25Y2bMLq5SLyBdTiLkFBxv9oA8m6bYZObmHUN27VzGOhyI9nZGrV2A/LwH7Y03wO+nMj2LMBKYrIQVGyXuCH0TLGhPP422aBEIwYDCrYTb29iQmc933UcjK7kcUe5j3EdvQ2EhNDTojTCbCZksLOx/FHXRicT99BVyMIhbEmjNzagaTMiyEmWWeWF9CG8EwqpGr4oiTtz0HYVJ3VnecwRNSRlUChvvZI+hzRXFBE1DDgaR7F2d4Mo556ClpKBOm4Y6dy688w7SuecinXgiNDQgNTZCMIiUn4/48UciP/6IfPPNyP37I4qLUa+6CjZsQCQnI+XkIIqL9czrujr9+oiN3e/nsnjxYubMmUN2djaX2u10XkEWC1ityOPGIR155D7XvNOpX1vjKiuxKAq0tOhu6/79EV4v2nvvcfpFF2GxWKirq+PEE0/svMckSeKuu+6itraWmJiYTlF4F71792b58uUAJCYmUrkrc1sIVq9ezciRIykoKGDBggUIIcjNzSUuruvz9/TTT6ehoYGKigomTZrEwIEDeeGFF9i5cyd9+/bF5frlg4xVVVU88cQThEIhLrnkEkaOHNnl/YEDBzJnzhwcMS24YiQy02NRTA42rqjm7rvvZvLkyV0G7Xdhtsi8/sJ2tm/1EA6rRFSBLECWJaw2mXBIQ40ILA4T5SXtmEy/Ph/dYDeG0GxgYGBgYGBgYGDwX0JCQgKff/45t956a5fXP//8cxISEv6gVhn82cnxlVCw4X0koSGhR7x8V+FkTX0ITQgQ4HGksLCphbfeeovy8nKSkpK44oor9hE6DoVSd3iP5V9akm//mEwm8vPzO3/ec3o5wIsvvojP56OlrgazZCYmNYsoqxmLGuDCCy9k1apVzJ8/v9OpLMkSVosZq1kQl5yNx+PB7XYjy3Kn4BwXF8fw4cM5/vjjOeuss9A0jZkzZxIfH891111Hz54uzLLEK5vcxFllNCmWoSeeS/ni2aSnp3PGGWcAUOmJsK0lzIBESxfBc2/qavydy411gQOudzCkmBhMzzyz3/cKUg7uZN6bQxGcHl/d2hnLcVYvBxfm/3on/KFSkGLl/hGxbG+NMCbdSvxe7mGr9MvO8+d4dWUdXxS1ITkcrE6L4rHHHqNx82ain3oK5aqrOKvHEXxw1EUkRSmcnBvFMdm/7J5Rn38esX49tLXRPxKhMT4eKTqa1D3crCIQ0AXTuXM5yWpFueUWlFtuofKkS7juhybUdhC9j8e5eQNDVq+G2Fi0WbMgPh4qKujXVEp6oIVqNY64hGiGp1gR7e1oS5bo+y8qwlZWwpb0fB495lo2dRuAUmNiRXs99p9KGJ6drTua4+MJxyXwwGGX82WvwzFpKmM2LCTT58FrsuFu8bCz0c9dtUEUCXyq/nxJa6nh9BWfMnndXLxWB/845nI+TDmf1hCkmAQ7G9pZcNsrjN++DPnww5HvuKOLgCvWrdP/9/th/nyorUWKjUV57jmk5GQAItdcg9ZUiza4FmnxjVj6foI2ezaYTLuLIebnIxUUoPTti/bOO+BwIHcUoxQeD9p770EwSNtxx/HUU0+hqiqbNm0i8dxzOX3iRERNje4yt9lQn3wSsWYN0vDhyDff3JlLfu211/LPf/4TrcbNrPrDeHm7k5Osazku0g5btqCFQvDTT5z82GNIp5yyz/UgSdJ+C/IBTJ48mcTERJqamhg/fjz33XcfFRUVSJLEkCF6vvHhhx9OUlISdXV1DB8+fJ9oCovFwvXXX9/ltZSUFFIOEB8iGhoQK1eiZmezoq0Nh8PReSzQXf6nnHIKFRUVxMTEUFdXx6xZs7rkR48ZM4apU6dSVVXF7HecuFs1duyoJBTWZ6p8+OGHTJ48eZ886eWLGtA0gcUqEwyoRDkV0CTSsuxEwoKGugBYQWgQn2jl5LOyMPj3MYRmAwMDAwMDAwMDg/8SHnroIa644goWLlzY6ehZsWIF8+bN45///OfvfvwZM2bw5JNPUltby6BBg3j++ecZMWLE735cg/9OFlf5eW2zh9jEw0lI+p6W+hoKCgqIz+zO9oX6NHAhAE2ghkOgRfjwww87Hc02m42rrrrqFx/3hO5R/HOTnl96Qs4vz6ndH3l5eUycOJFvv/2WXr16cfzxx3d5f11RCe0mFxHqSY51ctJJJ9He3s7xxx9PQkICa9euJT4+ntbWVhRFQZZlRowYwZYtW/B4PMiyjMPhIBKJEAwGsVgsJCUlcemll3LmmWcCcNFFFzF58mRWrVpFXV0dPXr0YFJuFPPKfLSHBYoEl59/FnnX7Z4KXu6OcMuPTQRVgdMs8fy4xAMWVjzlnGze/EcxsiJx0pn/PwSTxVV+trWG0QTEWaXfTWjWhGDmZg9FrWGOybIzoVsUww8cVf2ztAZV1taHyIk20b3DIS18PqiuhqwsJKsV9csvUR98kMIeJyNSchFxcRTKgxB/e4GYTz9lcXxP/Jl9OGH7UjjtDCxpKZzW41fUzjGZoE13slsSE8kYOBD5xBOROwYqALTPP0ebOxfcbgDUZ59FOvZYapN6oXakwUguF9XjJ5IXakZta8NVuEEv/JeSguP887m0sZFnRBZRpdtxT/2OuPXLEWVlSMnJaK1tzBp6ErP7HkVzVCxClologgAKNTHJVMpR/NB/IllqO7MHTOBfPY8iiAmbGe457W5G7vyJlugE4nyt+FRBsKNRWkf766ITeWLCNVTHpHHb96+wLqkXzqCPkMVBS5uPstJa2tZvBksEbfFi5FNPhT2LS44YAd9/r+ci2+1gMiG8Xr3oX4fQjNWKOrYM0bcBHC2EPI9gcvZBbN8OkQhSZibKjBlISUkAKHff3eVj0F54AW3pUgDkjRtRVRVN06itreXzr75i2COP0L17d33dxYt1JzggFi7UCw2OGQPoA8533XUXbyrHUjFzPcgyH6UMZczESqJDIYiKgnAYbe3aLgU0DwVJkhg/fnznz0888QQrVqwgPT29y0BcXl4eeb9w3/tDtLej3noroqWF7du380FyMqUxMVx88cVMnjwZgO+++w6fzwfQmTG9T0QRMGDAAAYMGED3rDbefKmY5jYzTVWLWbt2C1FRUdTX13f2L4CqalRX+JCAhCQrakQjN89FwahESovbKd7mJjHZSl1NAJMi8bfnhuJw/vK4IYN9MYRmAwMDAwMDAwMDg/8SLrnkEvLz83nuuef45JNPAMjPz2fx4sX7TCX9rfnggw+45ZZbeOmllxg5ciTTp0/nuOOOY9u2bSTv+iJu8Keh3B3hL9810thRBHDS2Y8wc6hCQkICnpCGRZGxKSo+IWESERzeeq4aGMsszxE0x+Ti9NbS5PHyYVE7rUGNk3OjSD3EwoAn5zoYkmSh1B1hQOKhRwj8HNdee+1+s47L3GFaex9N9aonUEMRMlxxhEIhXnrpJUCfUSBJEgUFBVRVVdGzZ098Ph9msxlJkujduzfx8fHEx8fj9Xo7c00dDgezZ8/m9NNP5+WXX2bBggW0t7ejKAqKonDsscdy/fXXM21sAmvrQ/SOM9MztqvQsakp1Cm6tYcFRS3hAwrNRx+fzsjDk5Bliag/qAjjLyUsIBDRz6+y/ZdFhexNeUk7G9a00LtfNL3zY5i908vWljBHpFt567VXmL10LXF5BWwZfyZ94i1kuX5dH3nDGrcuaqalzUt8Sz139JLp2T8H9YorEEVFenZvdDSsWQNCcEQglu2xGdDQwBHblqKuWMG7PccxK2UIOBwsTezNowUpSE4nIhRChDU9Y7gDrboa2tqQ9xAC98R0332Et2/XRdScHJSLLkLeKxdbrFwJPl+XrF+1rZVesfX0am9muzmWlLgozD4vF2dNQs0xc5n2OSfVroOkJOSoKF5zZmIN+Ki2R/NytYWpoIvqubl8Newk3muNxmuyUhWbil2RwCSTE2dl+KSx3GTqTn1ULBGLherELEwWE8GwIKJJtMSlMK/PEUiaQDHJNKtyp8CsN14gkGiOimVB7zFM2vQNxYk5NEXMaELDokGb1UGTYtfrEGVkwF4FGuXDDkN6+mm0TZvQ3npLz4oWAm3uXL0A4iWXoNx4I+FNS8EVQOqWg1DLEWovfV82GyImBklREBUViPJypEGDkJy7I1R2RWkAOH0+TjvtNP7x6KM0t7TQYDZz7733MnPmTL2Ip2Wv55p1Xxe9LTkOqYde+E4xSVjOPANWfo9oa0NSFKT+/Q94jR4qTqeTo48++t/ezwGprNQLfgJtra1k2e2UxsSwevXqTqE5IyODzMxMQqEQqqpyww03HLSgaY88F/YoBbs1iUDTOGITVDK6mZk3bx5XX31153r/eGobKxc3EAxqeNxhcvOikYBF39QyamwyR5+YxtMPbcZuV0hMtrFjm4fhY5J+v774E/H/47ePgYGBgYGBgYGBwZ+EkSNH8s477/zHjztt2jSuvPJKLr30UgBeeukl5syZw+uvv27kQ/9J2FU4D6Der+IN73aV7fSoJCbqU6OjrQr3jYjl76tb8YQFg7MSSB+YwvGDo/k00I1gZSUiOomSPnks3apHVKyoDTIpN4qq9ghn9nIeNAIioglmrHezuTlMlEli6ph4esT+vNNsU2OIrS0hRqTYyI7e/1ddEQxCKIS0R6xDo18jY9xkGjcuxd9Ugy3a3mXa/VFHHcW3335LaWkpZ555JjfddBN33vcgRbUt9MzLJ9blQJIkzj//fI477jiefPJJFnW4FZubm1m/fj1z585FCMFPP/1EdHQ0eXl5rOuYzp/mMJHWff/tHZBowaZIBFSByyzRO+7g/fBrCgD+kYxJsxLRQJGg9yF8xgeivtbPw7evIxTUkGWJ46f05e16PYLlsw2VuJcuw9/YjL+xmuju/fBFDv/Vx6rwROg75z0mfP0WiXUVRLJzULOTEQsW6MUT93JjTir8jr51xQTMNvrWbQenk82TRuuir89LYWYu2O1oS5eiPvUUaBrKddchH3MM7jfeRr73HizhIPKkSZj2M7NF6tsX86JFiEWLICEBeY8ia0II5i0spKbVySRnLDH+GpBlagb14s6GD2lfsJbzdircrPUmctsdPFwRwe+Iw4zGrEETmRSrR7B4mto464cfcLa1UBebzE9DdFfs65mH8UW/ifitDjw7y6ixxqCZzAzAzXMls8moiPBT0MqytKMRsoImyfRoq8PmaWFdci96tVZTb4+lLSaRdk0CAVYZZL8Pp89DqrueHUk5BM1WNFmmIj6Dq895jLDNhl0NooUDjNu2FE9UNKu6DeKK7grSYYch6uqQUveyrOfmwg8/QFoaUrduiOXLERs2IDZsAFlGueoqzLGPEHnrTlhSh3zW6Uh2O1J6ur69oiC2b0d9/HHd4ZyejvLss7pIHIkgn3026pNP6svnncclVivNNhvfm81QWorb5cLv92OxWJBHjECcddbu6IyCgn0+15POzKKpIUh1pZdujk00n347aR4PUrduKA8+iPwbCM0HQ9TXg6bt24+/hJwcpIwMRFUVzvh4dnTkWQ8dOrRzlbFjx3LrrbdSXFzMuHHj6LdHcc9AQOW7r6qZO3cu1c3f0q9fHy46/yZWrthAi7sUi1UjzlmAw7GDpKSuIvH61c0AJKXoRVbj4i1sWNNCQpKV6gofaZlR5PePIRIROJwmgsEuwxsG/waG0Gxg8GdElmHYsN3LBgYGBgYGBv81aJpGcXEx9fX1ndXhdzF27Njf5ZihUIg1a9YwZcqUztdkWeaYY45h2bJl+6wfDAYJBoOdP7s7pmMb/P+kuDXMwyta8IQ1Lu/r4qRcBwMTLQxLtvBjdQCbSeKCPk4WlPvZ1BRiTJqVqwfGcPXAGL4t91HVrnJMtp3WoEZaWhppqakgSQRNMqgaQgi+LvfxcXE7VkXig6J2vj09HYuy/8JvFZ4Im5t1kdAXEfxQ5f9ZoXltfZCbFjVhkeGj7V5mjN83YkLbsAH1kUcgEEA+7zyUc88FYGCihf4JFtrPuI6m+f+iIN3Gdddd17mdy+Xiueeew+/34/f7Kf1hOZ4RV2CNimFgvIVTTcWkJMR1Tj0/8cQTWbVqFX6/n4kTJ5KYmIgkSZSWlhIMBmlqaqK4uJiTTz75Zz+bLJeJ6UcmUNQSpn+C5YBu5v+vXDcoBllyE1IFV/aP/tX7qSj1EuoQijRNUFjmA7uZ9pBGTciEI70vrrYleMOCMSkm8uJ+vVM+Swpw5PLZOJvrMQUDRG/bgL9QQw6HMSHY37erHk3lu3/weJi05GO2TLgGNI0xq79BfBNGmzNHd9oC2ttv80X30bxaaMN64n3cufQNBn/1FcLnQ9pP7rkUFYU0cWLnz6KsDPW555htyuTVjNFoyUP49uR7eWnOVGzdMilxCTyb14PPy7upcOqyrTz35RqiG2ooTXYgbFZSnWZobmZur8NYKffmOLEG2WalR7iNguEp/NR6MjPso6iXXXg8KnJsJkHJhF0L0WvV97SWLCKpchsZYUH6Jf3YGZ/NwPrtPDj7aV4ZcSZ9gxG8FjuOSAtmXzvu5O5IQFJzDcmt9fSpLebZjx/greGn89GQE1mTPZBEXwsR2YQt4KNHqJVr575ETlM5qqTgjY6D8f3RPvoIPvoIMXkyyh4F4sTXX6O+/DK0tyMkCWpqQJKgd2/ocN1KMzejLEgGNKSKLchPPAF1dYiqKuTTTkNs26YPEACiuhqxZAnazJkItxv5ggswvfsuqCqSw4H64YeckJzMytZWvJEIx40aRcweTmvlwgvhwgsPeJ1FRZm4+rY+TH3oIVbMmEF+WxvYbKRZrYgdO3Z/n/8VLFmyhE8++YT09HSuueYa7HsVUNTmzkX9xz9ACJTLLtNzpX8Fks2G8tRTiM2b6ZOWxvmlpTgcDgr2EtaPO+44jjvuuH22f3naVhbOL2XLFjeuhBxCobXExb3LxuIPCIdVhDCRE30Eia5x9M07qsu2AwviWLWkEYCL/toTs0WmpSlEXEehTYfTxCXX9uLLD8tJSrUz6f9J3ND/Bwyh2cDgz4jdDqtW/dGtMDAwMDAwMNiL5cuXc95551FWVrZPRqEkSajqvze1/EA0Njaiquo+xXxSUlLYunXrPus/9thjPPTQQ79LWwz+8/xzk5vF1QHCmqDRr3JC9ygsisRHJ6awqSmE0yzTHNB4cIUuxnxX6ee5IxPoFm3m6Cw7y2qC7GgLc1iajck9HSyqCtAvwczYDBuPrWpla0uYep+KqkFAEexoi7C1rJqXnnqUpqYmJl9wKZOOPxabSZfokuwKLrOEp8NR3SPm4CKzJgQPr2hha3MIVUCUSeLx1a08NCoOh3m37Kd98gkEdIem9t57yGefjSTLmBWJqWPiaC0YSfRVo1HkfQVwSZJYvXo1f7/mGrabUjANP43cgcPZYepG/OgC8pN2T33v27cvM2fOxOv1kpycjKoJrrnmGu699166d++Oy+XC4XDwl7/8ZZ/jzJo1izVr1lBQULB7arnTRIZz91d3IQRUVkJcXJep+//taD/+iNixA3nsWKTcXEB3cz8yOv7f3ndevxgSk6001gdxukxcMDqe0i1eVtcFcFnthPsdTZ7Zz8mDc7jqrCP+rWNFOe30zY7HvzOMI+RFqCqmXUUiAdHx/8EYXbaOFz64h8boRAbWFhEZnw2bNsGOHXr0Q2srb767CCHJBEwWZuUfzeDNLfr3uIMgamsRP/6IOns2NDdT5rTgDlXQZnMStMXQnJhGRnw8bb27gbYZJIlYXwQRCGGrqeTcTfPoltyHcJSTi+yNCIeDDzNGEJ0Qg6xp2PweUgJt3F5mo3zQeMoaQtiEIIyEXZKQEQRlM990G07BthXURWXS4Ixna3w3NJOCo70NgkHqXEmEFRMVcRmY1TCDKzezI7k7ArAG/MT52rh4xUeY1Qinrf+avLpiLj//aaqiU+jfWMJhVas5pXQZAwq/wxQOgoDWpAS2L15LICmaXkpPbEuXwp5C86pVUF6uO86bm0FRQNNg61akY47p7D8kS+eyZLej3H575z60detg1iwQAikxEW3pUkRHPrb29tvIp5yC1FGQTj72WHovXMhrdjv+ggKSHn74kK+xPVm9ahV2TUMDWiMR0sJhpPj93zMiGNTPMT29sx174/F4eOKJJ2hqasJsNpOYmMjFe/QTgPbll53OfO2LL3610AwgOZ1II0ciA2Ozs3/RtqXF7Z1FAYNefRaK291Ez3wXrU0hvN4IZnJQPXlMf2QLj74wFAmJxGQbV9/WhxGHN2G1KQwepvdX954uPn23jLgEC2delENMrIXjT8381edmsH8ModnAwMDAwMDAwMDgv4S//vWvDBs2jDlz5pCWltZl+v5/E1OmTOGWW27p/NntdpOVZbiB/r+ytSWMN6y7QUvdETQBsqSLqwMSdQF1c5O3c31NQL1PpVu0mdc2e/h8p17IaXVmkGOy7BQ2hyh3R/ClCP51bDKnzq6l1K2iaoKQCiYZXvl0PhUVFVSmDuP6FSHep5YHRiUwMMmKVZHIdpn4sTrA6DQbR2YeXFyr96l4whqKJNEWUtGExOamEG9uaefqgbtdslJKCp6wRmtAI5SVTXoEXB3GVkmSiLN1dQuvWLGClStXMmjQIMaOHcsnn3zCptJSPEoNPncriRaF5Nwc0vaTh+xwOHA4HLy+yc1z691EWwZy1ZRH+fJfLwBw2mmn7XN/r127ljfeeAOATZs2kZub22WKOegic+ihh5HXrEZyOFCmTu0Ubf+b0RYvRn3iCQDEV1+hvPIKUsc0+t8Cp8vMI88OpaS4ncxuDmLjLNxkVajzq5gkkOJ7cPFJ9zC5168T5oUQaP/8J2LjRsjPxzx6JKYN66CxFk2InxWW90eGp4EMT4P+w57Z4XV1aFlZOJrr8UXFocTGklTjhfx8REvLgUVGr5fI7bfDli2I0lLIzuaIcBMfpQylNi6NYHwSK6Y8yZkDEzl64zqqFm2l1eTkjGKB/dkn6P/efDLryriwYhsOIphyuiFlZZHsbWZLdCIzh5xM3+oilnUfwqLontjawtgUCSSQJEHIbEWgx6CETWZifW30qdvBx4Mm4rfqLuz5eUewMy4TixqmJDGboMkCQrAg7zBd9JUkyhIyOXXDPOJ9bbTYo/FZrLTbnBxZvJwvB0xgaNl6ri7+miw7kJ6CVlYOQiPK30hxZjKWoI8qrYqeA07R+6W2FnXqVL1QnyzrGdpC6P9kGWJjOwsCymecgVpcDOEwyjnn7NPH8uDBSE8+iSgpgUGDUF9/HdHQoLuYc3LAvHtQTIqNRZkxA2cwiGuPzO1daF99hTpzJlJcHMp99yEd4HfokJEjWVFZyafl5ZwfG4tyzTWdwniX/bW3o553nu7UzsvD9MwznYUL9yQSibBlyxbaGhshEGB1IMBFp56KtIfbWurWDVFRof/wC8Xh35Ijj03lk3eCdOvWjZi0bRx38qlMmDCBLVu2YLN5cTfbiXbq/VZf4+eWy1YhSTDx1AzOu7wHIw/vev7DRicybHTiH3EqfyoModnAwMDAwMDAwMDgv4Tt27cza9Ysevbs+R89bmJiIoqiULdHMSOAuro6UveTz2i1WrHup3iRwf9PxqTZKG4NE9EgJ9rUKZqVusNUtasMTDQzKtXGJzu8rKoNEtIEj61qYVymnTX1IQAq2yM8s7aNJ1a30BQQCODznT5eHJ/IsCQrq+uCmGTd7WmSJL4iD6nHSdSkDsWq+glq8NlOHwOTrHxf6Wdzc5h4m8K2ljAbGoIMTDrw9batJUxLQCPRLhNUNXrEmDHJEp5Q1+iZ+rMu5MNtQbZK0czucRi9vqzloVFxHJGxr5C9Y8cOHn30UYQQzJ8/n/j4eFwuFwFZxhxoJ6G1ih5tW7hrTBxJB8ibDkQ0Hl7Zgj8iqPHCvPRBvPjiiwSDwf3e4+3t7Qf9GWDWwm1kfLUEkwx9IhqOBQtQ/h8IzaKsbPey3w91dfAbCs0ADqeZ/oPjOn/ul2ilX7yFotYwcVaZI9L3Fft+DtHWhjZ7NqK0VBcqGxrglVd0sbJjhsneIvOvHR6scybwXd5hpLbVszx/DDXCSovFyRk7l3DFig8hHEC94ALkr77a/w7q62HbNl0gjERg507y4uIZ2FqG2eUgKjEOZVgBYu7rWL/5hitVG8JqRTnrFITDwdiWYkR7E8gKkt2mu36zsrjjx5nM6HsCoUCIeT1Gsyx3KGYhQIMh8TL+FjeJW5bT7IhjbbdBWMwmBlVuJiSbWJfRl6zW2s4mapJMUUouye4GvCabPqK1V4+FTBamHXUVbw8/ncc/f5zBVYUkeFu5fNkHlMRncvuPr5MmApCWBj17Ire1gapS2UcmECXz9eXdGG4ZQe8J1wCgvvYa2uef68UQ/X4YMgRKSqCtTRe3k5MRa9dCRgbyiBHwwgvQ3Iy8R1Zwl883Lw9sNiJnnIHYvBmCQT33OT8faa9YSkmSoENkbm5uZubMmUQiES4691wSnnsOamsRFgu8/TamPaKr9mTKlCksGTsWu8VCwejRB7x+tKlTEcuXQygElZVo33+PctZZ+6zncDiIdrlor6jAJklENTSgvfkmyvXXd64j33ijLjCrahc3czisYTb/56I3Tz2nGwWjEkCSyOp2ZufrM2bMoKysDJcjk+en7qS1OYQzxsyusbuvP6/irIu7YzIZMaF/BIbQbGDwZ8Tng7599eXCQthPzpeBgYGBgYHBf56RI0dSXFz8HxeaLRYLBQUFLFiwgFNPPRXQs6IXLFjQJavW4H+T8Zk2vq/wI0vwwKg4FFlibX2Ay79poNqrEhGCBJtMi1/FGwGnWWZOqZ/vKgPEWWVagyrukO5UDmu6mAxQ6olw55Im8uPN2BWJQESgauAOaYRtKURSFUKSGeGMxROC1A7BdkdrhDpfhHirglmRMB8gyxmguj3CtLVtJNoVmgIqk3s6aQioxFkVzund1b1aFTHz7VHnsLY+SFgTtIc1ZhV79ys019bWdomvqa6u5rbbbmPx4sU0V1aSnpjItTdddNCsX0XS+2MX3rCgwZpMduL+v4aPHj2aESNGsGbNGoYOHcqYMWO6vN8e0vigwcI1Nge2gJcar0qv33gmQaPWyLrIOnoqPclRcn6z/cpjxyLmzEF4PEh9+uiF2X4HPCGNyvYIOdEm7CaZvx8eT1V7hCS7QtQhCmTa4sVos2cjZWUhtm3T3asNDXqOb12dLuTtwW8x7ySkmLl30h00OuJQZRm/zYlTC5Oq+UmqLccR8oMkIcrKEJEIkmk/11BWFsTE6CJzIAAWC+Z2D3/d/g3z7JB55qWcvPB91DffRDKbEYoCJSWoTU1w++0gSUh2O3g8YLNCcjLykUeSuH49pxUvZnl8D76KSyVisqCYFbLlIFe9Nx3XpvU4g+14rVEs6zWKF06+kWOKl+ntBSpi0wABktwZx1DvSoJ9ZuwIZCFAEwhJoj42lcoefRlWsR5F05BkgTPso90Zi5SXieR2IyorIT4e2trIDsUjNwQ4fomdoePG7RZ96+v1/pBlcLmQbrgBeccOtCVLEFu2QHQ06osvIq1bhzx+POr06RAKIcaPR9lj5s6eFH3+LNbmzcQrEWyaBl4v2vr1aK2tyAcYQHn22Wf56aefAGioqmLqpk3Q2AhCIFwumDIF7Ztv9Izp9HSkUaMQH30ECQmMvf32/bqTu/ReU5MuegcCEAigzZu3X6HZYrEw7sgj2VJVBUIwMi6uMxt8F5LN1plhD9BQF+DxezfQUBvg6BPTufivv8/fKKKwEBEKIQ0a1DnjIxIRfP91DasWN+BwmfjrrX3omZdAQkICAM+8nkgwoPHpe2V8/XkVAEmpNkNk/gP5Q4VmsWOH/nD7nyWMFt6KCMX+0Q0xMOhK0I/S4SpQgyvBdPDpiAYGBgb/CwitHlnpiWzO/6ObYmBwQK6//npuvfVWamtrGTBgAGZz12zagQMH/m7HvuWWW7j44osZNmwYI0aMYPr06Xi9Xi699NLf7ZgGfzzesMa0tW2dYm51u4ovrPHM2lY2NoWJdGitTYHd+eA+VVdPwyGBO6S/LoC9DMQAVLWHKfNECIR3xwv4IwKTLGOKSSZWhkBEoEhgN0nMKfEyp9SLPyKoCEeYMiyW/Pj9i7ll7jCztntpCWjEWGXSHCYmdLNzRk/HfmNn+iWYyXaZKGwOQQRirQrp+4m9ACgoKKBHjx7s2LGDrKwsRo8ejcvl4rPPPmPlypVkZ2eTl5e3z3YhVbC+IUhKlInsaBPXDYrmX4XtWBWwKfDA8hZsisSTR8STE931/jaZTNx3332dP7e1tfHGG28QiUS44IILiEtIwuRy8M6FUxi4fhH5A3LpvZ8CWr8Wt+bmFu8ttIgWTJh43PE4ecq+5/hrkLKyUF5+WRdss7P3L5Tuxb8KPcwu8dHNZeL+kXHEWA8uHNX7VG79sYnWoEa6Q+HpIxJwWmS6RR8843tPRHMz6t13I1pbkeLiEH4/ktOJ0DQwmeB3msnhtjlpdOhubFkI4nytXLH4XSyREDYtpIvcZjOkp+su3P2hacjPPot68cVQWtpZ9L2P5CW/8gfkwkzUzz4FWdbF8/h4SE7WM313FXQ1m8HpROrbF2JiiDijKTn2NByN79IYFUsoOpaB/jq0tjD3bvsCykqxRoKEZTP2UJD8+h2oQuLhCddxzJZFeC12wrKJ675/nfeHn0aTKwELKqoAVch6Ub4OshsrqI9OQgIskRApvlbm5o8jt3wrA3eu4/OBx2JSzOzM6E1ayEu0zQbx8UhRUYjychzZfejd2AgflsI/ryB04qeY//Y35CuuQJs/Xxdgs7IwDRyIdOaZSFVVRK66Si/2t20bYuNGxKef6g7nSAR1+nS0H39EPvfcTsFWW7eOou9eZXXdfLrHh6h3qgxcryEHAro4/Y9/wAGcya2trThCIZzhML7GRr2vFUUX5NetIzx5MqKsDCk1FVFVBZ9/jpSZCfX1aG+9dUDRexfKSScRmTtX/yEpCVpbD7ju36ZO5YeUFGJ/+IGCvDzk888/6L7nf1lFQ62eb79gTjUTT8kgJe231RDUDz5Ae/ttAOQTTkC5+mqKt7n5253r2fhTC5oqyB8Qw1sv7+ChaUM6twsGND7/oJxwWOX40zKJRDQjd/kP5g8VmpWzz0bZT1bN/wrhwL8IZ70Irf/8o5tiYNAVr8au0gCB1msgbIz2GRgY/O8jSbFIciz2hNl/dFMMDA7IGWecAcBll13W+ZokSQghftdigABnn302DQ0N3H///dTW1jJ48GDmzZu3T4FAg/9/bGgIsqQmSJ84M+Oz7AghaPBrxFpl2kMa3o6ie01+lQeXN3PpNxE8IcEB5KxOxM+8D9AcBIskCHWsLKHnufaMM1PhjuAJgyJJNAVV3tnWTkQT2E1ypwg7IXv/YkZzQOWOxc34whoNfhUJGGoPcawUBLoWwQqpgsLmEClRCs+MTeCSBidLawK4LDJn995/Zq/NZuPpp5+mqamJ+Ph4TB3CaExMDBMmTNjvNpoQ3LusmS3NYWQJ7h0ey5ThcVzeL5qdbWEeXdUKQEAVrKwN7iM0782zzz7Lqo4C3lVVVTz99NM8NCqOT4otOEf3YVy+Cy28nLD3HyBFYXHegWz69U7hEq2EFqEXfIwQYUNkw28mNANILhe4XIe0bqUnwsfFei54UWuYL3Z6uTD/4NuuqgvSGtSv2mqvyubmECNTf5neoK1bh9i2DQBRX480aBBi/Xr9zbw86NkTvvpKdw3/hiR4WxhauYmfMvtjjYS4YdFMetfuwKxGiAl4dq9YXk7kzjsxTZvG+sYQFlmib4KFJR9/j+P5acSaBJmXXIKYNw9RX6/PXi0uRgwZgvbOO7B6NZrLRUtqKu2nn063det0UVrTducW9+qFcDjQ/AEe3BxmY4wJ+8l3cu3YLHb81EDjxjKG1G5j5IYf+CaqG4maihCgKQrLew4nrAma4tN4c+SZDC3fwD3zX8BqkjmjdBmfTLyUwsFHsHFnIz6zDZ/ZBkJgFirHbVnI54NPIGiyYBIag2u3sS0+m0vPe5JYWSPe10r3jDjePnwUw02FKN0zkKKj0ZYv113y9fVEbrhBd51HIvDdd6jTpmGaPh3TrFmINWsgMxOi9dx2OSMDecgQtBdf1B29bW16Mb32dt1pHAgg1q9HC4WQx40DTUN96CGsnm0cXlJJW7yFLQPM5EUSiIpOgZgYRHX1AT/jKw87jNaPP0ZRVZK7d0caMACxYoUe5xGJ6O7soiJEY6M+ALBnDIf889/X5UmTUFpb0WbOBIcD+dhj91lHCIHP58PhcHDcnXfCnXfufq++HrFoEXTrhjx8eJftYmJ3D/aZLTL2A8QF/TuIJUsQmqClOYT49FvCx1/Iku/q0VSBLEMoqOH3q1j2GnB67fkiVi1pBKB332ju/fvg37xtBr+MP1ZovuMOlOjon1/x/ynBhq+RhA/kg09xMDD4jyNHgC0ASHI6yEaKjoGBwf8wohUhvCjWo7A4b/yjW2NgcFBKSkr+0ONfd911RlTG/xg13ggPrGihwafiiwiGJln4ptyPO6SRH2fi8cMTGJxgYkltiK3NQXwRCP6cwvwLCe2hSMsSJNtNBMKCKJOMywxVXpUyd4Qmv0ZujAmnGVQBeXFmEu37FzQqPBF8EQGSRM9YM1daajhh5uMInw9t1Cjku+/WB2e03eKvSYaHRsYxPNXG8EMQIBVFIbmjSNih0OTX2NKsT0HXBCyrDTI81UZylIJFAadZor3D2d0n7uddtk1NTZ3LjY26kJIXZ2HK8N2iT8D9PELzAC2Efa9jjf7bIbd3b3KVXBLkBJq0JsySmcGmwb96X/8uVkVClvR+BIgy/XxARW6Mni8uAIsM2a5f/h1HCgR013BtLdjtiBEjoKICmppg5crO6IffGgm45+vn2Z6UQ4K3lURf677HikTA40G88w4vjDmf+dZM0DSOSTfT7fW3kHxBtJYmov72OLGZqfr66em6u7W5Wc8CjoqivbqaH9LTeWfVKm465xyOaGuD1at1sTkuDrxeJCGokqPYGK07QwPNrWzX8njFXsSMTd+zOH0AT/ecyISaDVSk5WIK+FEdDr476TKujI8QO38uankF7SgkymFiTBJpJVuJ++xZNm34gS8zC7j16xepdCWzPjOf7/KP5IshJ5DTUE5MyMsAdyVL0vtTFp9BCBmvYiKvRxaj082cUL6K5Ngo6NNHL4jZqxfQkf3tcOjnscstHNBduHK/fmhVVajTp6N2FO6TMzORBg5E6tdPz1r2evXtQiGw23UHu9cLwSBCktBmzEBs2EByyIsvqOFzQW6VGdsRR8OOUlAU5MmTD/gZ59fWog0ZokfybNkCRx6pR538+KMubm/bpud++3zQ0IDy8MOIpUshIQH5oosO6TpSLrwQ+aijEC0tUF2Ntnw58qhRaJs20fKPf3DP8uVUJSQwfPhwpkRFIXk8yBdcgNSjB+rttyOam/Ud3XEH8hFHdO534qkZeNvDVFX4OObEdKJjDhwZdKi8+9oOvptbQ7dcJzff1w97//6UzN+AuyXEOlMGH5y6mNgECz5vhG65TpoaggwZEc9l1/Xqsp+6an/ncu0eywZ/HIa69HsjmZCkQ5+qY2DwH2GPKUqSZAbJeBQYGBj8byK0doTWgmKdgMX10H6nUhsY/DfRrVu3P7oJBv9j1PlU6n0qxa1hgqpgQ2MItUO/WlYX5oTPa3GYJSKaREvo4Pv6TRBQ51cJqQKzLBFvlVEkCU1AWBMMS7Fy85BYar0RBiZaUeSuz21PSMNukugdZybTobCqI2/ZXrsB4fMBoC1fTmFRLRuEkwyHqVP8jWiwpObghQX/HeJsMukOhWqvPvOg3x6RH7FWhaeOSGBlbZBesWb6J/68UHPeeefxxBNPoKoqFx1QaNq9n9aQidLaAIMTrVgPQZgF3eGoTZuGtngx9r59mXbvY2y0FpEr55Kl/Lb5z7+EpCiFm4fE8FWpjxyXiZNzHT+7TX68hUdGx7G5KczwFCtpB4hF2RshBNrbbyO2bkUaMgQpKQlRV6e7XBcsgMpKXXDcFVkhy7qI+RvPMJGFIK++Y7BRkroeQ5Lwmaw8ceKN7EjJxbe0iCt+vB97exsbs/pRsPZrhBDY/e2YhQYNNbpYarMhxcQgPB5obEQoCtVWK26LhbzmZn6qqmJst26I1av181VVpOhoMJtJ2rCBe0ofxW138dGkv9AjxkyJJY4veo9F1aDN5mJQazmn1PzERqJ5c8ixNAZUTlnwLsO+eR9RU4OSmoIcDkFlA8Lno3soQHpjFUO2LCelpZreDaUMr9zIkp4jyW2sQHbY+WvLKuKSXHxndxG22THLEmMai7g92cKRy9ci5s5F7XCZS6ecgumVV/SZP5s2QWKiPkjg84Hdjnz88Z39q82Zo4v3tbW6U3nIEMTq1cjHHKP3T10d9OqlF0GUpM6Cj/LNN8OKFXrBQFnG3NKOKzoOxa8QtVlDtlYgDR6MMmWK7to/AFL37vqC16sPXqxYoUfJOJ16wcDy8q5O+eZmTC++uM9+RFMT2gcfgMmEfO65ncfcsrGV6gofBaOTcL7wgt4fABdfjPr++3y3di0VLS1I7e2srKpiY2IiA6Kj0R59FPmxx3aLzKC7+vcQmk0mmbMv+e1y1StKPKjTpnF58yaqNuSyYODdnHzllXzxbhA1NsQnVd2RPGHSs6JITbNz8TW9yOsXTTCg8eZLxYRCGuddnku3XCcnTs7i5WnbEJrg5LOyf7M2Gvx6DunJ696V13MIRP8PO5QNDAwMDAwM/v8ghIbQypFN+Vij/2aIzAb/L6isrCQ2Nhans+t0/nA4zLJlyxg7duwf1DKD/2ZaAypfl/txmWVGpJj5sTpInS+COyiYX+GjzB0hEBG4w/u6Mb0R8EYEhxaE8QsQu/bZ8ezteAZbTBBWBSYJrAq0BDVkCSwK5LgUGv0atyxq4qgsO4osMTDRgqlDbP776ha+LvOT4VT4+2EJnJwbxZaWMDZFYkb0IPItX5MS8lCSnMN9WwWq5EWW9CgOf0QghKDSE2HaT62c1D2K3gcp5PdrMMkSTxyewKIqP+kOEwUpXQXtDKeJ03oeusFj5MiRvP/++wghsFj231aL807Cvtep8lq5f91k2iKt5MWZeeLweORD+L2n/fAD6jff6MXhNmwg9vu1HHnCCYfcxt+TcZl2xmX+shzYQUlWBv3CgQSxcCHahx9CJIL2xRd6QbWUFKiuhh07dsdK7ELTdjtePZ4D7/jfQZL0mBGvVxe2zWaWDxjPmKIVnLP8Y2qciThDfkBw0tp5xDXXIaO75SXRIYi3t4OmoXU4lWWnE5qbSfb76d/URP/mZlyqiigq2n0+FgsiIQG2bsXW1EC/DDvNssJdvo30yj6LN+r74rOswhwK4FesyGqEoM2BPSJRP3YCfaLNRCoqMFWW65EQdUKPqwiFkFQVW7gdm0nGKQcIZqSD240PC23OOIKyiSiLiTgtwNjzzuSUcA6flgaYuPorrvzpU7JXmhH1dQi3G9ra9KzpL75AO+kklFNOQfvsM10sD4d1wTY6Gu3DD5FOPln/GzArC7F1627HMiCFQihXXYV8881oDz6oi9GSBAkJSAMHYrrrLqRu3dBmzdKLJfbpA+npKFlZOFesgO4d0VKtrQcUmbVNm9BeeAFhMiFPnqzXKpMkXcyNRPR+dzr1z9vj0dvvcOi50YEA4ptv9AGDo49GkmXUxx7rjHehqQllyhRWLW3k+ccKAfhqVhlT6zYidzw31dWrEatXE9/WBj4fwuFAcTqJ76gBITpc/FJenr5fiwX5sMP0ti9ahFi3DmnkSLx9+mB69VXM27YhHXYYysUX/+rL2160gT5Na0FAt7ZtiOKVSFIvYk49lsUL6rC2eohy6s/KPgNiGT4mEYAnnt7IprV6vM+MJ7bwxEvDGT02mQFD4lBV0SXiw+CP45B+y8XGxv7sl7P/RG6cgYGBgYGBgcEho9UhyclYY55BkmP/6NYYGByUmpoaTjnlFNasWYMkSZx33nm8+OKLnYJzc3Mz48ePN/7WNuhCRBNMXdXK65vdyJKEXZFwh1Sag7qQ640IJAEa/Gze8u9D1++QZglkJEwK+FWBXmlQItYqE2OR6RVnoSWo0eRXeWhFC0OSLIxMtfLgqHi2NIWYsd5NUBXsaJP4uNhLcpSCy6LndarJKbgvupy0hhLKBx+DWq2/rgmJ8/OcaAI2N4VYURcEYGVdkH9NSMJm+m1rlcRYZSYdgvv2UNgc2YxP8lFgKjjgOrI5H2vMk8wuaaMtok8b39YSpsmvkfQzOara55+jPfccbN6M6N4dKTFRF7z2wiM8bFe3kyPnEC/H/3sn9d9Ih1gsysr0bF5V1d2tkqQXzPN6942xCIU6Yxl+FzRNF4ptNv3fwIH0aW8j2FBOkrueHnU7aY2KQQbifa1IQuiC9C7XdYd+s7HbAO48+k6uWvYeR9WsJbrdTZyqkm+zoWRnEwVoZWX6OdrtkJCgXwMd4qfd3UJmz+7I3XShLzbOhdI3n6bqBvpWbuG4cBWOjBQiTSFqalpoDtuIry3T3diKoveb36//29WHKSkoOTk4U1KIpGcyJ20UZ/7wA9tdaRzuLuGwSBnaIw9zb1oaDzz5JOra7YiOPHOx6zyhSzxG5Jln0N58U3cz73IFb92KlpyMEg7rw2h1dfrnGxurR4r4fLrj2elEstkwTZtGuKSkc3vJ5ULqmGVUM2gQWmIiyW43pgsvRLniCrSvv0adMQNkGfnMM9HmzNFF2VGjkI8+evdH+dxzaFVVSLKMsNlQpk5FvfFGPa4jKgry8vQCgJWVsHGjXsSvvR3hdhO54AKE241ktSKXlemi97x5nYMh2urViGuuQakwYQ9PxG920tAQxtd3KM6tawGQ8/JQMzM5QtNoNpvZ3r8/R4wYQfqsWXrbH3sM2WKB++9HfPYZUp8+SPn5aBs2oD75JNTWUvnII/zNYsEjBPfl5dGnpgapoAC5f/9fdXknZMejdtfjMOxRCpnj9NkTV97Ym5FHJCFJUFHqRZIkjj4hrXO7gF/d77LTdWgpAtqyZWhvvAFxcSi33qo/8wx+cw5JaP7+++9/73YYGBj8J5EktDxn57KBgYHB/xpC+BCiFZP9cmRTr5/fwMDgD+auu+5ClmVWrFhBa2srd911F+PHj2f+/PnExcUBHV+wDf6U+CMaxa0RMpwy21rCLK8JkuZQUCR4d4ubCo+Khi7kmmTw/wHjEbuycQ+ESYIos0SvWDP+iKDUozuR20MCb1gQZRYMT7HxbYWf5qAGCCQJ1tSH9PNvCxPu0NACEUFbSOOMnlE8v66NBr/GxBw7+WOPQpIkCgIqsY2NNAU00hwmxmXaibHKVLTvnpbuDQt8EYHtvzRB7pPgJ8wMzgTgSPOR3Ga/7aDrD0jQs7cBMhwKcbafF9C1jz+GqCik7GxEKIR81llIe0yXB3Brbm723Uy9Vo9TcjLNMY00WRd+hKoiVq/WBbm+fX/Naf7HEdXVqK+8AkKgXHEFUlYW0jHHIC1ZgtiyRY9eaGzUhTyLRRcng8H97EjPB8ds1h2ov9XzWdpjBoCmIXx+pEgEAgHS1RBBTz2moJ8i0vF77fSiCikuVm9jJKKL5Gaz/n3PauXlUWfTGBXLB0NPZmDJelyKCcnvx1FVBc3NaBUVuqCtqnrUxIgR0KMHIhRCtLdDTQ3SkUcidxSoPT4niuK2RLZnxXDiuGRi/D8iKiuR+g8gtmc3bnlnKubqGtRQGMXh0Avv1dbuPierFSk/H2n8eJRrr8VkMnHde+8TaluPed0neuRFaipYLLo4u2AB0uDBiDVrEDU1SHl5SFOmoD3wAJSXIw0bBjExaHfdpQu0e0ZPeDywbRuisBBCIT0aJT1db8rZZyPFxcGyZUTOOw8pOhrlkUeQDzsM7fvvEcXF4HajvvEGm4cM4YEHHiASiZCbm8tTF1+MAsjHHYc0Zoze199/j3rffWC3Iy1fjpSZqTuEhUBs2AAlJQi7HXJzkSwWlOefR9jtiKIiZKcT+b77EMuWoT70kC6EyzJi5Ur9HBQFMWAA2sqV8MUX+udVUwMNDXrBx1CIHHeYUa0mvs8+lezuDhx33IS8ZBFSr156OwoLEXFxnGqzodx5J+ojj0BuRxRGYyNC09AefBCxfbv+Od19t96ffj9qeTnVbjcxFgu1isKnNTXcntODT97YSX2CzOQLc0jLiPpll3l+Pkl3XUvCkiVIAwYgH3lExyUiMahAH8waOHTfQa3zrshlxt+3UFlZS5SpkDffLOKCCy5APoRiiUJVUZ96Sh8kqqpC+9e/UG47+HPV4NdxSL9WjzzyyN+7HQYGBv9JohSCS8b90a0wMDAw+N0Qai2ykovFcc0f3RQDg0Pi22+/5dNPP2XYsGEALFmyhDPPPJOjjjqKBQsWABjxL38C1jUE+KDIS/doMxfm66YAT1Dj/uUtbGsNU+YO0x7S8Ku6cBtSBb49ROWwgPAfZHrfR2aTJBQ0bEToHWfh9hFJ5MaYmPZTG8vadyByVhP0J+JsHkGa3czIFBtXDXDhDatsbgoRUqHMHeHoLDt2k0x+vIU+8WYqPREUWeLUXDtflfqJtcq4LDJ1PhVV6P2ysSlEa0gQ0gSTe0URY9VFiJNzo1hZG6QtpHFCThTxNoVGv0pRS5jeByk8+EewLLJsv8sHYnyWnTibTHW7yuHpts64kYOSkQEtLbrD9PDDUS68cJ9VtqhbqNfqAWgX7ayJrOEky0kAaE88gbZ0KYAePzBp0qGc2iHjER7WRdaRLWfTTfnl+fXC7Yb29k5xEUCdPl0XlAF12jRMzzyDFBWF6e9/JzJqFNrNN+t9ssuRGw7v35izyz38W4rMigKXXAJff02RJ4YX2o8hqClcFPiaw1asQBMCixAUkc4/mUQrTmIkH0/nrQVNQ2ptRWr36EJkMIhmtdHN28iXKd0QNhs1qTnklv6kH0eSdJdxTY0e2WCz6YJtJIKkKIjevZFaWpCOO67T1QtgUSRujhQhNi9HGjgQbcwYxHvvkVaylWMWf0JmxXYsfi/4/ZTbYnly+GVEhQPc8MNMMtrqIDkZsXMn4ocf0F56CdMnnyDHxWL+abUuMptMeryDzQaShPrRR5jfeAPtX/+CmBhEJIJcWIjl668RkQhiwwbU117THdl7O8wlCVpb0Z54AuXRRxGqqucgh0KIV1/VP7/lyyE6GpGaivTFF8i33qof1+sFlwtt1iwKKyqIdAjYO3fupKamhuxsPQtYcrkQHg/atGl6X6I/C0Vzsz6fo6gIrFa9zzUNuXdvfTuTCdMTT0Dp/7F33uFVVPkb/5wzc2ty03sIEHqvIgpWsGHBgr2u7WfX1bXturbFuroruuvay9rbWlcUxQoCClKlhxoI6T25deb8/ji5uaEpuCCW+TxPntzce2bmOyU3ue955/2uhexsnaPdrRvq889RFRXaXd8WmUJFBTQ06PrXrNFCaWqqdmU3NAAQSHEx/pBCBh/Wn74ptcgrLsVuaUEMHIjxl79g3HknlJToSBgpt46CqanRIjOAUqhvvkGeey7ihReQixZR53az2udDeDzkZGXxuW8f3l+WBlRTvjHInf/Y/l0X20Meeyzy2GN3apkevVO4/s7OXHzxXWystHn9dcjJyeGII47Y6e3vrsaeDj+yGeC0adN47LHHWL16Na+//jqFhYU8//zzFBcXs99+++3qGh0cHBwcHBwcdhhlN4CQmEkXIGTqni7HwWGHaGhoaHcuA3g8Ht58801OOukkDj74YF544YU9WJ3D7uLjda08vaSJNI/k6GI/l3xaTdhSZPkMVtRHWd2gIxDKW2KUtVo0byNjebewnXzlHUUAflMwMMtLsksyusDL4tooLy1vpjraQqtoxNVaiKvTl2TIThyQ1p8rh6TgMyXd09z0z3RTG7KI2nBuPy2490hzcfHAAPfMaSDFJXnsu2Y6JZkIIXRMSFQRsRSmFLy0rBkAnyl5s6SVcV11lEXXFBfPHJpNMKZI8UgqWy1+/0U1TVFFwCV48MCsH4yb+KkYZA5imbUMgMHG4B1aZki2hyHZO74N48Ybdfasy4U4+mjsN9/UObRHHYVoy4QuNorxCi8hFcLAoJehhTKlFPasWe3rsmfN2qVCc0iFuLblWsrsMkxMJvonMsDc8dv07fnztWszEkEecQTGZZfpF4LBxKC25pGqtBR7xgzUa68loifiAnLcuSxE4jFo52x6uhalt4ECLAEVqS6SQxZJYRsz/usbbyYYd9/GBS+XCz75BNGnD2/N6UmzOxWCQV5mDEOtElaTx3pyWEpnakkhislGmcxXdYXMWSXId2exv72AQjfg8WC6XUwIreHtNDeBjE4U3XAV4okHUTNnJkRZ29au2UBAu4/ffhv19NPg96OOPhq++gr11Veor7/GbGsaGfvzn3XcxOuv60zfSITsgkKOzVlEStVaApUbMKwYzw87lg2puWCYPHPgWfz5iye06Lp4sT4Gq1cTu/JKPcGRnq5d1R6PFpvT0rSj9rPPiF57rRZJg0FobES1HXO1ZAnWbbeh4tEcXq8+pnEHupSQlYWKRLDfeUc3+QsGtUg7d64+7k1NWrgNh1HRKKIth1lMmaKd2h4PPXr3Rr36KmrVKrJMk8wvvoCOkzLV1Tp2JDlZT2xkZkLPnqhoFBUIoNav1/ti29hff42cMAHr2Wf1ZNz556Oqq4n97ndQUwNHHYXcZx9oasKeMkU39PN6dd1padplH4vp85Wfjzz4YGhshJwcMi47l8yMDGJ//zd2SQkkJekojtJS3Yiww10HxkUX6TsaCguRJ56o72woKkKVlgIgBg1CBAIYzz4LTzxB308+Yb+WFjJPOIHTzz6bu/+0BFboyJn63dBFVtXW6smTbURbNDc369zxNhraxPYfQhgGxh/+oCct0tOR/0PGtMP3s9NC83/+8x/OOusszjjjDObOnUu47Ze4oaGBu+66i8mTJ+/yIh0cHBwcHBwcdhRlVyNdQzC9J+3pUhwcdphu3bqxcOFCevZMRL2Ypsnrr7/OSSedxNFHH70Hq3PYHcRsxb8WNdIcsVlUHWFGWYhwzAYhqGy1+GhtC/URRVPEpj6yJ5xXApStv4u2nwFJIibDlBC1N3czC8BrQJ8MF5leg4n7plMXVjwwr4GIDSW1EhVw4zGjZFPE348Kc5hbiwnVQQtPm86b4TWQAvKSEh9ZG8KKTm0NotY2xji9dzLL6iJUtFoMyHSzqCbCyDwv2X6DjS3a2p29hUvZZQhcRlt+bXWEpjbxvimq+K4mwsH+nWs+t7s4030m3WV3WlUrB7h2bRNQpRRPLW5iUU2U0fufwsm9krHuvLNdOJYlJRjXXQdAjszhfv/9zI3Npa/Zt11oFkIgBg1CzZ+vfx40aJfWWGqXUmaXARAjxrexb3dKaFaTJ2sBEbA//BB5/vkIrxd54YXY99+PKi9HNTQQ+/OfUUuXosJh+OKLzbOEpdTCp8ejhVnD0MJkXOSqr99qu8vzvKzO8TF6RSM1ySZ1SSYtbovKNDd5dWF6VIW1WB2LJYTRtpgMYjHYtAnVqxfJeSkQzoN160i2Q0xnAE9xBOVkEsJFHclYGKRYzbhWLOFkVUFyLEQdyUQirZjKQgaDdEsxmDH9HtTkyYiMDDj7bMTIkVpMDof1fqWkIE4/HfXVV1rsjIvPL7+s4x5yclDBINYXX2DdcAN8952OdjAMLXK2Cbad8/Mg0gIx7QJfmdMNDBOSkjALCxCDB6MqKvSBsm39NW8ednJy4riaJuKss1Cff66F4ZwcmDFDbyMS0XEfkycTnTwZFYloob9zZ+jeXTfMy8pCDRiAtCzsFSu0IJuaiv3JJ9r9GwzqKIk1a/T+K6W/p6cnYmPGjoW//AXq6lCGweCnn2bSpk0sdLvZ1+XC9be/oU4/HWG0vbcUFSEGD9bXh9cLxcXETjgBkZ+PvPBCfYxsGzwe1OzZxC69VIv9QmAvXAjz5sGGDXrZujrEs88ihw/X0TTBoBawFy2CjAxEcTHikEOQJ52kBWwpdaRIp06oqipUSwvqv//Vzm2lUMOH6zgYQK1YgVq4EDF4MPKoo5BHHbXZtWvce6++BjIzEX376idjMeRee9HtmGO4tlOn9rEnntWVh+5aQjRqc/r53Xb493JHsKdOxXroIV3T+edv5Xru2bMnhx56KFOnTqW4uJhx48bt8LrlqFHIUaN2ab0OW7PTQvMdd9zBo48+ytlnn80rr7zS/vzo0aO54447dmlxDg4Ou4lWC8+h0wAIf7w//EycGw4ODg7/K0rFABvTN96JGXD4RTFu3Dgef/xxJkyYsNnzcbF5woQJbNiwYQ9V5/BjeWlZM/OqwozI9XByL+3MjTdRlwKqWi3mVUWI2gpDgEsKQpaNBBpDNrveJ7YTKAtCreDygHQj0Q0FXRIMARFbC8220uJyVOnn3RLSPAbpHgMhBMEYBFz6/diU4JEGuWYnWkUl49IGc6jrUACeWdzEm6tacEsYmefGVoIxnXzkdxCaB2a5eW+NdqHm+Q2GZXu4d79MTvhvOf9e2sQrK5q5Zlgq1wxN5cXlzSgFZ/TZurldnD4ZLjyGIGwpvIagV/r2G0pFLcUXG4N4DcnoAs9u/xsjhGCUa/cIItPKQryzWh/H1Q3N9M9007ukpP11tWrVZuO7GF22GV1h3Hwz6ssvIRBAjhy5S2vsJDuRLbOpsqsQCAabO+bqVkph//vf2J9/jqqq0lm5OTlaLAbkoEGIRx8ldvjhqC+/RH32mXa4ZmdrR238vMZjC1pa2psFtruaExtLZDQD1ckmL47KYVHnZCYPyeDyKRswbMV9x3RiXZaPjFaLfz+9Gk/ESgjLxcVaUG0TbIPCw8T5w8mmgSG+Faz1SAaF1zBH9aCUbCpUJjESn91qSWWG6s2ZbAQU0qVociXR6E0hL1SHb/VqVFWVbi7X0gL/+IfOQI7FdN0ZGVponjBB5/3O3CKmJRiE0lItWr73HpSVacE3Ftv8WAihRerkZC3+2ja/X/gWT0+4hjxXjIv6FCNyDkbNmAGVlXp/hYBQCPXuu/ocdOqkj+fSpYjsbJTPh0hJ0XnJLS3azRsKgWWhli3Ty7edJzlqFGL8eFiwAA4+GEpKEIsXo+bNQ9m2FnHz83WsiGlqcXrFikT9Xi8iVd8FJ4JB3RSxuhrKylDNzXQOh+nscunteb26oVxpKWLcOOTee2NMnAjr12M3NGAddxy0tKDmz8eaMWPz6yYzU0/ONDXp49/WkI9oVF9/kUj7RIbs1QuVkqKX691bR2x4vRgXXYRasQL73/9GLVigj10ohMjL0+sPBvW6YjGE36/jPdauJXbDDfq8uVyYDz6IKCra7FSLQACVnk7swguhqQl5+unaWT17ts7D3ndfzL/+FdG1KwOGpPPYq6OwbYVh7NqGqvZbb7UfL/vNN7cZr3HllVdy+eWX71A2s8NPz04LzcuXL+eAA7aeUU1NTaV+GzN6Dg4OP0OUQi5vbn/s4ODg8KvBrkIY2ZjuQ/Z0JQ4OO8Wdd95Ja9tt3Ftimib/+c9/2Lhx409clcP/wjflIV5eof/fWtaWATyzLMT98xpwS8FZfZNpjtpELP2/mAKaowoBCMmeFZkBEQ1j1K6F3O7E8KCUwmXHkDEb0+fRGo8QeE2FzwCFINkl6ZLiorQpRm3I4oiufkbkenAZgt/1TWZ+dYQJPZKwFOT7O3FUsR8hBJateGtVC6AFbMsW3LpP+lY17Zvv5e5RGWxojrFPvgePKZhTGm53L4ctxeQ1QX4/NI3LB/9wdFJhsskDB2SyqDrCwCw3hcnb/3h877f1fF2u7+ad0JDE7/oFfsRR/XkQjm3+/3/EUojDD0e9+CKgm5ztCMLtRhyye/7e+oSP+/33823sWzobnelt9P7e8c0Rm5eWN+OfO4MRzz6MUjEKhY1vyBDkGWdASQmqWzftQrVt7Wi12gLN43EapqlFQcOAnj1hyZKEexm2/bkpGtUCqFKsyfGwtFDHtJRmegh5Td4ZmsmaXD/eqAIpsT0eiAa1uAiIbt1g3DjU22+D389k/6HM7ZnDtXOmUtdQxJfRoRyjKmjx2MhYDNOKElMdTUKCpxnHMcwin1psn0m1O4l6XwpIQfHKldqxG4no+uvqYN06ve9KaQE3HMY+5RREv37awdwxXiS+34GAFqJraxPLdkRKGDkSli6FpiZUZib1RSkca83joHf+i+n1ojp1wrjhBsTQoVivv466/HK9fdDCc2qqPgfxc9LcrOvt2VNHU7S0QGurzpAOhfR+ZWVBly6oXr1Qr7yCmjsX/v73RC5ya6sWmMvLoaIC0bUr8uabse+5R+9PVZXeZiiUiDJJS9PCdGWl3kZdnRbkc3MROTmII4/Efv11naP84osYTz2Fsf/+urnel1/quuvr9TGKRqGoqF3oNidNIvbHP2oHc/w4ut36OguFdGRFW68GccwxGNEoqrQUecQRiD592g+39cwzet3hsM5tBpRp6jpravQ+eTyohgZUc7MW6+P7F41q8bgtkkuef76ejAGse+9tz5q2H39c36nQ9ruili3DevJJhNeLWrsWedRRGMcfv/XvxI9AxWKo995DNTVpkX/9ev28bRP705/0eTvvPISZeI92ROafLzstNOfl5VFSUkLXrl03e3769Ol067ZrLfMODg4ODg4ODjuKUgql6jE9JyCMrTPdHBx+zpimSUrcubSd17t0aMjk8PMhailCliLg3vxDb3ALMa+iJcZfv62nKarH3/9tA8Ny3CS7YrTGFBE7EUkRtdmliLavLVdrAKPy3NREbFJcguV1URoi2k2bmx4gJXcw1SGQoRCBukoGly9n2LqFfDj2dErSChBAdUg7tPfKdlMdsgm4BJk+yd65Hk7rldweUzGhZzITerJNDCnI9RuUt3U2LEje/t12A7LcDMhyt//cPc0kxS1ojYIUMCTbvd1lt0VRwKQo8MMfixdWJ6T/RdV7ehpgc8IxxdqmKPl+kxTPD4svB3XyMacyzKLqCKMLvAzJdlNz8iHIvXuTbmYi2hqd7WkyZAaHug/d5muqogJVUoLo1w+Rns7DCxuZXhYiY+10sppqSHFLGn0Gw/v3x7r5Zi3iDRmCcfvt4PMhevVCtTVqExMmILp2xb7/fi1w2bbOEY4L0TtAOODn265+jlxQiyUE1ckmA9e3MGB9C8m4mNY/g/yiHpi/GwsPP6qF0EGDMG67TbvBJ01CWRYv3PUIvo1T8FiltIY9RGPQYrrpGq3hPPk+D3AqIbybbbuJJG7jLE7nU97NHEN9ViaHNM/mYBaDz6vFyA0bEqJ5R5E4FtPO3fR0VE1Ne9zI5ge7TQzt3l2LtqtXbz0mFoMXX4T8fMQ++/COx8PaKVMo+uADKoSgIDkZVq3CWrsWsffeyHPOwep4V4Bl6YzotngGtWGD3lZKCjQ16WiIaFQ7sxsbtTBs21oUnTIFNX16Ip85ft5MU4/JzNQRGtEoqqwM+8EHkWPHYpWWaiE6OVlnGLdl/QohEGPGoObN0/sei0FSEsa0aRgpKVjPPou9YUN7zIh1zDFYqanI009HXnONPlZxt7Vpahe434/s1w+RmYlx991YBx+ciO2wLD0uO1s7vKuqdP0pKci2u5yUUtiTJ6M2bEAecghi4EDd1FIpLahDuwjP2WejPvoIfD5kYSH4/VBYiFq9WmdI9+uno0TiYm5jI+bdd+t1JHe4A8Tr1dnZUoJlacfzqlWoZj2Baj39NGKffRD5+d/3q7FD2M8+q3O0QedGn3wy1NVhffgh1NejFi3SIv9xx+nxCxeiZs9GDBqEHDHif96+w65lp4XmCy+8kKuuuoqnn34aIQRlZWXMnDmTa6+9lptvvnl31Ojg4ODg4ODg8MOoRoRIwfQe9cNjHRwcHHYBqxui/HlGLU1RxTHFfv5vYGKyYHSBl+llIb6tDNMYsXloQSP1YZvWNgHaEFAdtNk7z4sE5lWFqQ1ptdkQ0CXZYG2TRXgnRed4xEVcwjGEFmBP6O5jZnmEsmYLBKR7BH/bP5N5VRFeWt5MfVi0x2FYCiqDNvnJLhqiNl09MWRrHb0aNjJs0zJKa9eyOKCFZonWclpicHCRT+9XyGZdk8Wts2p54pBsMrw/HNM2cd903l7VSqpHMqFH0g7vb+90N88flsNrK1vommJydt/d4zQele/lk1Lt9Nw337PNMa+EX2GRtYjR5miOdB+509tQKogdXYQwCpFG4Q4tE4rZXDe9lrWNMQIuwX37Z36vMxt0TvUfRyQc4+9G3uXJ0JOQBZd5L+Nwfh5C8/ZQpaXErrlGi8fp6RgPPURl2yTFnN75dOtTyH7lNZT0yWdgXTVmW+M7NX8+at067H/9CyWEFq6OOQZ50UVYv/+9drdCIg+4zamM0m7k9lzhjs0B2157fnQOg0qqkZEYpq0YtqYZAYRdHk6eZXH8kRfRdfkSxNtva3eubSNGjUKVlGDX1vJaHzcL6krIz5rLyS/MwSDGSOM7PuQA/uo+nh6RapqFmya1rQxxwXSGMINBJK1pIb02wsvWaA4V8yDSrMVCt3trp3Icy9JO2GBQf6+r29q1vHAhauFCvf/buyO2pQVWr0ZVVjK2uRnTttsz3WlubheH1dq12Kmp0L8/fPttQiwNh5HHHYf95JO6hpYWVK9eyM6dMW6/ndj992vHcjSaEM1tW/8spd6+lInM66Qk/Tgc1o7mYBCEQE2ZAvfei/D5UBMn6riOvDzEgEQGuHHKKahPPkF9/bWeFJASdemlqIkTkUcfjf3ooygh9DpbWyEYxH7kEcRpp+m7A6ZNaxeuKSqCsjLsqVNRra0Y//gHYsQI1MqV2iHeFmdB9+4oKbEfegi1YAEiNRXj7rt1k74PPsD6+991lMX772O8+CLim2/08fD5oGtXREoKxi23IPbaCzVkCKqqCnnkkQgpsd9/X9fR0qInFGpr9SRLamqiTsC4/36smhrYtAlxzjkYZ52F/fLL2N98g+zeHZWXpyNUdjFq7drED5s2Ic88U0eRfPxxYkyb+12tW4d1yy36Gn3nHcS99yYypR1+Fuy00HzjjTdi2zZjx46ltbWVAw44AKsHXH8AAQAASURBVI/Hw7XXXssVV1yxO2p0cHBwcHBwcPhBlF2FdA1Fmru2IZGDg4PD9nh3dWt7M7n31rRySq9kUtscpaYU3LR3OvMqw9wyqw6AnukultRE8BiS/pkuRuV7Oa13Mv0z3XywtpWbZtSiFNywVxouQ0dRPLGwjg/Xh9sdz25DO56FglSvdgKvb4xhShiY6cHnktjKpiliE4xBbcgm2y958KAcSpui/GFabbv7enldjBX1MQZmeYhaihX1itaooiWq8LkE+UkuCpJgv5x8XGtmcETFt6zq3IWlvUeQJyVVQZtUr0QoKEgyuHZYGp9vCLKyXt+iHbGhJmjvkNCcl2Ry8aDtu/q/j0HZHgZlb1v83VVcNSSF/Qu8eE1B/8ytXdPTo9N5MayjJxbGFtLD6NHeOG9HUCpCpPF67NhaECbuwEQM1w83v1teF2Vtoz7eTVHFzE0hTuy5/VzqbfFW5C1UW0vHdyLvcLh7x6Iz9hRq/nwtWgKqrg61fDkn9xrMX+fUk+Xei8mnrWO2D87sdjieEhuLKQCI1FTdBHDZMoTfr12mQ4fC118nxLY2N2xMwrJCH5uyk+lUF6bvqtpErAZoQTMeRRAKUeuTmBELoUC25Za3urxEDTcht4+H1/h44MtpsHatXo/Xi3rtNayPPmJxchRPAPqk+YkkhfEQxDLd1BgBfMQoay1krdkFIlq23V46uI2kiWQyG8pxEeUD12Au6F2Gu2snHROxPaHZ7YZevXRdGzYk9qsjO+rubouA8HYQmWPx5w2jXaBX77yDPPVU7KoqLXp6veDzod58E0pKtPhsWRAOY/zpT9DaqvPAV6/Wz1uWPgfxCYDGRi3WGoben3jecXOzfi2+T7YNDQ1YF18MK1fqrGSvV0c3rFwJe+2lHc3Z2bjeegv722+xrrwS0tJQDQ1Yjzyia+vXT0d9zJyZuCbCYYTbjXn33djPPYcdCkFDg3ZbgxaEQyGdd3zAAahFi/TzXbroeuvroaBAi6ttzmL7448xzjtPO3gXL9b1l5bqfPG1a7WzecMGRFER5kMPIXJzARBbNhAWAuFyaVd4aal2p69aBSNGIM87r32YzMlBvv/+Zosal12GcdllAKhgELu6uj06Q+Tno0Ih7Hff1fGc48cjfDvfUFUeeSTWd9+BZen1CgFduiDHj8eePFlHZ7Ttk9q4MXE9KoVat84Rmn9m7LTQLITgpptu4rrrrqOkpITm5mb69etHcvLO/TFzcHBwcHBwcNhVKBUBAab3SKcJoIODw09Gti8RUxBwCXzm1u8/6V7ZHomR6zcZ3y2Jb8rDpLglFw5IoXuabkB3TLckjum2tZN3aLabM6dUsqklRlNE0S/Dxch8LzcMTyO5TTAOx7S7b1pZiIfmN6IwOL1PgEXVUUqbYpzQI4kcv0G2TzIg0826Ji26DMvxUNKgG5l5DMHVQ1OZvDbI+qYYaW2C+aGdfVwxJBW194VUbjyeG+dESTEMUoCDOhmkew0GZLo5rbf+PHhIZx+flAapCdmMyPXQPW3zj5zR1meIhf6LNLrgDtyKkD+cpfxzQAjB8Nzti9nNqnmzn5tU006tX1llWmQGUDHsyNc7JDQXJpt4DUGoLeu7e+r2GxpujyJZRLVdrR8bRT8wes8j+vfXUQOxGCIpCdG9OyOzvPztQIM/zfuYxqige6CAEzofgCx2oZYvx54+HXHEEcguXbDblv0mI0ZZoIYDG/2ku90677ctymBlrpd12T7ePXs/znz8s/b4AJRKOGY7OHtPmraRN4ZnMHpFA2bYoi7JRNpuIi43b46aQI8ZH8Ps2YmdiEa1azccJrushdYcHzkbIFQUIL9FEa032RDNp9BVR2o0SH0sQGy7EvPmhHDjwqI+avD43HyOq1tPYZubd5tuZK9X5/CWlWl37v9KJIIJxLe02TtAU5M+lvX1qFmzEPvui/rqKy2CS4n69NP25ork5iKHDdMu36efTkRhKAUFBQnhtrJSLyOEHpOcDDk5WkgWQovMWzqxZ8zQQrTHo4Xu998n9uGH0Lcvri+/RAT0nRFi0CBE5846LqKpCfvtt/WkhGkiBg6EM89EvfqqFplHj0b26YOKRFAbNugmh4GAjsRISdGP09K0KPrcczoapKREx394vfp6WL5c70MggMrOxp4yBfx+RGFhQlQPBLBffllPuKSnI4qLMc44o11kjqOU0hMHaWnIc87RTuavv9Yic3o6pKdj/PWvyF47PiEmfD4t/HfAnjQJ+6uv9A8rVmBskXTw3fw6mhqj7LVvFi7XtqN95KhRiCefhGBwsyaFxoUXYlx44eY1DB6sXd6lpfquhF3ciNThf2enheY4brebQCBAIBBwRGYHBwcHBweHPYqyKxCyCNN7zJ4uxcHB4TfEKb2SUUBFq8X44iTcxtZCUNcUF9cOT+WrshD9Mtwc2z2JqKUwJTs0MVaQbPLe+DxW1UdJ82jnXFHA2GxZj6k/vB/S2c/QbA8xW5GbtPVHPSEEd4/O4PMNQXL8BiPzvAzKcvPBulYKkkyO6+7HlJJPSoM0RmwOLPRy+WDtMhZSkl6QTU6guj1L+aSeyRxctLl7LT/J5PGx2TRGbDK9crM6bWsDseCb+nFsJbHQu7j8Z/3gMfgxqKYmfft5584/SebwQa6D+CL6BYutxYx2jWaoMXSnlhdGHkJmodoEX+nqv0PLZfkM7hmdwazyEL3SXAzN2Xln93W+63gz/CZSSCa4J+z08j81ols3zL//HbV8uRadsnRfhtk139EUa0YIwermTSxrXM/ABgP7o49AKexXX4XOnZGXX86nJV/yYPpGhFjJ5KwA/8zJwhUOt4t5r++dxdc9U3BvLKHV2yZeRqOJmIMt3MHFlUHOmdPI+/2SeWVEJoWNMerNYoR5CoG6Ou6Z91iHHRCQm6tFzoYGspoi1Ce7aPQIulS2UhR28Y3RmapWP4eqWQSo52nGEeP77wwwsHAT5Qreoo4A39AXlx3joFVzyCeERCWyg+OOUCG067eqSn+Pi7yQcOrCth3N2xKuOzy32btbvDFeXKhXSjd++/xzLfhKqUXXWCyxzqoq7A8+wH7+eR2DYVlakE1KggED9OOPPtKTA3Fsuz0SQiUn6xxlpbR4axh6O9GoFqgNI+F2jh+XZcuIHn88MjMTMWECxsknY9x+O/Zbb6HWrUMFg1pojsUgGESefjpiwgRUXR00NWE98ADWe+/BN9/o9VVVaQex260d262tWjzOzNSveTz6q75e1x7f/+Rk7eJuacF+8UXkJZfoqJW6Ol1/ZSWiWzdUZSViv/02czA3NkRYNLeOgsnP0WnZlwi/H2PiRMy77kJVVhK75hrU0qXIAQOgR4/vvaZ2hI6xF5tFYAAfvL2Bl5/Smd4DhqZz/V8Gbnc98d/jH0IkJWFMmqQnRvLyEF7vDy7j8NOy00JzLBbj9ttv56GHHqK5LQQ8OTmZK664gltvvRWXa+dnUB0cHH5ihMCOfyhwnH8ODg6/BlQQ03P4L8YZ5+DwfUybNo3HHnuMVatW8cYbb1BYWMjzzz9PcXEx++23354uz6EDphSc2eeHM4EPKPRxQGFCkHVtQ5D+PpJccoejITJ93y9GBdxyM+d09zQXl6cl3ju/KtORBCluSXmrtZlQ7DYE9+6XwfSyEAVJJnttx+HrNgRZ26hD4AEhQWkHthD+HdqnnUWFQljXXadvsTZNjIkTtaiyG/EKL3cn3Y1S6kfdWSOEF0/q/ViRGQijC4Zrx2Oguqe52p3xP4aACHCO95wfvfyeQBQX6wZuHeiSnHB0uqVJvi8TVbKyXbhcbDbx+ht/Ir0lqt2keYWohQtJWVlJy9eNpBUWQnU1FUmSpYV+SjPcHPpdHfutaIJQVAt8mZm6eZ5l0VFijXrd3DYumw3pbmqTDJr8LqoDVQxcdx9nzq4kr7Et/1lKcLkQV14J69ejpk5FNjbSq0znz5KRAc0tfBrqzpHMogUP8+gJ3+Nmllhk0EQvNnA80+hNKfdzKgKFjeQThtOPUj04nivddo0qpYhKk2BjkNSOIjMkmtRtKTIbxtYZznG2l98MiSzluIt45syEExm04BzPXo5vPy5chsNaFI07szduhIqK9giVzbbf2Ii48krUH/+oxfNYTDuKhdAicVywzszUr8djK+LxGt9+ixo4EPX888ixYxG9emHccIPO977mmnYnujjwQOQ+++j3myOO0MJnvKFiJJLI8na59H43NMAHH2B99ZXeF59P1xt30rdlEGNZuq7u3dvfS4TbjfnII6jly1Hl5djPPgtut85lPv54hNSTjcFgjNv/MJ/K9Q3IhXBd71R606AjOHr1QuTk6GORlYVdU4N4+WU444ztn7MdQB55JNYTT7Q/7sjCb2vbHy+eX/ej3x+3RLjd0LXr/7weh93DTgvNV1xxBW+++SZ//etf2XfffQGYOXMmt912GzU1NTzyyCO7vMhdxW233cbtt9++2XO9e/dm2bJle6giB4c9hN8gPG/snq7CwcHBYZeg7CaE8CHdw/d0KQ4O/zP/+c9/OOusszjjjDOYN28e4TanVkNDA3fddReTJ0/ewxU6/NoZkOlmTmW4/fGWZHgNxm8j4mNHEEY27qRriIUnI42uGN7x/1Ot26W0VIvMALEY6ttvtQPyJ+B/EVGEzPzRd+aEY4rS5hj5SQZJ27k9/afEevJJ1PTpiIEDkVddhTB/9M3UO8zeWf24of/pLG9cz+icgWR70/gqXxLMilK0roY79/NQJyIIf4S9ShZjigqK6mOc9+FqUje0tDttXRbc9p91fNIvhX1LmvE1BsGymd4rhbqkKPs3KFKshPRrG7DJL9iU5kYCSRGbFblufFGbiGHzxJgMxi6r1uOzsyE7G3XPPVpwbWrSIqOUWsBtbYVwmCSCKAQSsJBYbHlOFX7C2Ag6U84tPE8OjRRSRRUpZNJAgCA2gkwa2kVxAYkICtumxe2jPJCNUuCPtOKytxCVO+Y1d2yAuCPEG/N1FKpte+us6Pj64q7ijmJz/HE4DEuXatHW69XLtLZu21EtBPbEifrYxrfd0KBdxbadyHBOTdVis9+vYzbq6/X6QiHU8uVQVKRjMBYuxH79dVRJCeTmInr0QPTsiXHmmahly4hdfrmORTFNvW/x5pEABQWIggLUmjV6giIa1SL06tXtojh1ddCpk963piY9CdK1KzI/H9XSghg4UGc6r1yJampC7LcfsqpKu5L33x/RIfqirLSVqooQuExs082ixgx6pzS0x1FY33wD332nmwCCzmn+H5HjxyNGjNANLgs3b2I6eK8MFs+vB7Sj2Ym3+22w0+/2L730Eq+88grjxo1rf27QoEEUFRVx2mmn/ayFZoD+/fszderU9p/Nn+APnoODg4ODg8PuQzcB7IPh3n9Pl+Lg8D9zxx138Oijj3L22WfzyiuvtD8/evRo7rjjjj1YmcNvhT+OSOOzDUF8pmD/gl1/S7LhORDDc+AuX+9mFBYisrNRVVW6CdagX3eT2NaozXXTa1nfFCPDK7l/v0yy/T/cgHF3YS9YgP3OOwCozz9HDBmCGLt7TS72559jf/gh+xYXM/r88xGmSW24kftW/gfrzMF4mkPMayihubEWlJfC6iAPPb0cqyCP/CYDERdQbZukCMjGCEfNr2dxkZ/BG0O8vncWL43KQQmY3juVu15Z0y40B32SrKYwhbUhNmR4yGiOclxpM+uzvGQ1RTl8UR22bWP4/TBkiI6IaGrS4mdHcTWeI6wUF4oPmKqG0INNDGI1y+lMBO1aN7BIoYViKohiMJgSBrCOalJoxksRVfyFp6knBQMbP61EcWES1eEbHdy2SoFpW3iiYX0Mvg/DSDTp2xHajucO80Mitm3rbYdCWpSNZzJbVkLQllJnIYdC+nEkklg+FkvEhvh8ely8GeG4cfD885s1eKSyklivXtC7NyxerGvz+1FFRah33kE9/DAUFenlhUi4q+MZ3lLCyJEYF12EPW0a9hNP6LEtLbqGaDRxLL1eGDYM0diohXBAXnIJcr/9ULaNdfXVOvrF60WMHIn5+OMJsbgD+Z38ZOV4qK4MI/r1YcCoAHLoWFRrK9ELLkBt2ADl5VBWhujdGzFmzI6fn+9B5Odv8/kjju1EUdckGht0RrPDb4OdVlk9Hg9dt2FRLy4uxu3eesb754ZpmuTl5e3pMhwcHBwcHBx2AUpFgRim9yiE2HMfqh0cdhXLly/ngAMO2Or51NRU6uvrf/qCHH5zuA3B4V12T6TFT4Xw+zHuvx81ezaia1dE7957uqTdyuKaCOvbGjzWhmxmlYe22ViyI83RVp4umUx9pJnTisfSM2UXNgE0tvh7LHevw1pVVmI98ADYNmrxYuycbKbt04XGSAuWrUXIcMCHGQ0gGmtxxRSWgLz6MLiD0BrcrFmcW5g0mjC9dwoLi5JodUnmdUmmNMODACwBdT5JQ5KLvPowTVLSmGZy4zulrM71ktUYJb3V4rYJnTl7WiXFlUGqUl3kxYRuxpacTMyUWJbCg47SiDfhs4Ug5HdjRqL0tzdgYHOt/Rpn8DH/xzWUkUUarYxgGccwk9c4gHqSeZwjWUYXTGwu5R2GsIpkqlCAjaQFLynSSgi/baKuLxYmq7UOIxZFfp/IG3cz76xwvKuxLP0Vd4EnJ2vBuKYm4aCuqtLPbUufcrn08127wpw5+rnsbJg2bXP3dpzmZliwIPFaOKzFa69Xu8Tr6xOxGx3d0nEB+Z13sA87DNG9O/TrB+vW6QmGzEyd3RwOa2e7lLBwISonB5GWhnH22ci2qCy1ZAn2tGmo5ha+rsuj9fMGDlixBv+IIVuV6/eb3Pq3oSz8tpZOXZIo7hHAmjQJ+5NPUAsX6nMSP3YZGYi99gJgw/oWnnxwBdGIzVkXdafPgLQff462oP/g9F22LodfBjv9jn/55ZczceLE9tv4AMLhMHfeeSeXX375Li1ud7By5UoKCgro1q0bZ5xxBuvXr9/TJTk4/PQELTyHTMNzyDQI7uCMtIODg8PPEGVXIYwcTO/xe7oUB4ddQl5eHiUlJVs9P336dLp167YHKnJw+GUiMjKQhx/+ixOZPy0Ncv30Gh5d2EjM3jGhrjDZJJ6WIdANKH+Ip0sm8/GmOcyuWcZfFv4bgFhkNq3VB9FaNZpY6LMfuwvIAQOQp5yC6NQJecQRiAN3j4NdxWKoaFSLtB0E0MnLp/LA0te597sXqS9dRWz5Mro3S44sGMnQBheda8NYhqAiSUKnQp2RK2W7kCpsm1V5flyW4pj5teQ3RFha4KMizc2mNDetHoP3RmRTk+LmibGFXHx+L/58UjFVAZP9ljfSvSJIdqvN0E1R/LakOiuJDZleVJvjtrpTFq1Y1HsFnw7ISIjMQFBYbAoYfLRXHiuLulLi7kolGRRSy3/5M5fzFoVUUUIBf+FMorg4lw9ZRlcAYki+QjeSFGjBR6JIJojchkhs2Bb+UAueWEQ3C/w+LItWUzC/cxKRnyKdJd68ryMdXc+2raMnNm7U4mk8liIY1M7hNkF4M1JSID1dx3CEQnpMRYVex7aIu5M7Egzq7VqW/t4xokMpLTYbRnsDQjVlCqqhAZmXh+jXDzF+vHZCt+V1k5wMaWlQXIxIS9P5zx2yjkVaGijFm+ERPB49nBfq9+LBRyu2e9hS09zsPzaP4h66f4Baty6x701N+nFmphbIN2wA4LlHS1i9oonStS08/sDy7a7bwWFH2CFH8wknnLDZz1OnTqVTp04MHjwYgAULFhCJRBi7m2+H+V8ZOXIkzz77LL1792bTpk3cfvvt7L///nz33XcEAj/cxMPB4VeDrZDzG9ofOzg4OPwSUUqBasLwHI+QjlvC4dfBhRdeyFVXXcXTTz+NEIKysjJmzpzJtddey80337yny3NwcNiNlLfEmDRP5+kurY2Sn2RwbPeEM/mT9UGeW9ZEptfghuGp5Cbpj/MFySZ3jsrgm/Iw/TJcDMz64TuN6yPN7Y+boq3YyibSeD12bCkA4cbLMDyLfvTdQsaZZ8KZZ/6oZXcEe948rLvugmgU47LLkMceiz15MqK4mHcGe6gK1bKmZi3+1hAjqgRXT/6awBNPc0XJQr5pXcGCzsmMLGkiyV5PbnqQQ9ZHkfGPRUlJrO2SQfqmOsKmQAlJXbILf9giNWhRneqlKdlLszfMlEHpSKU4YkEtBoKYIXApkMXdGNF/Xz5LmsWIxZWEDYMn903i7PIUrJKV2KaBJxqjx9paFG3ZyQIakt08cs4IlicbxD4YgKjtxfm8y7EhHf85jtk8ydGk0kIh1RzEHHpTSg51VJIGQDHlAKi2L1Bs7ywK+J42gx1Qitokg9XZPh45JJ/8hih3vL72R5y5nWBHIzpgc/e0UtphXFm5tau6LU5nM7E6EoHc3K2zo0GLswUFsGzZ5su43do1bZqJCJS44zsuNLctrzZuhClTdPO+v/8d9cwz8M47OkIjORmGDUN264YqLdUO6lAI+9lnkWecgXC7EZ06YZx5JivvWAVRP/j9rFy/485yefTRWA89hOjSBfbdF/Xdd9rNnJ2t940fbz6PRCK8+uqr1NfXc8IJJ1C4RUazw2+THRKaU7fIfpkwYcJmPxcV7cLbbHYjW+ZKjxw5ki5duvDaa69x/vnn78HKHBwcHBwcHHYa1YQQyZieQ/Z0JQ4Ou4wbb7wR27YZO3Ysra2tHHDAAXg8Hq699lquuOKKPV2eg4PDbiRkqc08pa2xxE8RS/GPBQ1YSsdjvLC8mT8MS2t/vW+Gm74ZOx5leVrxWFY0ltIcC3J+j6OQQoJK3LWMioAKgfhxjR93F7ayKWutJuv5f2O0ZeLazzyD+dJLGBdcAMCQpW/w9Yp3CFlhUoNhVrosHklv5eMPr2KtbKXWa+CPxLjvqEJSgxZdaqOsynJz0SdlKCEICYuydA/1tpfMxghTB6SzMd1FVYqbJq/FwPUtdN3UTGZThJRgjIjbxV7rW8luiuJGQmoK4k9/Yvgf/4g/Q3LDuEIMy0IiyGqq4oCyGLQ13VNtCl9UQnmqm7IMD4ctqKV0ZBeKhZeawZ3o980aYpgoBGm0cg+P8gqHEsNgCd05kO+4jpeZwUDSaWI0i4GEgLzDYvIP0OQ1UQIMS7G40E+rW+KP7ESUxk/J9ymn23qttVW7i2Mx/boQUFSkG/FdeSX2RRfp2Iv4a+GwFrK93oTzOhrV64o7qW+4AZmRgf3OO6i4GH3eeagFC7Q4Hd/u0qUwYYJuXDp1KmRmYr34IvasWRhHHok4+mjkVVcxculjrPxYQWYme48rTuzOihXYs2cjBgxAtplBOyLHjkUMHgzRKCI/H7V8OWrtWsSIEQi/jkk6+6LuPD5JR2ecc0mPzQ/X2rVYTzwBpolx8cWb5TE/++yzvPfeewDMnz+fp556akfOjsOvnB0Smp955pndXcceIS0tjV69em3z9kQHBwcHBweHnzdKVWK4hiJdI/d0KQ4OuwwhBDfddBPXXXcdJSUlNDc3069fP5KTk/d0aQ4ODruZrikuju3m54O1rXRLdXF0cSIrWwowBFhtGplL/m/SYc+UIl7Y/2Ys28KQ2n3pDtxKuPH3oGKY/t8h5LZF5hllIdY3xTiwk5f8pJ1u+/SjsWyL2xY8w/y6Ek5r+Y5jLInX8OgYgDaao63ketMp8GVRZlZQ7Y9Q7heYzS3c8sCXrMz1ceOpxYRdBjUBQbPXIKU1xjvDMqhIdXHYonoy3QE2pLtZWZTJuiwP6zM9WFIQk1BcGeHG/5ZixmyCboOC2jBjllaR1hQlp7nNgSsE6tZboaaGZOUhv97PaTMq8UcsFILUxhBNyR4sYZMUthHAyjw/zV6Dz/uk4BdB/vr2ali9jGjwFYQVw0UMicKQUGFnoRBIbMrJBCRptHAUs7bKRt1KZDYMLYJKmYhR2EFcMZuveqVSleqmZ3nw5ysy/xia2xz+brcWmwsKYOhQVDiMOu003TzQ79cCc8e85nBYC9SmqbOeKyq0MzoYhEmTEFOmIJ54QsdX+P2oYDARxSFE+3f7hhu0QN3aCmVl4HKhysqwVq+GBx6AzEwOPftset4whtaWGP0HpwGgysqI/fGP7Q0exb33Ivr2RSmFEIkzL7ISjfhE795bRQoVdU1m4qRh2zw01t/+hlq7Vj9+6CHMu+9uf628vLz9cVVVFbFYDNP86d4THH6e/KavgObmZlatWsVZZ521p0txcHBwcHBw2AmUCoNSmN6TN/tH2sHh14Lb7aZfv357ugwHB4efmAsGpHDBgJStnjel4Ia90nhxeTOZXoOz++6ayae4yAxgeg/HcM9BqRakkbPN8V9sCHL/XO3G/O+aVh4fm4XftXVgr1q6FPvDDxFFRYgJE3bJ3+q1LeXMryuhJtzA42M7UbTQxajUXiw/ajQby2YzKnsAdy56nu/q11DeWkNKfSsZdSGyGsPss7IB01bUJ5mkBmPUJruQtkAJQXmqm4ZkN991DvDoIYX89SuLo+du4JOuLs75spyqFBf/OLSAjRkefGGbnuVBfBGboFtiCQgEY9T5DWqCJjnNUS1IBoPg91NU2cjlUzehlMIfsSiuimDYkB4REFNa9PXbPDGmgLHf1TJmST1uS9HFyCEm64iqEAobo83rbiirPRpDAKk0k0N9u8Cs+IFGXErB2WfD00/v9PEvaIhy8NJ6BpW2MGplw04vvyfY0ru83asw7nIOh7UAXFEB8+dr13I0qh3Ifv+24zyiUf18Xd3mec7V1dh33gkFBYikJC00r16tx7blN+N26+01NSWWjTcW9Hp17IZlIQIBrKeeovi1wxHeROyrKi3VInPbPtizZqHuvx9VW4vxu98hjz12q3JfeWY1Mz6vpGffFC66pjeuWBi1dCmic2cdp7ElbRniwFbxIscddxyLFi0iFApx0kknOSKzA/AjheY33niD1157jfXr1xOJX9RtzJ07d5cUtju49tprOeaYY+jSpQtlZWXceuutGIbBaaedtqdLc3BwcHBwcNgJlLUeaXbH8By6p0txcNiltLS0cM899/DJJ59QWVmJvUUTotWrV++hyhwcHPY0e+d52TvP+8MD/weETEKw/biMlfXR9scNEZuqoEWXLYRm1dRE7JZbdLM1wHC7dQO0H4mKRGDNGjKzU6kONbCqaSNRO8YdB/blhgFjeGDp61AO75Z+xbqWchbUlhAMNuOyY2Q1RfCHbQwbCmsj5NeFyauPEDElYZdBSgTqU7y0mgpbCnwxQUNNKT3qm/jzW020eiQLi5LJbI6xLttLebqbJYV+hq9pxhO12Wt1EwV1YTKbY0RdUgvHDQ1aKPT7ITubgXigqlILjEqBlFR4FdXJHnrXWZj+JA5YHyG3MYIACuvCYFdgutyYLluLn20YpmRUdAmZNLKRTAawDi/6nAgAjwfVYXz783FsG554IuHK3UkGr2/5Ucv9olBKi7fr128es9HUlHAhb4lt6+u94/hYDPXhh/qxaUJODvTqpa+Dnj0hNRXmzYOaGu0wtxKOeKTUjfpcLijWMRnC6wXTRK1YgfXQQ6AU4pBDUGvWQEsLYtAg1OrVqMpKAKynnkKMG4dwJyJ1VixtYPKbugHg7K+q6dfN4MC3bkPV10NyMua99yK2aDwsL70Ue9IkME3khRdu9tqgQYN4/vnnCYfDW0XuOvx22Wmh+aGHHuKmm27id7/7He+88w7nnnsuq1atYvbs2Vx22WW7o8ZdxoYNGzjttNOoqakhOzub/fbbj1mzZpG9rVkbBwcHBwcHh58lym5CCBem78zt3tbr4PBL5YILLuCLL77grLPOIj8/33HsOzg4/KzYv9DLh+uChC1F3wwXhcnbkBQaG9tFZgDV4fZ6y7aYVrkQKQT75QzS2dDfgwqFsK6/HrVmDcmBAEPP78PyxvUALKgr4Z3S6e1jy6vXU1a2nFqzmZABIytaya+LkNYaI+gSlKe62GdVE3UpNdT7DApDktJsH/O7BpiXJWjySHpsbGL/72rps6kFTwyipsIXsWjxSjwxG5cNs/pksFedib+qlnEL64m4BOVpHnrUtQmFzc06aqFNGKS8XAu7GRkQCLDQ3cTEw7KJmZKB9ZJbp9YxZm45lrDwhW28XqBrDoR8WmhsbNSuWaW0uAj0YQO92YAN2HRwMbvd2JEI8vsyin9AZO645C/5L9D/3PJ+W8dwZ7vmNTZq0Tjucp8+XTuZa2v1BEJ6OuTlwdq14PFoMduytHAtpW7a16ULFBYizzwTYZrEHn4YtW6dzvf+05/06+EwoqBAZzDPnw+g85eNzdtASilQLc2wqRxME9/Dz2N/95G+Jjp31rnQWwrNw4cjn39+u7vo9XrxenfvBJjDL4udFpr/9a9/8fjjj3Paaafx7LPPcv3119OtWzduueUWamtrd0eNu4xXXnllT5fg4PCzQWXueLMQBwcHh58LSimUvQ7DvR+m76Q9XY6Dwy7ngw8+4P3332f06NF7uhQHB4dfEaqhAXy+zdyNP4be6W4eG5NFRatFzzQX5rayogsKkAceiP3FF4j0dOS4ce0v/XP5m0zd9C0Ai+pWc1mfE3R9SqE+/BBVXY08/HBEjo7uUCtWaMcm2ik9qkJQWtKAO2KzYkhX/KYXgRYVz3pjIQ90a6G3iFLrk+Q3Wdzz6loM26bRa7Ax04uJZOySBjJCUBz1sCQnREmuj0BQktEYZsziehZ1SSIQitGlOkyz18AXtalNdhF2SVp9Lur79yQwezG4PLhiMUREkZ+WjfQ06JiBuDu1ogKSkhJiX0sLFBTw5bAsYu4QCMGiAg8ruqSRX1NOyCvxh23sKBgW2sm6aNHmwqNptjujBbC5jAg0NbUfD9h5oVgBNgKJ+tHr+LnQ8TjsMgxDn4udFaE9Hi00x2KJDGch9PVSVQW5uXoiYt689gkFKir0NdO5M3LAAGhpIXb55dgLFmjhevVqqKhANTcj+vYFtxt5zjk6V3r2bDjkkK0c2N27+zk+/CmzgikMZDVDwrN0DbYNpaWwceMuPmAOv0V2Wmhev349o0aNAsDn89HUFiB/1llnsc8++/DPf/5z11bo4OCw60kyCS0/bE9X4eDg4LDTKHsjQubhSvo9Qjg5cA6/PtLT08nIyNjTZTg4OPyKsB55BHvyZEQggHHHHVvdGr+zZPoMMn1bSZztCCEwrr0Wef75qNZWVHU19owZqI8+otAoxXXCIKJukwV1q9qXsV9/Hfvvf0dFItgffID5wgsIKREFBdoZ3OaQPnF5lF5TqwjGIqwtMxn6t0PwGW4qQ/UMb1zOh2VVLEoHGZNkNkX442ndsW2Lqz4qIxCB3IYITV6DmiSD5EiQtFbJBd808cQgNxtSJG/unU33yiDvD8ngrlfW8OHgDKb3TafV56Zbvc1N3SZwwPy5PDbITcjK5NRZVXSyfbD33vDRR4l83WhUC8O2nXjOMCAzk6KSNcTStNs0P2qSU9GIK2bjCwqiEtzKgNoYdPdoR3M8QikpiQY7CNIkELaQdgdhs4PIGZcWbQEIidgigumHECisNpl2+2f5l8EuF8ktS58TIRLZyKB/DgS0m33L452bq2MyTFM3+mtp0eOF0GMjEdi0STvftyQUQpWVYS9ejHr0Ub3+aFRvyzB0FMemTSjAvPxynQP95ZeoGTNQ06ZBeTnmn/6UWF8kwjEZyzm6ca3eXm1Yi+AA3buD03jYYRew05/Q8vLyqK2tpUuXLnTu3JlZs2YxePBg1qxZo637Dg4ODg4ODg67AWXXgQpiJl2K4R6+p8txcNgtTJw4kVtuuYV///vf+P3+PV2Og4PDLxxVX489ebJ+3NSE/e67GL///U+ybbtyLrF/3wZLBGLhBkTfvgwN1rNyxkpmHNSXfbISDU/Vf/+bcC5XV6MaGxFpaYisLMy778aeORPRuzfi1VcZlNadhmgLQ2qSSQnpHOSeKUVYhx7OrbffxCpvBF9U8a/DCvisfxpZDWFqkl0sK/AhVBIDS1twIZjVI4lvDx/OqI8X0uR20+I1qE8yafS5sKTgpdG5PHZEF7BtTv6mhms+ryU983Ge6BVlZi8fNf4A7wzP4rINKZxaHQQp+XJgNl938TJucRN9GwSbUlykN0rcBZ1w5RfSBHRa0MhFNY00JEsOWVpPZmOEmBREDJOkmERKqRvLxTN6k5KgtZWNXosbTuxBdkOYMYvrOGRxAz6XV0cwdGhSFxdXDa9PC9AdYkx2BAtoxQsokgn94sXmXU68mV9HUlIgK0uLxw1bNErMycF87jmsm25CZWbC3Lk6IqNNP1uuOvFGZD+SzRjnGFNIs9qWF0KLyeGwFqvD4YT7ODNTv7ZpE8RiCI8H8vOhtBT1rb5jgEhE3yVw2WXYL7ygmwoefjiqpQVWrNB3OAwYgAoGEYEAorgYefTRu/ngOfwW2GmhecyYMbz77rsMHTqUc889l6uvvpo33niDOXPmcMIJJ+yOGh0cHBwcHBx+4yi7EWWXYXiPw+U7Y0+X4+CwSxk6dOhmWcwlJSXk5ubStWtXXC7XZmN/zo23HRwcfob4/YhAANV2JzJ5eT/JZu3YCsKt18EBG2GoxFgUQ4RCdE7K5aSuYxg35EiGZPRMLJCZ2e4AjiUnUR2uI0+lIIVE9OiB0aOHHrd+PcaKFaRvrIbaFUTHj0fusw9i5Eiin31Ci1swYEMr9UkGR8+pZlW2F6kU9x5TRLPPBBRZjVFOm1VFt8YYvsYWbjirN6HWJt2YDxvD5yOpuYnODTaXTC1j/HdNDFhdR0xZWI2V+LLysHO8rMn2YtiKV6PNFC3bQG66waTD8lG2xdziFP44uYwN3TNYPKIH+87bxP51zVhZWXRuamJwdRhJQhQ2FaTjBiOmBUbTRHTtCtEoatUqiEaZ09kmELY5ZVYVhq0IuSU+0RbTYRibic3A1s3pdgCBznv2EcHAdkTmbRF3rMeJN+/LzET06YNasQJWrky8XlKC/fnn0KmTdr03N2+2un+q8bTgBWXyivtwLk6frrOd4+teswb12GPaedwmcosuXVCmCRUViCTdr0QtW4bo2ROys/UkBSAGD8aeNAl7zhy9vg8/RCQloeLCtd+P8X//h5wwQQvPbQK6PW8e6ptvEIMGIffdd7ccRodfLzstND/++OPt3a8vu+wyMjMzmTFjBuPHj+eiiy7a5QU6ODjsBoIW7lO+BiDy6kj4nlvfHBwcHPY0yq5C2bUY7oPxBP6CkI7L0+HXxXHHHbenS3BwcPiVItxujL/8Bfu//4XcXOSJJ/5P61OxGLS0IFJTv3ecHV0IAR9UAAEb9usCsjOyd2+6n34RYovmYfKcc7BXrqQ61sKNx+ZSt/gxBpV15/bB52LKhGwhTzwR67PP4IsvtFAWCmGbJnz8MaqqkvRQC82pPkI+k37lIU6YXc0HQ9KpTnZhS8G6vGQa/EH6hHxkZ+fwVUorlWlZKG8SYbeHrulZnD+tin7vLcYVjtDod9G3OgaxGIZSmNVw9heV9Fkf5KqzupPRYoE0aelaSG1sPcqjM7BDfj9zhptsGtiNuSO7I6TB/nMipC1ZghWLYQuBaMtZ1ge2TRDu0UNn9rrdGBdfjBgxAvuppyASofeovix69AYMBIZhkOTyQ8xORHRsdbK+R2QWYruvG4CBtc3Xvo9fSxPBHSJ+7KRsnxigqgrl9+ts5Y5Iif3KK7BgQaKpY3w1QFS6QUnwegl36wtZVVBfrycKSkr0wHBYR2y43do53b075oknYj3yiF6f14vo0gWRmor5zDP6msnPx7jhBqwrrkjUEgpph3zfvlBVhTz7bOTpp7cLzABq7Vqs22/XovZ//wt3360zoh0cdpCdFpqlbLuVo41TTz2VU089dZcW5eDgsJuxFcaM2vbHDg4ODj9XlN2EsmsxvcfhDtyKkEl7uiQHh13OrbfeuqdLcHBw+BUjevTYJXEZqroa68YbURUVyJEjkTfdtNndGB2RriGIjFxUL4loNHDd+yQyr8d21y2HDMH17LN8UTKFupaFACysW8XKxg30TeuaqKGmBvXdd1pwC4chHKamoZK6pgr8UpEVswkraMlKo3tFK7+b3cCF06uZ2zONP57ek7SI4LA1MQZX28woUJgZWYzI7MPalnIy8vL5+xsbyZ6ykFBNkJBL0pAsqEkyyA5LsC0UEIhYjF1Sz42TN/LOsCz6VYc5sDkHo9MQjvKl8k39CgJKcmRDCv/I0IL8wd5iqJoOpaUYloVhGFqgdLu1UGiaMGgQIjUV+c9/Inr1QhYUAGBcdx0AAxYsID33QJT1X1KlB8/YEeByod56i7XhNDxEyKQR9w+JxB6PdpA3NSUa1EFCfI6f051wQ/9mP1HGBf6aGn08q6o2dyzH3c6LFunYiy0QLhe/c33By7EDSO6dzUmHBeHRefpF00w0gQR9PpKSEAUFGCeeiDjoIMTcuVBXh7zoIkR2NgBy0CDkgw+2b0OefjrW/feDbSNvvBE2bECtX48cNw45cuRWNamyss3d8Rs2wIABqIYG1IIFiOJiRFHRDh8itXEjauZM6N4dOXToDi/n8Mtlh4TmhQsX7vAKBw0a9KOLcXBwcHBwcHCIo+MyNiLN3rhT/oIQ3h9eyMHhF063bt2YPXs2mZmZmz1fX1/PsGHDWL169R6qzMHB4beO/fHHqDa3pv3118gVK6B3722OlWYPPKkPopJWI7sORMgMlFLYL72EWrgQue++yC3u5hBZWRRZA2HxIgDc0iTbm9b+uvXii9oZWlEBfj8RbJqzUvnbcd3wrTY4cnYFXgs4/HAKH5yE/5mXsZ94AiyLvc68kJe//Yr6pQvpVlIBUtJrfivJhxbSIg36pxVzf/MA8sqXEnEZRLwuKnKSqQxIVvRM5uiZG5FCYoQiCCEQ0ubsr6o5a2YtwuWC/CjU13PBV5JTfCYbThpH3u9PZmJxZ6Kl60k6uSexF6ZosTDugs3JQVxzDeqhh7RAuXy5zvC1LNTnn6MOPhiRnw+AWr0a65ZbyLNt6DMU+X//hxw7FmvlSr55cwlvMJITmEYDyfRkIwZtAqjLpR2wwaAWOvv00Q0WCwtRM2ZAaal2uXq9eky8aaHXqwXoSGTbbukfQPEbcDV3JN70sWOkBuiJBCESYn4cl0sLyYbBPvZS9hHfwVIJC6OJ6yM9HU4/HT79VE+qKAVpaZCejjIMrPHjUQsXtuc4izvvRKSkbFWaHDUKdd55Wlzu0QMOOQSamxEpKdiffYb98suQnY1x7bWI9HTEkCGIrl1Ra9ci8vIQ++yDamnBuuYaVGUlmCbmPfcgtvO73xHV2Ih13XWJ6J5bbkGOGPEjD7LDL4UdEpqHDBmCEOIHm/0JIbC2zAVycHBwcHBwcNgJlFIouxSIIl3D8aY94YjMDr8Z1q5du83/p8PhMBvaMhcdHBx++SgVxY4tQ8hcpJGzp8vZIUROhzpdLsjI+N7x0igCI+F8VDNnaqEYsJYsgexsRKdOiC5d2sfslzuIoBWmpGkj++cMIqtNaFZKYb/xhq6jWzdmpUeZlRpmVZc0jLJyzpm+CV/YQrjcZHTtjXz9PYjFMCdPRvbsif3uu2Q+9xyZmxq1W1Mpspqi3P/iKtb8+yr6zVxOasNGbKVwdemGHWqhOjuZD/slc9DcCpbn+chtiJLuTcFtuNqbwQmltLgoJTQ2UpcVoMRnMaelhFcjM7ntzFvwhMPYw4YhL7wQ++GHobJSO1NHjoRvv9VRBtXVui63G/uuu8Dvp/G19/jgsJvp1CuD/Yx1CcHXNHV0iceDuvNO1rkKqYpl8LY4kCPFN3Tyh0i2g9C7NyI/H3n66brWvn2x/vUv7Whdt06Ll8nJertxkTmu+RQV6boWLdLjtodpgmVhuV3IcKRdXP5NicygheGO7uM4bjd06wbr1iViM2Rbrnb8uokvY1kJJ7FpIoYNw/Xcc+2rst5+GzV9OqJ/f0SnTqj4xHMkoidw1q7VEzj/93+IrKz25eyPP8Z68EEwDNTUqYi0NFRVFWLIEOyFCxG2DZs2Yb/0EsZllyH8foy//11P6OTkINxu7MWLtcgMEIthz5uHsQNCM2VlCZEZdH61IzT/6tkhoXlNW/dXBwcHBwcHB4fdhVIhlF0FqgUh0zG9J+NKuhIhA3u6NAeH3c67777b/njKlCmkdsg/tSyLTz75hOLi4j1RmoODwy5GKYtI403YsaUg3LgDf8Fw9d9l67fCX2JF52O4R2K4t741/scix46F5mZUSQlizJj2W/V3mJaWxOO6OmJ/+hMiJQV55JEYl1zS/tKhBSM4lBFaIFv8LmLUKFBKi6OhEE3disias5jTGlqIYlPtgazGMN4YJHXvBtOnY6em6iiDt9/Gvuwy1BtvQHm5FlRBO0xDIXLKG8j98z+1WFdTo8cEAmQceAidK1bx+7cW89zobGq9in1agmRXtGgHaUoKGAaiqAhVX6/dp6Wl1HpACcG6nnksXzGLhk3rSA3Z2LW1GEcfDYEANDUhevXC+NOfsG67TbuZYzEdaeF2g9tNLGqz+tv1zGpeSr0vG3OcYkQohBICkZODvXIlYt48qKtjb18Fn8f6M0ysJS/bQ1JmJ6is0I0fs7Kw33lHC3zhMGzapJvW9egB3bqhSkq08G13cEBLCcOGITt3xg4GYdmyrRsNtl8UUjtcR4zAnjED27KQ2x7566Zj5nXckZyWBoEAYtgwyMpCbdqkxdtIRF+boI+7aWpRv7k5EVsiBGrBAmLnn48xcSKioAA5aBD2ypV6O1lZiIKCxHnNykKVlGB98w3WzJmYEyciBg1CzZpFbNIkWLgQpESlpUFhIbS2Yj/3nBafe/feLKMZdKQHnTolfu7SBZGRgaqt1df9wIE7dlyKi9vd0Xi9TmPB3wg7JDR36TDD6ODg4ODg4OCwq1CqFWXXgWoFYSJEOobncEz/6RiuwXu6PAeHn4x4Q0AhBOecc85mr7lcLrp27crf/va3PVCZg4PDrkbZm7TIDKAi2JHpu0xotqILiTTfpx+Hp+JJnYQ0u+2SdQPIY4/dqfH27NlQU4PYf3/EgQcivvoKtXAhtseN8Pr0mA8+0BmzHdyg1mefYU2ahJASe8oHiPpG2LiRyd1cvNmnjv9bGcKFRVpjmBRlEwi3iXytQVS4XAtr0SgkJaGeeUaLe16vFvY8Hv1zXh507oxavRrRqRN8951+vaUFKivJ6dGVaUVJfNEnlVNnhGj0GiiBFl1tG/r2xXjySazPPkM9/jikplLXJYt/jCtkRlGU/AoLV4fUCXvWLB2FkZ8PQiCGDUMMH45asKDdIW5ceSX2u+8SqW1hfVI3GryZqKoq1t/+MnsFv9axGpmZOkfXthEtLXTpk8ldS14h6vGT4Yoh0zpDcVeMZ57BvuIK7IULYcUKXXObkKkCAYw//xnrkksSOcJxsTkahZkzsb/8UoufhrG50BzPlo7Hatg2zJiB9HgS7tx4HvGPiN34xSGldoZ33Gch9HXk92v3cXm5dom73VpsbmjQY01TX4fdusHcufqYWpa+VqNR1HffYd1+O0oI1FdfIQoLweVCAuYrr2C/9hrW3Lkwf77OUvb7wbZRU6eiPvkE+7PP4Jtv9ESG262vfZdLu6FtW193S5fCsce2O9+3hUhORuy9N/ZbbyF69oSePbc71p45E/X114jBg5EHH4xx332oFSsQBQWbOa0dfr3sdDNABwcHBwcHB4f/BaVsULVaYEYgjQKkayym9xike28nJsPhN4nd9mG8uLiY2bNnk+V8GHNw+FVhW5XEWp8AYhi+03Vmsa2bcwuz1y7ZRsxWfLl+NfkySq7fwGdKlF0O7JzQrJTSzbvCYS0QmzsvG6iWFqxbbsH+5BPIz0d+8AHGpEkYF1zAp6XfsOjNJ9nnq5X0TOlEao9+CCl1PMbMmahXXsGeNQurbAPL8v3E7BjdNrUQQPL63pk0eGF9XjLeaCPZ9WHcERsQWhCNu4NjMS2kZWSAZRHr3AnT64FN5dqN6fHofNuSEkSvXtolGotpgQ/ANPGnZdGU3kww4OO9g4rp++YqMMIgdPSBccUVyN69if3hD1rYFoJ+S6PkHNSJfF8mGXkZfHRIlOOWBpHHHovIzsZesAAaGhA9eyKEQI4Zg/r2W73tmhpUfT3Gfffhbw2x/IUg6rtmkhs2sU9soc5SVko3nvP79Tr69oVgkJRoVLulv/0WFQohBg9GNDfr/dm4EdUWiyGEAL8feeqpyKOPxvrb37QjNhbTAmdqqt5OXAhtbtbPezzaddurl34uFtNjqqoSInQ0Cj4f5ORAY2NiDGzfER1HiET8xI/B49HbN4ytc5J3N16vPmYdc5il1HWkp6NWrdK5yG+/rc9dWVnCAS2l/t7aqr8nJ+tjFwqB243y+1FffQWdO0NlpT6Pto399NOQloaKRmHlSu3Uj5+XpiZE9+7Yr72mt+P364mNHj2Qp54KyclY69bp7USj2uFuGIj09O3uolqyBOs//4Fly1CLFmE1NiKef36zySFoyxK/+269L598AhkZyMGDEU4vt98UjtDs4PAbRfmNPV2Cg4PDbwztXq4GFUTINKTZE9N/BqbnGIRM2tPlOTj8LHAi6xwcfp1EW/6BHZ0PgLKrcaf8FSvyBdIownDvmtvJX1/ZwpsrB3B6pzzqwmUMzeuHdA3b6fXYzz6L/eabAMjZszGuv367Y1UohPr4Y/B6EWPHtgtP9qRJ2JMnQ20ttLaiTBP7jTewHnqI/OpVLD58AB+NG8galcKpl/9FL/Ovf2G99RbquwUIr4tISzNpm0IsGVzEvK7JlHksqtJMDFeMlw/IYdwcg0GVMbDbRGaXS4um8axhpaCxkaaVS6jctJwFnfyk9Mnh4NH74Bo4BHXdddC1q3aInnoqdufOqMmTdT7ukUciOnXi+FHXsSplDfOrZ7CmyMfeb2wCUQSmG5GWpl2/06cnBNKmZnKUh1xfBvjAfe3xuPx9ITub6CWX6LFSojZuJHbxxcgzz8S49lqsBx9EJSfDxx9jV1biuuMOrr9TsWljK4FPy/BeujEhoNo2VFSg8vMxTj4ZAgHU7bej6uq0Q7ZXL1QwiPXxx4jrrqV+8lsktQqEDYZSCMB+/33Ul18ikpNRffogfD4YPlwLicuW6W3Fc6OV0m7Yzp2Rhx6KPOkkWLUK69FHUZ9/nhBYo1EtbNbX6+UyM3VEhGVtHi2xLQxDO71LSzd/3uPZdka0YWyeKe126/O/PZE5JUULsT9GyI5PPsQb8nVECH3M4/uulP7ucumIifR0fYw+/DARjRGvwePRX01NWrCPu5kzM3UUS1OTPgf19bBxo95OXZ2O1cjLw7r6aujeHdas0e7peNPBujrEccchSkr0Oe7dGzp1whg3DnH88QjTRKSlEbv6al13fr6u7fsQInE9AKxapWNYCgs3G6bKyzc/Rps2wWDnDsXfGo7Q7ODwWyTJJLR+3J6uwsHB4TeAdi/XoOxKED6kzMf0nYLhPQIhO2lnjYODg4ODw68dlRBylN2MNHKRvpN36SY2tcQI2ck8u/4Oks16/tW1Nz7hSmy3rg48HoTf//2lzp+/2WO1ahXWAw9ALIa87DJkh3xW684728fLdeswLrhAL1daqkW2ujpoc9jaL7wAK1aQE21l/BtzuOqZC/Bk+4m6/oUMDUPNnElL6yq8gRpIUrhsA3+TG09DCw8f2YXClByUWkPuylb2rglxSmUY+vTRot7y5Ykoh7jwKQR2sJXKnAxEUxMjFjVQk1xD+dd/odCbocW18nJU376IggLMhx9GzZuH/corqKVLsefNQz73HDf0KyZ2TTMc6kVNb0VU1SBzBiP22gt76lTIytKOVMvCn53HwLOuZFPVfHqkFHJk70MRhovYxRfDf/+rxwkBwSD255+jKiown3oKkZvbLpKqdetQoRDS66WwKAl1+EFEMzJQoZCORVAggiGEZWE9/DDG+eejNm6EkhK97sWLtRj52musPXAob/xuXw78eDE9l5bhEQaeSERHLey1F/j9GBMmYFx3Hcq2UdOnowDVvTv2QQfB+vVaOLRtjOuvxzjtNH3ehdACbI8esHatFmGl1Mc+Lra2tGhxNH4+OsZzxGnLeKZrV+T112PfdpsWVUGLmD6fFpFXrtTnt/3CVAlh1+WCMWP0pMa8eXp7LlfieoiPMwz9eAvhu86VzrcpezG08VuSos146bAdw9CO4LhIbJoJIdW2dX1xMT7u7pUS+vfXMScbNyb2WanEcVJK1xcXxuP1WRb06aMzkt1ufR1WVVFlpbDeLMB/4Ej6mxv1HQCRiN7P1FTtHJdS12pZ2i1/zTWIffYBjwe5996JQ9fUhP3RR5Cbi2huRqSnIy+8sP11++uvsV96CZGdjbziCkRqKqJvX+S4cbqZZ3IyFBdrMXwLxPDhiN69UcuXI4qKEKNHbzXG4dfPTgnNlmXx1VdfMWjQINLS0nZTSQ4ODg4ODg6/ZLS43AKqBWVXIow8DPcoDM8hmL4zEB0+9Do4ODg4OPwWMP3nEm3+K6gorqT/2y3bOKrYzzcVYVqiJvsWFpHqTfy9tV58UYtEHg/Gn/+MHDJku+sRI0fqDNe2x9Yjj+hGfID9j38gH3+8faxatmybj+Vxx2GVlSF8PsSRR2JcdRWxE08EINn0YpkmxyRlc2z+F1gRgRX5GllehajdiDIUohKk1yIQiZKiTHLDBrIgF1dzGcMb6zl/VQMk+UEkIVJSIDsbtXKlFj07RBgIW+EPRrGiNq0uSefqECkhC2SLFswMA6qrsefMwdhrL+SwYdgPP4wKh7VoaVmougpEWKGe3hd1V3+oOQijx+UIvx85Zgz2/vuj5s5F5ORgvPACx+Xmclz3MZsdUzsebxAXKeOu11gMwmHkhAnEHnpIi8SWRfSEEzDvukufp/R0yMjAqqhG2mEUEIvauL1eCIex/vlPLbL6fO2xIaJvXzAMMhet5JtDBrKsXyF//PN/6NTQJmwaRsKpGxcM6+ux//tfqKhAnnYanHYa6uOPUfX1iFNPTYjMH32EdeGFOt6hoAB55ZXYc+fqLOCGBi0wZ2ZqgTUpKXE+8vO1kFpVlXABp6ToxnZjx2qhvG9f7TJftUpHcFgW7LuvFmjLyhJCNiRcxKapneJ77aUdwmlpuoa4mBsfY7Td0SuljhnxeEAI3mwczVetfZkT6Ml5Da/gsesQ8W0EAoll2gR3AgHYbz+YM0e7jZOT9b7V1emJhPx8fWzy8/XYtuzvWNQCJcDjwQwHt47P8HggPV1Hu2zYoB3NmzbpRBcVImA3M6nuYCbtOw9/TRni7LNRS5fC4MGoAw+Ezz/X7vzx49trFp066fiYjtfiBx+gVq5EBAIQCOhmg22ZyyoSwfrrXyES0e8B6ekYl10GgHnvvdiHHYZavx45duw2J6yEx4Px17/q6zEt7UfF7jj88tmps24YBocddhhLly51hGYHBwcHBweHdpSKgGpsy5tUCBkA6cf0no7LfxHS7LqnS3RwcHBwcNhjGK5BGOkv7NZt9E538+yh2TRHFVm+REyesm2d1woQDmO//TZyyBBUPLN3y1pPPx3Rrx9EIogRI7BuvFELfi0tkJ292Vh50EHYH36oHx94oN5eaSlkZiKvvx5r/nzU8GEYmzbpfN8lS5DJyaTn5HD28tVYRa1g6vgsRRTCQAoQA+WSGC4/QxpMTnB34tPaBfiCjRzpbUZ1M5E1PZDDxiIPOQQ7GkVdeKEW7+KxCkIg8vIwLj6bJR+/RsrGKorqIgjDANmW5ev16qzbL7/E9noxrrgChg3TUQfBYFvmr0BUJYNIQQQ648q/BCG1yCaysjAeeQTR0qIFvWAQtWkT5OVtfWzjwrLHo926nTtDUhLWXXchjzwSefzx2F9/rccuWEDsj39E5uUhBg/G+Mc/KD/tUpIr19PiCtDqCtDNrYVSOnXSjt+GBr1uvx9VWwuRCKm9BnBrWj9ij11NtpmESzbrzOxLL0XU1urzdOaZANgvv6yFS8B65BGMZ56Bgw+GQAC5116omhqse+7BfvttLbAKAWvWoDIyEDk5Wpxva0ZHTo4WSmtr9TUzYgRiwABkv35YTz6pM61dLsSIEVqUXrcO1dioxeZBg7RLfNMm3SSvtFQ3nwuH9XZ79tSvz5iREOyFQLhcqO7dEV4vKu7sjsd4AAwZogVcrxe6d0cOGqQd6bUxEKAsm2YjmWy7HmhzGLvdWgwPBHQ9pgnnnYdsbMR2uyEQ0NEU6enQu7cWe3NyUCUlWvBPTUUNHEj0m2+RloWNwI7EMBQIVEIE93ohPx/RqRNy330RPXti3XyzzlO2QxgRiwyauKD0Mew/34Q5/lD9O9PSoms0TZ3lHAwiDjxQ553feae+nrxezIkTEX366Gs2Lp6D3n5Sh/i6jncEwFZRJHLs2K3eL7ZESKnPj8Nvlp2eXhgwYACrV6+muLh4d9Tj4ODwUxCycP/uWwAizw4Hr5PX7ODgsPMoFQbVhFL1oEDIFAzPGEzPIUizP8LshhDuPV2mg8MvhlgsxksvvcThhx9Obm7uni7HwcHhF4jXlHi3+JQvpNRCYHk5ABVdfExsvpgKu4LTPKdxsmfrCI+Ojmd57rnETjlFC4eBAGrTJkR+vn7t0ksRBx2kncvdumHPn0/shhtg7Vqsso3U+g0aU7ykFHUjJykLiooQWVmo5mZ4bSXixfkIjxuOHIowMzGbA0SsZjzBKMJOQbhMxPjxnLfiC855ZgmyMgx+gah2g5yPPWu5FiILCxGdO6MyMqC8vN0tK++5h07jxlFwyR+oeeRBXB99hrF8hd6xwkItFMaFt5YWvU+9emH36EEUG7OiCtHUhHHoJZgZt292jFRFBdaf/4yqqEAecwxy7Fism25CNTcjR41C3nhju9gsc3NRo0drcX/QIMx77kG9+SbWc8/pxomPPIIYPjzRWC4Y1OKraaI++QRj6FDq3/uS2yd+hx2JcdxhSfTsWq4zejMyiM2Zo5u7pabq7zU1uuHhZ58xaNw4Ys1u6D0AmpqQRx6JcdFFW188rg53nEmJ8HoRBx/c/pT96qvate526/riy8yYgbz0UqxPPkmIlLGYrqO1VX/NmIGKxZC33w7NzdiWpRsaZmbC3nvrnO/kZL2+yspEU8dVq7TwnJurBetQCMrLEfvvD336oL74Qo9tu6Zk//4Y996L/e23WJdcooVTy0IcfTTywgux//Y3/XNWFsatt6KE4PgNb1Ddks7e4cVkFKUjqht0zZmZiKFDEWPGYC9erONZqqrgs89QgYB2Tre2ojZuRKSlYdxwA3ZTE2rtWn0e1q5F5eQgfv975IzfYQsDlEIqhfL5EOEQSIm88UbkZZfpOJPkZOS++2I99BA1YTfVsTySPU14XGGq3Hl0yjNIfvlpYkeOZdaXVZguwcj9/AghsJctQ336KWLGDMS55yYmLUIh7E8+wYgLzYcfjqyoQJWUaGdyQUHivcLrxbj8ch1zk5WFPOOMra8TB4cfYKeF5jvuuINrr72WiRMnMnz4cJI6zn4AKSkpu6w4BweH3YSlMKZWtj92cHBw2FGUCqKs9YAAYSBEKtI1DJf3ZKR7b6SRv6dLdHD4xWKaJhdffDFL2xxlDg4ODrsK4y9/0Q3+UlJ48/gaNto6B/f58PMc7jqcVJm6/YWbmhCdO7f/qGbPRrTdni+EQPTv3/6aPWMGLJ4L9Q2IligZrYL0mmaaappRIw/Q4mcopDNmSyuRFS7o0Q3umA8ZGbgzsrDcuRCrQxYUaoduaytMXokMhyBkQ8yAcFSbZaJR1Pr1Wvw0DERqKuTkYFx4IeTlIQcPxg6HscaNI3XdOu2iPfFERLduGMcfj1q2DOuppxAZGcjTT8eaOpXoqy+zvnYdVZngS0qnZ+f+eJcs2coBbr/zTrt4b7/7Lqq2VgvobcdBlpej8vKw//UvVFUVVFcj994b47LLEIaB3dE5qhTyoINQc+dqN6wQer+rqiAzE7VwIQMPy+Oh5/clVFFLeuVqRPd9ITUV6777dEO4eExBc7N2FgNq2jQ491xEbi6qogJSUhAHHbTN0yxPOw0qK7Vwfsopep/efReKijD+9Kf29YuuXVENDfqYp6ejvv4a2zB0xEVpqRaF441to1HtKLYs+PJLPVnR1KRdwoBqaMA4/HDs+fNRVVUYN96Iqq5GTZ8OtbVaxM3LQ/TogT17dqLh3bJlGC+/jP3nP6NWrWrPKjYefRThdiPHjkWdcw727NnIvfZCnnYa6s03EcOGaUG/b19iF1yA+vprMrJ93DhwLWp9jXYuyxwIhxH9+yMPPBD5+98j3n4b6+239TmREuX3w8iROs7D69XX4ZQpGI88oh3b776rjwNgDBuGnZWJXV2LrQRWIBWXW0FKAHr0wPjDH/Rkx6GHJi6HjRuZtGoo5cZIsmU9pwxvYrBZCgJITuaxvy/n62lVAKxa3sTp+8ew33lHLztnDrJ//0RGOiC6dGlft5AS43e/295vu2742KEWB4edZaeF5iOPPBKA8ePHb/YmG3/TteK3JTg4ODg4ODj8otFZy606a5kQqAgIE2EUYHrHI13DMFwDETJzT5fq4PCrYe+992b+/Pl06fCh0MHBweH7UE1NqLZb9uXIkdscI/Lz27NWA6Fnifc78wgP7h+4+0h06ZJw2gqB6NkTFY2i3n5bN65LTdUNAdetQ3UKoEINYEcR6Ixkhc5JZvZscLv1LfxJSTqaICcHqmv0djp1YtO6Zczon0e3VSG6eySBVat1nEM0irBtMAQUdQNfK7S0IIqKkCNHIsaPx77rLuxQCBGJ6NxigKuv1i7sdesIS6gzIhgrF5K3//7aPXrkkcg2jcP68kusCy4g1tJEejTI/OEFfD4gg+ObfBwcdus85EceQW3ciDzuOO1ojeN2I4qLtUCKjidQgQBq6lSs999HeL3QqRPy+OMRXbsCIMePRy1ZAmvXIo46CnnggYi998Z+5x3sF19ElZbqGA7DwJoyBfvjj/FefDGeV1/Fqq0Frxe5777Yb7yhz41t66zfeHNCIRDjxmmX6n33ob7+GtG5s45F2dZ5DgQw/vxnlGVhv/su1j/+oTODlyzRcSunnQY1NajycuSECVivvAIzZ+pr8JtvEEOGYEyZouNATjsNVVmZaAAohG5QaJrIY45BzZ6NamlBHn00sndvxFNP6XPsdqMqK7HWrkW53RgnnYS87jod0fHppzoSJCcHMWgQMj0dOyWl3YktAOHW17JwuTBvuw3VlrVsnXWWFscBkZmJ/dxz+ncmGoX6ej2ushKqqyEvD/P995EDBiQOzsqViQgO24bUVOTxx+uJhdS2SZr16/XES0oK7VYuKRFZWZhPPI785z+1e/jaa1E334xqbsY455zNoyziix17LBXPzyAmoLxoKF/0KWBo/kxUMIhx9tksvrmifezShfUwZvPGfCI5GXn33VgffQSlpdjr1iFWrUJ0777Nc+/gsCvZaaH5s88+2x11ODg4ODg4OOxhlN2MUo1aXMYCJEL4QSZjGAMRRgGGe18MzxiE8O7pch0cfpVceumlXHPNNZSWlm7z7sFBgwbtococHBx+jijbxrrxRu3qBbjkknbhdHuc6jmVZtVMuSpngnsCPuHb5rjldRFCMcWg7GwdC/Df/2oxtG9frEce0Y7ehQu1gzaeFZuWjMr1IFbFQCgUIBS4IxZE6qBLFx2ZMHo0wufDfvJJvXxhITFTsrg4lRcvPIjC9TVc9upiehcVwZo1xBobiRlge/wkn3U+8sorYf16aG5G9O+v40FefhlZVYV1/vko24ZoFHvePOS552KlpbCUOvytEVizHPczj5I+ZQrGY4+1i5MsWADNzUjbRglBJC+L9X3yyS3NR552Cda//oX92GNgGNgLF2K88AKyuRlVWoocNgxGjcLw+bBXrQLAOu887SJevRrVp48Wmz2e9uMrkpIwJ07c7JgLnw/RNkYUFUFqKqqxUYuRLhfqo4+02AoQCmkR3jAgORk7GqOu5zCyH74HvvwSOXAgcoxuSijS0xFHHLFD15T90EM6dzvekK9LF/B4tBD9xz92GGhjrVmjIzLa4j5ESgrEYhgvv4x66imsqVN1k0AhoKgI67LLEF26IB9+WDuW583DnjYNuf/++voB3VTx8cehtTUhwnbrhjllCurbb3V2+D77AGCcey7WvfdCKKTjJ7ZACIGKxXT+cxuqtlbHW4AWqQMBHdsRb44YDuts6Q6o/TJRnSWssRBJKcjTT8e88EKsYBD744/1REPb8ZXHHw/l5bpp3tFHIzIzMY4+GuPooxMr/M9/ULHYdpvlyVGjGH9HOm++uhFXkpcxp/fF2PsA1OrV2DNmcHiBl/805gAwbJ9MRLeuGBdcgP3pp4hevRCHHoowDGR2NtabbwJgTZuG8dRTiC3+r9jmNfDee3oCo6AA48Yb9Z0CDg47yE4LzQe2Bfw7ODg4ODg4/LLRLo9WlF0HqgUhvAiZg+EaizA6Ic1ipNEDYRY7wrKDw0/EqaeeCsCVV17Z/pwQwrl70MHBYds0NSVEZkAtXgw/IDR7hZfLomfrSIzCQgDsN97AmjwZUVSEcdNNvL0+ytMLalHLl3PIqllcOv8tyMuDJUsQvXrpbQaDOgahpUU7aSMRqGmA7h5i9ynwgnwGxEwQbc5SSku1wHbIIaipU7W7t0sXRFYWctS+fFKwEUSEjV2yiI3eB/H1SprKS3HXK+qS3WzKctH7g3dJv/pq7CKxeZxFeTnWfffp6In6elAKFQggLr6Yiqf/ycJHb6WgvJG0pjBJ0SBp1dWoDRv09g0DVVMDzc2YsRgB06C7K5Nrj7uZQfnDAHTmb329FsbXr0fdeCPGgw9iP/kksUmT4L77MCZOhI0bUXPmaLdybi4iNxdMEzl+PPHYCtvahBV6C0QqcnExorwGceCBiJQUxGGHIb75BvXttzr6oKwMtWYNDB+OPOggLWK2tOh1nn02KhIh3BLh9eahfKqOY+BbJn+49QqkIX/UJaXmzUs4tFtbkWPGaAf3Foi999YZ0atXgxDIG2/UrvKvv0Z0745x553Iiy5CffYZ9pIl2A88gFq7FpWdDcXFMG2ajhQBaGlBdhDChWFoAbjj9txuxL77bv5cr16YTz21/X2xbdTcuYixY1GffIJIScE49VRUaytq8mRobUWeeSZq/XrUxo26gV9KCqKjmxmIDfwa9coImFeHzOmKMfY2AIwrr9TCciCAaHO4C7cb46qrfvA4b09kjnP8eX058NhuuN2S5IALVV2t889DIY4E+pxyNdagYfQbpLcrjz0Weeyxm+//xo2Jxy0tumHkDwjNqq4O64kn9O90bS32669jXHDBD+6Pg0OcnRaaAaZNm8Zjjz3G6tWref311yksLOT555+nuLiY/fbbb1fX6ODg4ODg4PA/oAXlGKggEEKpIKgWQCBEMkJmYriPw/Dsh+E+ECF+1L8HDg4Ou4A18VxLBwcHhx0hJQUxaJB2FguBGD16qyEqGNRiZUYGorkZu6YG+447UFVViGgUunZFffWVjkUA7Gee4YtLH8YOm1BeznSVzqULF+ps2rw81KJFiHH7o75boMUow9CxAkrp71UtGK8IYicorNPB/kZiWrYWhA1DC109esCMGbBhg3bLnnIKxlln8adwI5+WzyXHm8aQfXphP/ccJX2z2fDN5+RWNtHsc9FalE8g/AnR5gcBheHeD3fgBux//1tHV5SXa/F74ECIRLCnT6fg888YvqaJaq9AGQZp7mRobiZ25ZXIggLdKO6557SrtaUFIznAXjUSY30U2tpPqPS2eIJYDDIyUFVV2J98gvXOO7BsGSiFfe21UFCg3blS6giLLl0wrrsOecABKKWwnn2WSMEkVBcvKJCftWJM64KYPBnjn//UTue778Z68UWsW27RYr5tQ1kZcvx43Txv/nxE796I7t2R++/Pe3+Zyqcvr4dolEXz6lhT0kyP3jvXP0tt2oQ1cSL2woVaBM3PxzjxRIxzztnmeDloEK6//x1VUoLYe29UeTlWWwM6tWoV6tNPkcccgxgzBrV6dWJCoqxMC/xxkRlQK1fCDjqudwb7b3/D/vJLXe+ZZyJPPhkhhI7VGDNGN4wcOVLve1ERNDYir7oKkZGx2XqESEHleyE/H1x9NhOJRVHRLq87TkZmwgGvysq0c7yNnp4aZJvIvD3k4YejvvgC1dSEHDVK1/9DSKm/4hPbPyCIOzhsyU5fMf/5z38466yzOOOMM5g7dy7hcBiAhoYG7rrrLiZPnrzLi3RwcHBwcHD4YZSygTCoEEq1aGFZCP1PvTDaXMk+DFdv7Vg2uiFdw5Cufo5j2cHhZ4KTzezg4LAzCCEwbr8dtWABIitrs6ZfAKq+HusPf9COzbVrtcDb2qqdjatX64iJxYu1S1cp/dXSwglPTeTecVeCZdG/bJkWnaqroXNnrP7LiPk/gUkGxivnIt75GrVunRYSpUTYLahWGxYKwkMNVJILbySGW7p05m+PHvqWfq9X5+Z6XagunQDI8KRwYpeD2us3Lr6YXpEzePnzSdR/PY2Dw+kc/LuBhBt+DyqMMHpgRaaj1LXakdwWW4GUOv6gsBDq6hDfLaZfWleaoq2Ii88gNbOA2L/+pe8Y2bRJxwQkJWnHctv/Tqq6Gvvzz/V+jx2LSErSx8swdJwEWmQU0J4FrCwLOWwYas4cRJ8+Okv46KORBxygX586FevNN1CXlMMqBWkp2K4gstKHsm3k6tX6HPTogRg8WNcDWuxraNBxEgUFOus3fo6rqsj66DVyK9NwqwjljCDl0alEl88Bvx85apQWTw0DAHv2bOyvvoLKSkS3btSdPB6vLxnf66+jSkshKUlfK8XFiG7dvv/669cvkfncluFN3L2ensgNFpmZiC5ddJSI34889VRUOIxasEA3aNzOnfMqGtUN93JzdfQI6AaOd9+t4zIuv1zHbmwHe9asxLq+/RZxyim6Ho8H0aHhncjPx7zttu2ux5V8HbHWZwATl/+8zWtsaNANGcvKkCee+IPRNT8W0auXdpmvWYMIBBCjRv3wMl27Yjz1lL52cnM367O23WVSUzGuugr7zTcRBQXIk07aFeU7/IbYaaH5jjvu4NFHH+Xss8/mlVdeaX9+9OjR3HHHHbu0OAcHBwcHB4et0R9mwlpIVpFEoz7QgrHwII1chNkHwzUUIfMQMoCQBQgjzxGVHRx+5qxatYpJkyaxdOlSAPr168dVV11Fd6eJj4ODwzYQpokYPhwA+6OPUEuWoBoaUHPnarGvqko3lauu1o3L4o7flpYOKxHaNdvGyJLZXPXZk4QsGLNihn59wACMSQ8QTroC1rUi3ipDpVrU3H0LrR6Dzu98inr4YdhkIApNIkYScxbmU5BVjuX1kCq95PUcjHvsIbquujrUIFDBlVgvn4Jy34U58vytxLA0d4AHDrsZDgM7topww+8RlgtbVSLsSqTnQChZrWNDbFtHeHTrpuMbrr8ekZuL/dJLSCSp7mSMfkO1QOxyaXcyIPbaC7FuHUFTIFeWYLsNvKtXY7/9Nmr6dMScObr54D77QF0dFBVhXHABcvhwuP12YpdfrtfVqxfGtddCRQX4fIgtHaTNzQglkE95YP0mcDVB0AUb10IshnXDDRCNIkeMQN58M/LUU7FffhlMU2dRJydvfQHU17NPeB497UpaYyae6s9JmxNArVgBKSnY4TBi+HDEgQdif/UVsbvugvnzQQjKO2Uy/92H+eKY4Vxud6WwpQWWL9cTD19+Say6Gte//oXo2/eHr8OuXTGuuQY1bRqib1/kfvuhqquxHngAqqsR++6LsCzk4Ycje/bEvvxy7L//HZKSNhPO46hgEOv661Fr1+rc5vvuQ2RkYD37bHtOtf3II98rNMshQ7C/+UbXN3jwD+7DdtdjFOAO3LTN1+zXX6fiw1lUVYTwTP8rnQeNIKlT9o/e1vYQXi/G/ffDmjWQn6/zsHdkOZ8PfNvOYd8e8uCDkQcf/GPKdHDYeaF5+fLlHNA2G9eR1NRU6uOzbQ4ODj9vkkyC1Uf/8DgHB4c9glIxIAoqCkRRKtQWe6HQPbVthHCD8ILwIY3uGK5hSNfANqdyPoiMHXItODg4/LyYMmUK48ePZ8iQIYxuuwX+q6++on///rz33nsc2sGB5eDg8NtE2baOydji77z99ddY//iHzvONN4nzeHS2ckWFdjIvWaKfS0vTgmwspt2/Xm/CPYv+b+OgiiXaFWxZel0tLYj0DEQsF+6bC7UhgnvXsnLT1bzc9QAGnHkoF84ZiShdhvIE8afkkPPHv3D7px9w9EcrqMoJcES1pM+HH8IXX6CSk3Wkgh1DlEWxrD8iZzRiXHMNANYrr6DmzkWOHImcMEHve1MY8fgaRHMMjs1H1gaQb1ZgJf0LDAMxciRq4wbkMeMx/vSndmHWuPpq1KxZiMGDtTgMrLj8TOa88SjlhRkc2COF3scfxROLwxzwQTO2KRm0tgl3SwtkZaE2bUIEAqimJkhPx/i//2sX4kSvXojOnfWxikZR5eXgsyBHsuV/YuKww+DTT5GvfQNWMrQGwbChZ6F2Akej+lzOno2sq8P4xz8QY8ZoV/YZZ+jj8thj2C++iOjRA+POO7X72e8n0x0iM+ABuxZUsj63beuLxx+oFSu0GB+LgW3jXV5C/00+sqqamHrRSZzbvz/28uUJV3IwiL1oEbJ790TTxO9BHnQQtOVQA9jPPYdauFCbJEwT13/+k3BWP/igbmYIWH/7G+bdd29+nS9c2N60T1VW6vN35JHaWR4ftC3hvWM9N96I+PJL7aLeIt/5f6W6MsRT/1hBw3QXe63xUGS2Eo7G+Oj9Mo6/aNcLzaDzn+nde7es28FhV7HTQnNeXh4lJSV07dp1s+enT59Otx+4rcLBwcHBweG3jnYjW0AEVBidnWyhCLe7khEGAhcIE3AjjUKk2Vu7kWU+QmYgRABhdkXIQkdQdnD4FXHjjTdy9dVXc88992z1/A033OAIzQ4Ov3HsDz/EeuwxhM+HcfPNmztNy8v198rKhDs5EtF5wXHhMJ7x2tgIOTmQkqLHtDXl4+WX9ZhAAMJhLTALoV2n4TC0tGD6bsBa/hb28BYYEKMgo4UTMv7LE5uaufThhwk/OB7cftR5nehqfcEFz04nuaGVHnPCRCxBaV5nishFHnIIatPnqHC9rrdFYs+ciYEWze0XXwTAWroUevZEDhoE//4IOd2Psqow5tsIsxDsBuxQBcJtYLMSNTCCulRhJCXu4JIHHwxbODQfTlpH6UnDUY2NrHz3Pv46UzFIVUBfRbfSTdi9zPbGaca4cYihQ7E//xzRpQuyQ9SD+u47LdZnZaGqqojefjLWyWWQn4VRPwJjai7ygAOQ48YhkpIw7p5IbOU0mLsK3C5QQjeh698ftWgR+P2I/v11/raUGG0iO4A1ezbWrbfqaI81a6BXL8wbb0RecIHOqK6u1jm8ixZpkdkwEIce2h6zIEePxn7/fVRBgc5IFhHqMvQ+dq2LYtx7L8Ri2B9+qCcYmpuxnngCe8oUzL//HZGamrgW586FhgbE6NHbF6EtCxWL6QzrUAjrllswbr8dDAO74htUrFT/X1tXt9WioqBAC+RtrnM66XgVecklYBioYBDj3HO3vd34OlwuxNix3zvmx/LcoyUsnl9PRBayODaWywJfMCf/IPqmpO2W7Tk4/FLYaaH5wgsv5KqrruLpp59GCEFZWRkzZ87k2muv5eabb94dNTo4ODg4OOx24tl6tHskrLavLZ9vyy9EAVHA1l9tz6n25WxQdtvjGOBqW94GYSJwg3ABbpABDCMPYfZBmj0RMgchsxAyFSEyEPL7u0M7ODj8eli6dCmvvfbaVs+fd955TJo06acvyMHB4SdBKYV6+23U6tWIsWORQ4Zsc5z14IMQiaBiMawXXsC8887218QBByDefx8Vb0QXz1zeZx9YvTrR3CsSASmRjz2GLCjQzd86dcI44AB49FFi//439gsvaIfu/7N333FSVecfxz/n3Dt9e4VdlqWDgKI0FVFQLNi7MXZNTIwldmPvxhKjJmpQE2P7xaixRaMxauyxF1A6SK8LLGyfdu/5/XFnZ3dpAi7Mwj5vXuveuXPLc2cG3P3OmedMmeIF1cEg6tBDUaWl6H9/jat7gH8G2onTGFJYKs6YnC+YVzCBglsGEU1MJLj6S/wffMHo2nqaQpoa5SO2OodlTdUUFAbJHjkIq/xWnAk3YdwGdMMg9PBUe4PGxrYXnmrzYdasQelSlC71Ji8sUKC8tgLmxgNxVz8HfbIwocm4ia/Ri4txnnoKVViIPuMMVKTlZ6pcf4SFjUBtLTlxyLJDdMOh8cIkS6uK6fueDV9Wo8r6oMaMQeXlYZ12GiaZxFRV4cydw/eqjoLJX5FXXw9ZWag1a3BGNILtwuJFJH3LUdNGYCZP9kY+9+6No/+Jc3EW+jINrkYV7YL+yU8w776bDvj1+PFtJpxLv06aQ23H8Z7H1JxZ6vDDMbff7vUznjnTe4MAoK4OlZWFeeEFks8+iyouRv/ud6iGBkxpKcFrryRv5reoSISKI8+B+fOhshJ96aWYsjLMrbfCd99ipn2L88Qu2L++EAD3n//E+ctfvHO//Xab12Fr+vTTcT/9FOM4qF69vFHKkyZhBjfgHBdFP1CLUbWoky5dZ19VUeH1H//8c9SgQd4bDYAqKsK6+ur1nm9bise9N3P8YT/xobvy7sB9KO8e4eCju2W4MiEya7OD5iuvvBLXdRk3bhyNjY3ss88+BAIBLrvsMi644IKtUaMQG9Q2GDKt71nf1luzkq147M2xiXVEHfznTgYg/qfBELR+/DE32aYe74eezx9bRqaes0057+bUtnYIuqFjrO/xNGCag9SWdWZ9223wOG7b22Z9595Y3a1vN3+1Hp271kjdDQ7cVS3HNK23VevWlN50fdelWk6iLBRWq5O2+q6at/MBlhcYKwuw0SoMKoxSYZTOBZWDUj5QfpRVgVIRLzy2ikDlonQxSm3s76AQojMpLi5m4sSJ9O3bt836iRMnUlJSkqGqhBBbm3nrLZy//tW78fHHqEceQRUWttnGee45L2iMxaCiYp3etHU6wuPdz6dHvwJGWy+TVVflTb43YAAmLw9TVQX5LtgONMS8CfBiMUx1tfcTWCKBHjcO3b07biAAdXUQDnsja/fYA7s53CsqQnXpgl6Tje37llBeDJ9yObR4GUvr/oXrqyFX1YNO4nQ32LtD5GMXnWd4+cS+FBfUYkZGiRdPwD/8WvzHzsd8/DFEo6hUm041ejT6o49wJ05EjxyJGjkSAOunP8WZNQvT0IC+4gqYNw8zY4bXruHdT9HvzML0zcKMyMet+TfOA894gXk4jGlowL7iivTjdfFOJ/Do7NdwTTFnPPdvmDyZfhE/jTXdsQt9+N6ZBIvAnfEuPPoo1kUX4d5xB+4772DmzmW5irLGjnHDiYO40Y7RO6sLar/9UPXvYagDy0bVBlGOxrguzksvef2ix8+D4fm4L+wBn1XjU6fhPvUcfPSRN4J6ZDcSpS/iNqzCDp2OmToXAD14MNYee+D27w8LF6KKitDnneddzMyZXu/oQMAbkZ5IeIF0Monz5JPec7lokTe53syZ+N9+G4DsPzxI1qxZqPJyCAZxzjgD09Tkne/gg3FWLMEtrwXbxUx9Asucj1KWN5q5+bX77bdekGyt+/OsKinBuuIKnOb5vJTy+iw3zUP9YxF834DpEcYU+NbZF/DC5VTA3NGc9LNePHjXdJoak1x07SCG7l74wzttgvq6BNEmh6ISmVNFbJ82O2hWSnHNNddw+eWXM3v2bOrr6xk4cCBZP9AbZ30aVx2JHd9YCVsSSG3Ofj/Wxs8TUxYkF2PcFduwno708ektfR7Wdx0bO9Z6QqD13r+1/fjztN8r9wdqibuEX60CoOa++eDT7XfsdrG+cDHTr+2tef6WY2/aa2B9tWzKurYBrgFQfgw2KI1Bp7bRqftTy+lQVbVa791nlBe0muZANtXCIb1vm3OvXY9utb3tHQ8fRtmpY2nW/nttNhZCtzmPSh3Hq80oP6RqNKrlGr1jWi23lU7XblQAQwCjmu/Xqe11ajsbV2VhVDDV4mJzxcBUgeP9Xexn9SMok/QJ0emdffbZ/OIXv2DOnDmMSn3U+X//+x933nknl6T6lgohdjxm+fKWG/G41y95raDZ/b//80LmpiYvTKyoIHn66d7EYPvsw7QH/sOYzz6ktGEBbjwKuT5vZGtTEwwdCrPfx4RTI4PLDNaHH+K6rjdRWHk5ZtYs3NWrcV54wWu9kOo5TGMj5t//xvn6a6yhQ9EjRsA552BWvExtzxDTzbf08a9CqySF1ioiOoZxXFTYoHxguoPKBfcwTb1vJ/YrmkIwVAAmjrP8H/DxLFR+Pmr//dPtwJTPh7r6DEzj0zg6glaNOB9+RPLhG+Hd2ajS7l6/5aOOAqD2m89xHnuEsC5Hf7wcPliD0a94E6dlZ3sjpCdObHm8Fy2i8P33uaK8G7rfGJJdp0N1I+TkEPlbCHN1X1gyCVw/uAnM559jJk3yRueuXo1ZsoRcHHKMy6mvzcJXFcfMWIrp3h378J/gJufDzt1RTy0DeyFKKcz773u/6S4qRv0yjCkE+5hfwnkfwqxZ3s/FDQ0kD5uF6ltIMvpv3C8+Qv++znv+j94P85MQ6pET0Mt2Qu86DJWdjfvOOyTvuce7RsvyAmaV+rk81W6C+npvVHgiAV9+ifPMM1gnnogKBlE77+w9JlVV6ZA5bXQvWDwZbBtTEcNNTsHy7YIeMQInFTar3XZbb8jcTO++O/zyl7jffIMqKPAG/PzfAtRrK8Ek0fUaXvoWBh+1yX9ftqYP/7uMl59ZQHFpkF9dNoDcvPW3BeneM4s7Jwxv13NP/LKaP/52KsmEy6HHduMnZ0h7WrH92ezfjM866yz+8Ic/kJ2dzcCBA9PrGxoauOCCC/hr87uwm0ApnzfKawf1bfJzPrVslilni/bfktBx60fsmxe2be64TBdwlVrPWweqTcC07gfcFU6qvvWNcW75/uPrb6/H2GxGKRs65+ZeT7OAD/6WWr7AB7H1/DXc8HWue0971dcyprX1mNrm53TTz7uhY2/6tuvWbTbjCD+05bqv77bXu8H9VMtWzZx0WGrWes2r9HHb/p1QuLQ81kmi6bC3w9jQIO0dWJAgl4cu57jAcZkuRQiRYddddx3Z2dn8/ve/56qrrgKgrKyMG2+8kV//+tcZrk4IsbXogw7CvPce7tKl6JEjYX3zHzWH0cbAqlW4Dz0EOTmYTz6Bp55i0KoaVDwGxvsZ0TgWqkcPdH4++sEHiU04BvX0d9CUxPTUmJUrUPUNXn/kpUtx1qzxRsU2NHhBdn4+LF7s9cnVGvPMM15gDTB+N5w1D5OI1TIgXkvC0QS1S47dRENSEfI5KAevy1gONB3qY7FVwIcL8zimxMU0zMUsqEff9B2u+dy7rNdf463hXfliYBHHz1X0rvoL7qgmKMvHzJqGs+wFzIHLUTuDdVsNznnnoV9/ncWNK7h2xhN07VpFt0aLs+Zno6tWglntXVsi4Y30Pfhg7zz19Ti/+Q3uypUwZQpOJOL9PNyrlxeY6iJ8/gtIDJkM33/v9UwePBiVl+dtFwyiEgn8xvtk38hpKwkngRwNs2ejfAH8hz3kPU7Xet+Sl13mjbwG1H8X4NvvetTwQWirkKTvM689STjsTW7Xx3iTMwLukqmoJRYkErj/vh/3yEF8MqWU777LYZfG/ux7UDbuU095fYy7lsCa5VCWB6EusHAJ9OiB/atf4X74Ie6ECeDzQUkJ5ptv4MQT27y8VEkJevx43DfeQBUUoA8/HHNYOe7fr4GQhTm2O0p7b37oww7zenrX1KB23/0HX99q/Hj4z39wP/8c9803vTdH/Pnec+MoyC/4wWNsC40NSR794yxc17BiWZSX/z6f03/V94d3bCdvvrKYZMJ7Xf37pcWccHpPmYtFbHc2O2h+4oknuOOOO8jOzm6zvqmpiSeffHKzguZQwfOEcnI2t4TtxrU1e1Nn6ihWW2fGUSG2VNBygO8BqLO6E93IO9Bi6/uhMbobI8/c9i9BgpXuSsp1eaZLEUJkyCuvvMLBBx+Mz+dDKcXFF1/MxRdfTF2dN4pt7Z+7hRDbJzNrljfpW+sJ/FJUSQn6nHMwt96K+fprzAsvwKGHwoIF0K0bKhJBjR6NWbbMG/EcCnnHCwRg4UIwxpsNwrg4aGylUE4S+vZFHXQQVFZijToe98uFmMYG9AwbFY15kwFGo97o5WnTvJA5N9cLVPPyvJHVwaA3qVz//ul63ddfwBRMJT87TrQghmMZbKWxlUu2nfR+prXB5IA5WFGXsPh2tWJU6J/ULFtNXqIRsyqIb5LCxL6AZJL4l59T8HExA3sVEhzyPU75GtSLmuTpBcTq6vEHE9AIpguYPmCWLsWsWcM7Vc/ypp5Jj7ERfl05l8X1DZQ9Fsd6N8sLbo3xWoQ89hhmn33AdTG1td41r1rltZXw+6FLF9hlF1Q8TvLcc1E+HxxyCLpLF/TZZ6MKCrAuvBD3nXdwZ89GrVqFMS7ZMYMOBr2RxLbtHWft53fPPTGffeY9fz4f7q2/895cOO9c1OU/gSxQ385BDRuGr/8AkryMUiHUpyWwaBJgMMEkc2Zl8+iEASgd46vPZ1FcGmRAYSF89BGmZglYDkRroSIL3WUE1k03oYcORR99NEljcL/6ymuFsoEe4NZ556FPOw1CIZRtY1MBF2rcxAzUy0txXroAt39/rOuuQ6dGQm+S5csx8+alXjwuqrQUdt0V8/33qNGjsX7+800/1tbW5pezbRvydu0WYvI33sSIJV2DEjKL7dImB821tbXeBAXGUFdXRzDY8vFex3F4/fXXpW/cegQIyEehRYcTUMlWy4Et/Ni/EKI9OMbBp3wU6I4xkkMIse0dffTRLFu2jOLiYizLYunSpZSUlEjALMQOwhiDef55nCeeAMdBH3881llnrbOd+/LLUFMD9fUkr7kGrrjCC3h33x3ruutQY8d6LS2mT0+Hv6xa5QWciYQ3GlcpbOOCZcPQoeholORFF3lhqlKoVQWoHoNRRVmY4jovXAYvILVtL3BNjdpl4EAv/H73XdSuu6LPOIN4/YMkl78Atd9DHZC3gqCVB4VhcOcDrpfNpT6Z5nVgM+TbUYblrCayopo8NwFLDXHiuL4swg1x3KRDnASh6tUMzqkju3sD6j8GliZZWFPPvJ8uY3jIIStLgWOg0YKIJnnWSXQ5tYaEazO2exWFwRgx48c9Pg7JRtQqUHOCqEYwX3xB4qSToHdvr41GY6MX2jsOuC560CD0L36Bc+aZXuHFxRAKMpnVrHjrCfbI709kl6HY48YRr61FPfQQKum2tKlITfanDznEe97nzfOeI6Uwzz7rhczz53tvEmRl4X7+OckTluF++gbs1oT+9V4o/wD85Wdhm1MATTLrekzPWgC0Xkn1O01gtDcZIlC9Mob1m99gPvwQY6+EEgtWxMEk0Lvv3iZQtu66C/3RRxAOe+0sNkCt9f8eO3g4Zk5vks/9xruuyZMxb76JSrUtaebEPsB1FmAFxqKttSbEKy5GlZVhliwBpdAHHYS69lqIx9tM0Jhp4YjN2Rf245/Peq0zjv5p9216/p+c0ZPsHB91tQkOPkomFRTbp01Ol/Ly8lBKoZSiX79+69yvlOKmm25q1+KEEEKIHV3CJPDjp0BJ0CxEZ1VcXMynn37K4YcfjjFGRjAJsQNxnngC98UXMVOnen1yXRe3pma9QTPGYKZP99og1Nd7rRSamjBVVSQnT/ZG586b54XG8bjXw7lvX29dba23vTFe6Onzofr29SYAXLnSCzgHDAB/GFXSA3Xkfqi9yzB/+xxDBJ56yhs9nZ8Pffp44V9DA3r0aPS55wKQaHyceN3NEFgNezmwLAJJIFADbhXN6bKqBqJAV2+Vegd8n0GPfjFMX1BRMDYEkwnMr1fj/NkmvjpJqAbKl9RSVRwh/Kck1hSDKYcu0RjZ2dUEyhoxloG+4J4K+uMIJlbPXl8s4thduhCpcgiUG4rW1GN6JHBOApVUJF9KMOvzIJUrY/i//ozg559DThjiMVQw6AXOySTu++/j1tfDlCle+Jydzcr5M4gHkgxasIr5vbvRv3IX9KWXohYtwgSDXs/srCzIzvZGD++1F+63b5O8/ByYV4PqPRA96gDchgZYtMhr5dHUBAsWoE48DPPHp1HvL4fFtRCfiRnwMokzFuA75UYArKOOwpk+HTN3LjRohr20kIEBzYz8bHr2zWbEXkWokI11442YB2/FOHNwb9sJ3/6/xcreu9VLK4njvAV7OliBUal1BjN1qjdavkcPnMcfx331VRYUBfnol0ewd9+96ZVd5h0gHG77Wl0rHE7G3iFRf6/3mo/9m0DuIyjdso3y+7Huugvz2WdQXo4eNMi7w9fxWqnutW8pe+1bmpFz+/0WR51YmZFzC9FeNjlofvfddzHGsN9++/HCCy9QUNDyC7Hf76eyspKysrKtUqQQQgixo3JwsJRFtpKRi0J0Vueccw5HHnlkelBHl/V87LqZ42zZ3B9CiG3PVFXhPv+8d6N5MrZQCFNdjfvxx6iiIlSrQVxq112htNQLIo3x9kkkvFB5xgxvxHFjo7dxqkWD3mUXTEmJFw6PGIH5v//zgmrLQo8ahfvPf6YniFOBAHTrhv7NmSRKHsCYJtRpJQRy7sOccw7MmIE7fz7m4Ye9+jE4vIfT8DlW4ACcxHeAC1qBpSA3StLvYgUdL1BWoD4F62FvM/dQcEeA9WTqAmeAWweqGPCByQbncKBHEnsgMB9Cixx8y5I05ATI0VHQYMcMuZ804Y8bVBOYYjC7xjFv/Q/8NvQI87u51Sx+10/xwEYCXZKYkNcBwRiDsxMkvlQszfPTe3kTrgKl67yJCuOpx94YmDcL07gIFdRQG4fVqwnHGynO8mPHHRJNDbjffYf7s595z8ugQV4oHYtBOExywq9RZb/A/e1dqO+WgAIzbyKmS2/vOdEa47OhzMLskYd1/qmoEx+FafWwxgXjglOLeeZ1OOVGjNtIYsBLuPcmsE6th4WrsWtquDzvIRJPvs3yu6/my5O/Z8HxB3PsCZcTGDUKQxKVk4ta6xOriYY/4cTeAsBNTMKffS3Ofbdj/vs26Aj6+BNwX3iBldE1LF+yhKpnF3PVwV/wl71uJtsXRvXogXXeebjvvYfq1w+1//5tX+vJOS3Lbi3GXdUmaAZQubmoAw/cor9LQojtxyYHzWPGjAFg7ty5dO/eXUZaCCGEEO0gSZIQIQIEMl2KECJDbrzxRk488URmz57NEUccwWOPPUZeXl6myxJC/FihkNeKIh73AuT6eigogHgc57bbQGuss89GH3EEAHr0aMygQZi6OkgkMP/7XzqgxHG8cLN5xHJTE7pbN6zf/x6lNSYaxX3oIVylIJlEDxyIPu44VLduuDNmeG0cVqxAH3sspnIVprEJAONU4SZnYfmHws47o3baCfe77zCTJmGOyiZZ/hZEwYm/i7KGgGkAXLA0bk6iZb4QF1Cg304tA/oNcCPg7gTkgpoBygDzgSIgAb6bQS0CHQdTBvZOULG8kWQumCio5WD3B2WBmgeEQa0EdwiYQhe1Io715zhqaJAec+rhcyAI7h7gHufVor8B2zHpoFkZUGsMbhaofLy2GgZojGOq4xAF5QKWTag+SqCuCaWg29I6Ynk1uLuWE/x0DQofjO4Pc6pxu63BOXIpfHkxjHWx3gKVALISmJkfQlYxlJRAfRXgYk4rJNF4O9bOx2LenoBxU60N67y2J05iCU70KZzYezA9jpm5AFVnvJYoWmN+ez3LpnyMBXS992lub9qNnx00iqnMojiZz7DCln7aACY5I73sJmeSaHoF563bvJ7hKh++6A5a0+REMaaOqG8lddFvqKr/lOz8/QBQB+6Os+druMmXsRvj+CLneMc2DqrVXCPaNxhl/bi5R4xbjZOYiLZ6oe0eP+pYQohta7Mbs06bNo2FCxcyevRoAB588EH+/Oc/M3DgQB588EHy8/PbvUghRPuKhS2OWzI+vSyEyBwHh2yVLW/gCtHJDRgwgAEDBnDDDTdw/PHHE177Y8pCiO2Oys7Guuoq3FdeQR9yCCYYRFVX4775phceA+5HH6GPOAL31Ve9NgannYbu2hV69iQ5fjxMmuS1Wygs9ALrmhpv39690bfcgmo+zgsv4P73v1BVBYsWYQIBnKuuwvrTn9B5eTj//a/XmuOTT1CHngFKg3FRKtImyFO2jXXVVQAkGiZA9HXv+M5qlPM2WL3AmQ/UowCVxAuWDeAHUw5qFpgwmL2AXcEt8oJbM9ibHJA5wC6g3gT1v9T+AcAG52Qwa0C/D+ZkwAf6WVBf402YV+NNBmj9zWvBQQSoBVUT9XpGAyYf1HdgTQW3CaI1mqm7hPmqRzZjptV4KYjPm6bG9ARTA5R4NaqFqWPY3mOhkkk0YBSEw2twrwQrVEtivxC6Khc1LIi6biFumYtxXSgFeoB7IFivg7u7japuRCXmoxocnBMNZlwMkzURnQzh+/UzOM++jpozx3t+kg6majrxM4fgXB+ArJXwURJVATqqoTGGyoqgP/ofwUCMZMKQtyBO5NUXWRa6kG5Fdfwzuifv9/op8yZ+SJ/GZRx3sI+cwDLWxFdj6TyKco8h0fgIqrcX/htTgxkUxT1IkfVaE5PtPD7fo4ghOZpy/xzAC5qT0ddwk/PSy1bgYJTVnVjNOTixjzFuE3ZwHL6s61Bqy3/HNG49sZpLMO4qUDaB7NvRvgFbfDwhxLa12UHz5Zdfzp133gnAd999xyWXXMKll17Ku+++yyWXXMJjjz3W7kUKIdqZUsQiMgGgEB2Bg0NEdZxJUIQQmXXDDTdk5Ly33XYbr732GhMnTsTv97NmzZqM1CHE9szMn4+ZMwc1ZAgq1WpSDx+OHj687XY1NZhvvgFADRyI+/HHOI884t33wQdYY8dCfj56//1xc3OhoQHrwguhuhrnuecgOxv71lvR3VtNVNbkjVCmocEbnmsMZtEiaGzEfPppasgumGnTsOpKCeTehZucgfYNQ21gQmIrsD9O7H2MacDy746b+AKceUDMq90AVurLAArck8EtBnbC69FsA9lg/KnlBaA/BfUUqFV4vZxjYAq9L1UNpj+YbqCCXuBrTgH9Oqg6MA6QB1SBuyuo2V5YSm2qaNcb8Yzfq8kCfP0MBdckuPa38zDjQH/pbWeKwD0ezO+A1aCWgX4E9GdgsgAnirHA7JK63RNUxLtOcpowa+agHrRwdnP5foGfyvwoVjnQCO7R4K5RxI8yhP+6xntKggpzoAvaQCiKem4p7htneT2eBwygsXEF1vIVxEL1BPdOQAOQBZwCzv7grHRQb0DNrOX4GExhVj3ZTVUkTrU4e58ncI0iWu3npKb3+MfXizjznXnk7NaImeJjeq9y6twkkxpKOch9k+6+KtxLLPjMQts5mLErQblk71HJ0bEl7OdGKAtq3l2R5N3pExhROICjS1u1eVMWSkVINj5KsullMN4TkIw+jzH1BPMfQ6nghv6qbJTrzPNCZgCTxElOlKBZiO3IZidNc+fOZeDAgQC88MILHH744fz2t7/l66+/5pDU7KpCCCGE2DSucclSWZkuQwjRycXjcY4//nj23HNPHn300UyXI8R2x8ycSfI3v/FaERQUYD3wACo7G3fiRNwnn4ScHKwLLkAVFmJdcw3mv/+FcBg1ZgzmlVdaDvT9996EdDk5sMsu2LfeisrLQ/XuDYB19tnrPb8+5hhvwsHGRkxWFvj96D328CZ6GzwY/vtfAFRFBeTmou1CtN1/vcdKH9PuSyDvzxizBqW74cTew4l9ALTqFa/W+u4DDgaqgTVAIRCkJXnIwxu9nAvuKFDft7TbUElQ74L+AJLXgmnOv0vBLQN1CagKUDFwx4N7AqCBN8H6o7ceDTTiBdgWmCAEd3PZN7cG7gYnCe4bqdB6lDdSmQgQAjM51UajG7hHgfpvKojeBfQUb2S1meeNulYFYPomcXOT6N9CaSKOa4MOglqdau9RYvBPTeCGQdeCOyA1XWIh4Lqo56fi2Isgu4Da2tXMy3Lp08sheLXjPU7N4xCygEqvLpMHkdca+HTmfPa6swl3jkF1T2Dnev1KfAVJTDUcZ74lfIoDSbDiMfLdxfgsm+GRBlQygtFrIJQNYy0aA5ezuPZFsnQtpdZ8wsSJ+BWLE0cwedUrlBj4eMn/GJB1DgPCR+Mm52IHxqOsItzkLFD+1DsAXq9uN/EVyegr+EIntHk9GZPAuCtQumSdHtJtXndWD5QuTI9otuxdN/YyFUJ0MJsdNPv9fhpTExC8/fbbnHbaaQAUFBRQW1u7sV2FEB2EHXM4/6LvAHjgvp1JBqR9hhCZ4uAQQUY0CyEy66abbgLg8ccfz2whQmyn3IkTvX7KgKmuxsydCzvvjHvHHZiGBm+bv/4V6/LLvUn5DjgAVqwAx0Htuy/qP//BLFzojW7N9kaOqiVL0MOGbdL5VUEB9j33eOdfuhRWr4YB3ihQvf/+Xm/oZctQe++NsjcjBmjSKF2ECins4L7YkZ+TbPgDYCCJlyis1f1LvZIawTwCiOMFpakRzzjg/gSvVcUsMMOApBc4E/CCX5XEC6nzUvvGvXYZ5n68Ub4j8EYs+/HabhwEZg7wEl7AbVJfLqgsMGd7xzIhUA6YU1OTANZ4x3CaUq2P3wDTBIwGwuD8H7ASqAf9DlAMaoXXEsM5PDW6OQSUQmRnl0QuuNqbK9F+Bax5oP6deoxioEeCmwN08Y6JD4jXgq7FOVnjDA1gBVPXbKeuj9TjlhqhTX9QvQx72Eu9nti5oLJT2xvQEXBDUGwnIAEqDiQgGKmlWIFr8DY2isZkAL+OYuovxU7mErAbcXUjWilM8htKzHecWQLKOLhLFLGpz/Odk0+yxzB2zlsODX/wWq/oclx3WarYOMaZhxP7tE3QbNx6YrVXYJyFaKsSf86d60wWmH796CwCuffgJCahrZ7So1mI7cxmB82jR4/mkksuYa+99uLzzz/n2WefBWDmzJl069at3QsUQrQ/K2kY9/QiACbcPZikzEEmRMY4OOSpvEyXIYQQmyUWixGLxdK3ZcCJ6Oz0kCG4f/97ekSz6tkTAJNItGyUWjZ1dThXXIFZtAhVWYl1551YDz4I9fWYzz7Duf9+MAZ9/PFbVIvq2hW6dm1b39Chm30c9403cP70J7AsrEsvRY8eTSDrapLRN8CZDf5EaojuWrLwRu3q1Be0hNFBoBteqNwXqAZ3DDAE9FRQDV7rDBLANKA/XugcA3ZOfQ/h9cRoPnYuuEeAmgN6GrCMdLBteuH1TY6nakhNVMgaYAGYStDzQU3yzu9cBAxMtcooBvKBOm8ksYnhtQMZAeztjW7mQ3DP9gJtX54XYOvleIO+u4LReIFyEJyfpo6ngDxI3p7qCT0Dso50GRxo8kZip2o01joZPiivN7WKp+rrlWpholLXq1tuq4B3bqNbniZLASRJuoqgTnjHV1AeWEWd0/xLoUltm8TSeGF7jSFYESMrtozZq9+nya/x60DqpK2KJnX86H9Ixv6LHRgHgJP4HON4DbBdZz5u4kuswJi1r67lMnUBdmDfDd4vhOi4NjtofuCBBzj33HN5/vnnmTBhAuXl3myi//73vxk/fny7FyiEEELs6LJ19g9vJITodKLRKMHglvW43Npuv/329ChoIQSo/v2x773X69G8666o1Khk66KLcP/yF69dxemnA2A+/9zrn0yqr/NXX6H32Qeys1H7748aMcJrrZCfn7HrAbzg3BhIJnGffRY9ejTx+tvQVk9cY8Cdvk4SagzeiODZeEFw8z9hzWFoBC9EbsILpHPBlAAWOA7eSN8lYD0DZiCYZXijeW1gBl6AXQCmAi+0TeKFz3FwTwczHaw/ebeJgDvQOzZBb/5D/KRHWZv+4OaBVQ5mpHcoBuC19ihL1ay9yQWTN4GqT61r1XuaXmB2xQuWG7xw1/TyJhlUs8D0BpVIXXN26vzJVE2lXp9oBoPypdp4hMC43nnXnidaKW9SROtB7xjuYV5rj7ZPQOpxNqm4OBXGtz6UayBhDDZgq+bw2RCxYm22aw6hafKu1/hAJ6DCbsBOn6B5uPXaqonVXITKfw7LtxPaKm8pDIWyytazjxBiR7DZQXP37t3517/+tc76e++9t10KEkIIIToTpRRhFc50GUKIDsJ1XW677TYeeughli9fzsyZM+nVqxfXXXcdPXr04Gc/+9kmH+vKK69MT+K9IdOmTWPAgM2fZOmqq67ikksuSd+ura2loqJis48jxI5E9eiB6tGjzTq9997ovfduu11ZmZcaGgNKeSOQW9+fm7u1S900paVQXQ2AKi0FwDhLvfvc6vXuosALlwfiha+alvAzmbrd3PYCvIGw2XgjjKcBXUFZ3kSB6glQ8722Ge5PvT7JpgzcQ4DF3ihjpUBNBiJeuw61Atw+qeA2C0ypV4ZK1aE1kANu6j1+TapOH3AqMB0oStWVAAKpEcJ5QOppMW7qeCV4o6ubW1ckgSrvWt2xwDgwg/B6RjtAObAAqMQLx1t3L2wdLG+sq+GcVL/qBV5bDnMs6RRZpUY1Y1KrjBcqmyTo5uQnta1fr31g8CmzTrgNeCPQV6V6YGdBKGDQ6e1M6mJ06kFL3eGuwJgYsZpfoX17Y/uH48u6ApP8Fu0bhrb7buQihRDbs80OmhcsWLDR+7u3nvlWCCGEEBtnIAuZDFAI4bn11lt54oknuOuuuzi71aRfgwcP5r777tusoPnSSy/ljDPO2Og2vXr12qI6A4EAgYD03hJiS6iddsK66irMN9+ghg9H9e2YoZv1m9/gPvMM2Db6pJMAsEMnEqu7FVi98Z01LcNok0AtXkuLfrS0vKDVcj7gA/2mN0rXuQz4xBsVTDdwD06Fq3O9EcvuGEjunBpBXAvWv2kZffxkqjdyPcT8CutzSIwArQz+1DBdhUm3kzAWKBcvJ/WD/hRYAO4Q4CC8LHUNXqjsgloC9PW2pQAvkI4By71gnK/B9AMGpa7dTW1fC/H7Nb6jXFR5atSzn7YtRlq3IlnfaPHdvVHS+jVv4sJ0rmvaPqwmFTonayExV+GvNNgR0j21jfFGMhtIhcbNo4038FwWt5S0vizaE0hdcPOFOLiJGZjkXJJNf8YOHEog949tejO7znISDQ+CacIX/hnat/lvfAohOpbNDpp79OiBWu/bXB7HcTZ4nxBCCCHWJSOahRDNnnzySR555BHGjRvHOeeck14/ZMgQpk+fvlnHKi4upri4uL1LFEK0A73nnrDnnpkuY6NUYSHWeee1WWeHjsJ1VxGvuQAvYd0A0/JN+fBGA0fwRg5Dy+BX1dLiQXUDN+iDbxOYXOBgMCd525p6cE4APRFMIThHglYK9aHBeg5oArOLwv2lD/VmHLVMo2ZbzK8qp+KNZTSdrlE9/fgHWGBsb+hzqvuDUq43ijgnVasLeqrCHKYxON5Q4VXGC8On4rXw6EVLQGwBq4BpoN4H91Bg11bXGcZr1/G3POpWZbPos9X0GBqlKjdAj9IGfM2pzNo5b/NI8FZ3mTKvRvcAMH3abh41OQSobTMq2R+B4NMGsxOYPYDeoJvbdECrkcm9gbl4Q69bs2g7HF3hBcqNrMvFYHCMwTWahPGT5cvBsMa71/meaM0vwcSwAwfgi/yCRMME3MQ3GLceJ/4pgdz7sPzeBJjGRInX3Y4TfQ2lC/FlX44d2H895xVCdCSbHTR/8803bW4nEgm++eYb7rnnHm677bZ2K0wIIYToDAyGkAplugwhRAexePFi+vTps85613VJJDYS6vxICxYsoLq6mgULFuA4DhMnTgSgT58+ZGXJpy6EEC184bNI1N+FcWal1tigIl4anEimR81iWrWD8NGSPiRarVPe+GL0LqgCYM18mNcElTHMTngjiRtAv+fHnN4Pd2QSFSzA1gGMswz9v++9XhahAHpBBdaLI+H9ibjLV6DitQzoUo9TBfy5hJziCszvuuIW1uHGv0bpIli9GBJRKIqCPzUSuQ6cy/MwA5NAFJQfUxpFLXGgSmGOjaBiMW8yxOZhxE1gvYiX0/ZUkBeEZNLrW4GB1aD2iFE6YhyT6ofxds6H7PrIdPqevgB6Oi3DhJsDeJdUC43WY4hdjIZkCTQWWuTYjjdu2CjQJQSoxnEVGtMyutkG97dAg4ZQCPwJFElUm8n7bNAuuLZXK4Z0Y2sMqFSDZisPRRBtV+LE/wdmTatjZAE+Em4NlnJIuBbPrRjB2T1zScbeBBQmOQtwUSqXRNOzJKNv4CangApj3GUoNPG6m/Dn/BbLNxgn+m+S0Vcx7mJwF0LdHVj2riiraFNfqkKIDNjsoHnIkCHrrBs+fDhlZWX87ne/45hjjmmXwoQQQogdnWtcFEqCZiFE2sCBA/nwww+prKxss/75559nt91222rnvf7663niiSfSt5vP9e677zJ27Nitdl4hxPZHKUWo6Auia07GJGehrb5o304kGp8A/wrS42+Vwgsrm1K3UwfwW3iJbAB0V+zAfvhz7iVmH4ebtxoOKcEsWA5NNail3uGsqV1Q3wxBj98fO3QquKuJ1V2N6Z1AzaxDqZ4oXYKaYjC6ArVbBLNiErrBoAdp/OXF6Om5qE/Hwa5hks/WYkrmQnUETCnOSXMhNwEhjdmnFKW74SXiLrjLUHkhyHNgoIWK+tGzs3B7LoSgd22mApL3KVQygiruhtJ5uGoWmCgQg0I/pjQLAhaH553Pgfc/g1rYQKJBe49F8+jlmA98SUj4IZIPJo4KHoNy17Cg9n+sTjRR7m8gN2ChUCgstI6kHs8QrmnEGAejDEr7vGuwNeTaoEtRygKyMc4UvGHWNsqqBP+RuE2PoaiheRi28g1D6xx8Wb8m0TABTBQrMA5f+GwaV47BJCelzmuj7J0xSmPFP8E1CldphuYuI5D/Cu6qAzDuKoyJg7MMZedgnMVgKZTVDTc5DYyFsnsABuPMBd9gr1l3q2HeBoMhuZHWHUKIjmCzg+YN6d+/P1988UV7HU4IsRXFwhYnf39AelkIkRkODhYWESI/vLEQolO4/vrrOf3001m8eDGu6/Liiy8yY8YMnnzyyfVOyN1eHn/8cR5//PGtdnwhxI5FWzmEC19ts84KX0x01UhwV4HVn2DBayQb/0Sy4U688NIAYSz/SJT/SNz4ayidjS9yHpjVqKeXY78WBRXDOWsw7pJPodpBfWOhJ4FqXIP6ahactxxVVkYg92HMeQ3Q70Oc++7DLFiACYVQloXqnY9z+c6oQC5mwUysl2zw+7FG7o3z+ONYU/Mx82th5UrUsL7oqlKS19ehAkUo5QP8GHc5SheC3QcreAKY1VDvYq56BdWkMYV5JPafAvuGUCYKOQZllRPI/T128BCc5AKc6JskGu7E6FoUAXTwYFBZqEED4fVlqBk+TD8Hgl5PEZ0zFl/yJJI5X6Koxg6djh30fm+r8N9J7ar30YEabDUHpbNBV6JoQOli4rFVJOJfo7BJJP0EAga/v3lGRlA6D3/2DSQa7gYqvFHouFT77+cvs57kZyUxcm2FpYKgNAoHX+Tn4NaAiYHOxQ4djzHVKF2M0eVg6tD2QNbEXmT2lM+pLDufrIIV2NjsVHAAYFA6D9CYxDSMMhh3FVZgDMZZ4r1u/HuDKsA4C1E6H+3b3VsfGI8dmkyy6fnU6+SXaKvL1n1hCyF+tM0Ommtra9vcNsawdOlSbrzxRvp20EkMNuSOO+7gqquu4sILL+S+++7LdDlCbDtKUVskE/gIkWkODpaypEezECLtyCOP5NVXX+Xmm28mEolw/fXXM3ToUF599VUOOOCATJcnhBAb5nyL5ds1fVOZBfizr8GJveW12TA+fNmX4c+6AKWCGPdUIIDSEYxJot6Pp/bU+D7ug1kRwsyZgZrfBE4Uk0jAt9/iPPgg9m23oZRC2VmYnj0xU6ZAIgGWhTrsMHx/eATd9E+c+P9Q+T/ByhqCLitHdemCKi3FTJ2KKi7GRKMAWN33w4QXYdxlXu12JW5sHiY5DaXysf3D0XYvTP1ykg2ve9usKMGuCZNU01FWBcG857D8g9PXb9ndsbJ+jh06Aif2NtrqixUYAYB/3F9J5v4f/uWLSYTewuiVaN9ggvnPopSNj9MwxiUZfZ54/d1YgfEE7C7skmMBBShdiS/rFtz4eyirAiuwD4lVf+fVZ0YyZcpQXNfilLMm0b/v38FdCSqMP3I+vtARYFaTbHq++VniP8vm8219PtOyujMoMp8cXwE+32D8ufeh7e5Eq38CGHBrSDY9iy9yMXZgTxxlgwqxqvZmbrp8JrFoNqHQnVx/64sUlZbjz74BpXz4IhcQr70OpYMoqw9KBfCFL8CJv41x12CHTiQZfQHXmYlSBSjltWtSyk8g+2oC2VcDYEyMROMTGLcGO3Qs2irfGq9iIcSPtNlBc15e3jqTARpjqKio4Jlnnmm3wra2L774gocffphddtkl06UIIYTopJIksbDIUtL/VAjRYu+99+att97KdBlCCLFZlG7dO1ehdCFahwgXv48T/wxtVaLtHi2bONmYzz/H5OaiBw/G6n8kZtJnoALoviNQp/0a94knMPtGMAvmYPIXQUMC1apfvfv667gvv+z1H25oAK2hf38A7NCR2KEjvQ2HgvvZZ5ivvkKdcgo6JwcaG1GHHYYKBKCsDMusxom9g9JdcJzvSTY9gzdjYALj1nlXVVqKPvVUzD//Cd27Ezj5KgLZodQo6PXTVgk6fFLbx0qF8I0426vTvQzjrkRZFanWFqmHJ/oqycanvOX4ZwRyJwBg3Crs4NFouzeWr3d6+5yiM9l1r1VUVS+ma3mInXc/AZ/vZkzye9ClaKvAO1/wOIyzENdZhB08ivz6IEkzlQeXHsbo3Hmc13d3/KFxWL7+GJPw3hQwTam6s1BK4cu6DttdjFL5zPy8lli0CoCmpi4sqrqf8n4tE9Hagf0gx5Covy91jAjarsTyX+RdW2ISbvxTUGFc53uc+H+xg4ev8zgmGx8jGX3Ne96TkwjmPbrBx1wIkTmbHTS/++67bW5rrSkuLqZPnz7Ydrt14tiq6uvrOfnkk/nzn//MrbfemulyhNjm7JjDz6+eCsBffjuQZEDaZwiRCS4uFpb0aBZCpH3xxRe4rsvuu+/eZv1nn32GZVkMHz48Q5UJIcTGWf5h+CLn4ia+Rft3R9veJ56VCmIHxqyzvXPrrZivv/ZunHMO1jXXYV5/HYJB1MEHo2wbPXQoANGZZ+EumAdJB1/h0QC4H3yAM2ECRKOwfDlYFgQCqLV63AO4//oXzsMPY2prUT4f+tZbsfbYo+1GqgA7dBwAJtqItgeDaULpHFpmMATrhBPghBN+5KPV6rQ6C6XXHXRg3BWtbkSBKL7w6Rs91tDdCxm6e2GrNRbKt9Na54vgz742ffuoCgfHuCxpXMnB5ecTyenesq3y4cu+lmTTcyhdhB06ObXe668M0H8Q+AOaeMwlHLHp3T97nbrswDjvMpz5WP6xXtuP9DmySc8eCSiVs95rM+7ylmVnBcY4bYJ5IUTHsNnJ8Jgx6/4PYntz3nnnceihh7L//vtL0Cw6JStpOPQv8wF47OadSEoXDSEyImmS2MomW637A7kQonM677zzuOKKK9YJmhcvXsydd97JZ599lqHKhBDih9nBgyF48A9uZ5JJL2RuaMCsWoXz3HP4Dj0UdfzxmDlzcJ96CtWrF3rMGIxbj8lfBostSCZIfvEQWu2J+8YbmCVLUAUFEAxCZSWquBimTVv3fJMnY5qaYMYMjDG4N9+MuuMO9AY+4WwFxmLFP8JNfoflH4X2Df3Rj83msoIH48Q/SvU03hedCnbb/Tza4oQe+234ft8uWL4NfxK8vCLCLX8YyuzptQwYnEdRcXC92zWHzWvTdi98kQtw4h+g7YFo/z7rryN4NE5iMpgodugnEjIL0UFtUtD8yiuvbPIBjzjiiC0uZlt45pln+Prrr2XiQiGEEBmXJEmQIGGkR7MQwjN16lSGDl030Nhtt92YOnVqBioSQoj2p2wb1bcv7jPPgONgpk7F/eAD1JAhOFddhWlsTG2oUHvvjaovwjQ1of4TRb+0ACd2KNg2GINZsQLy86G6GoxBreeTH2rUKHjtNTAGcnO90c/z58MGgmal/ARybt6aD8EP0lY5gby/gGlMjaruuLqWh+lavuU/z9rBA9KTHm6I5duFYP5TYGIonbvF5xJCbF2bFDQfddRRm3QwpRSO4/yYeraqhQsXcuGFF/LWW28RDK7/XTYhhBBiW0mSJEfloJXOdClCiA4iEAiwfPlyevXq1Wb90qVLt5s2dUIIsSn0z36G+8knYNuovDzM/Pmorl1bQmbAzJ+P3mcf/MV3k7jyc3h7LqrGAV8SfD7o2hUKCiArC1au9JovdO267rn22Qf74YdxbroJGhpQRUWoPffcdhe7hZSyYQOtJDojpYKgJMsRoiPbpJ9WXdfd2nVsE1999RVVVVVtRok4jsMHH3zAAw88QCwWw7Lk4xdCCCG2jQQJCnXhD28ohOg0DjzwQK666ir++c9/kpvrjdhas2YNV199NQccsPHRXkII0dG5U6ZgpkxBDx2K6t8fPXYsZvJkVHY2euxY6NoVNWgQZsoUb12qdad563+ot1dAPaAUxOPgOLB8OWrIEMysWbBkiXeO559H77rrOufWAweinnoKFi+GLl1QoY49R4ZxHMy336Jyc1FrvfkohBAdVacaFjFu3Di+++67NuvOPPNMBgwYwG9+8xsJmYUQQmxTSZOkUEnQLIRocffdd7PPPvtQWVnJbrvtBsDEiRMpLS3lqaeeynB1Qgix5czMmThXXw2ui/vss9j33491662waBEUFaEiEQBv3YIFUFwMWVm4S5fi/PWv3ghmnw9cFyyLxt6V3DumgFW9NCfOXM7Iujro2hWzePEGa1B+P/TsudE63a++wn30UcjKwrr4YtR6RkhvC+4dd+B++ikohXXhhehx6+9xLIQQHckmf1b3nXfeYeDAgdTW1q5zX01NDYMGDeKDDz5o1+LaW3Z2NoMHD27zFYlEKCwsZPDgwZkuTwghRCfj4lKkijJdhhCiAykvL+fbb7/lrrvuYuDAgQwbNow//OEPfPfdd1RUVGS6PCGE2GQmHse0aq1pZs/2QmKAeBwzbx7KslCVlemQGVL9m3v1wsyYQeKoo0ieeSbMm+cFxPn5sPvuqPHjeWJsGct8CYq/mMxf9yklnpcNgQB60KBNrtF9/XWSJ55I8rzzMM0jou++G7NwIWbaNC9wzgCTTHohM3h9qD/6KCN1CCHE5trkEc333XcfZ599Njk56/YHys3N5Ze//CX33nsv++yz/hlChRBCCNGWQpGn8zJdhhCig4lEIvziF7/IdBlCCLHF3JdewnnsMVQkgnXDDagBA1DDh6NyczE1NRAOY2prMXV1qOzsdfZ33nsP56c/9Sb4C4chO9vr5XzCCVgXXghZWeQ8cwun/fkf0NhIPGBDeQV6j1Hoiy7apBpNLIbz0EPeBIENDbh//zvWpZd6t9MbmQ0fYCtqnizRzJrl3R44MCN1CCHE5trkoHnSpEnceeedG7z/wAMP5O67726Xoral9957L9MlCLHNxUMWP/t2v/SyEGLbM8ZgMJTpskyXIoTogKZOncqCBQuIx+Nt1h9xxBEZqkgIITaNcV2cJ57wRuLW1+M++6wXNpeUYD34IO677+I++ijugw9iXnwR6w9/SPdLduNxbwTzv/8N9fXeCOiaGm85Jwfz2ms4M2eicnM5vHYVS2qaiCvoUZsgcPAQrDvuQG1k4lT3228x77+P6tcPNW4cBAIQjXp3pmrQl16abp2hf/azrf54bYh1yy2Yd96B/Hz06NEZq0MIITbHJgfNy5cvx+fzbfhAts2KFSvapSghxNZltKKqMpzpMoTo1BIk8CkfXVVm+v4JITqmOXPmcPTRR/Pdd9+hlMKkRtMppQBvImshhOioTGMj5r33IBaD5sC3sGU+CpWbC3V13o2aGtx581AvvIB1yikAOMceC6+/3tJio1kw6E32pxRm+XJMQwM5xpDjON6oY6Uw//0v7p/+hHX55euvraoK58YbIZGAN9/EikSwrr4a9+9/RxUVoU89FQA9YgR6xIj2fFi2iIpEUIcfnukyhBBis2xyj+by8nImT568wfu//fZbumaoSb4QQgixvWkwDYQIUWFJz1UhRIsLL7yQnj17UlVVRTgcZsqUKXzwwQcMHz5cPoknhOjwnBtuwJkwAROPQ04O+tBD0Wed1WYbNWQIxGKY6dNh2TKchx/G+eor3O+/x3z88bohM0A87n1Fo94I50QCksmW1hbGQFUVzp//jFm9ev3FrVzp7ZdiFi9G77Yb9l13YV1xxXpbeAghhNg8mxw0H3LIIVx33XVEmz9W0kpTUxM33HADhx12WLsWJ4TYOuy4y5nXTuXMa6dix9fzg5wQYquro44KXUEX1SXTpQghOpBPPvmEm2++maKiIrTWaK0ZPXo0t99+O7/+9a8zXZ4QQmyQSSa98BhQ4TCqTx+sc85BhVs+SWkWLPBGOx99tPe9tha++ALnxBNJjhkDTU3rP7jrets3Nm64b3IsBitWeKOqYzHcyZMx1dUt9/fr54Xc4I1g3nffdrlu0X4cx6WhPvHDGwohOqxNbp1x7bXX8uKLL9KvXz/OP/98+vfvD8D06dN58MEHcRyHa665ZqsVKoRoP1bC5Zj75wDw9FX9SPo3+T0nIUQ7MMbQYBrY3d49/XF4IYQArzVGdmpUXVFREUuWLKF///5UVlYyY8aMDFcnhBAbpmwbveeeuJ984t3ebbc2k/25X36Jc8stmKYmmDWrpQczwOzZoLX35fO1Ha0M4Diw9s9Mzdsnk95tY6CmhuRRR6H69MFMnIgKBLCeeAI9ZAjKtrFuuQVWrIC8PJTfv7UfErEZli9t4varv6V6ZYzR40r5xUX9M12SEGILbHLQXFpayscff8yvfvUrrrrqqjb94g466CAefPBBSktLt1qhQgghxI5ijVlDrsrlQP+BmS5FCNHBDB48mEmTJtGzZ09233137rrrLvx+P4888gi9evXKdHlCCLFR+sorURMnYiZOxP3rX3EffxzrwgvR++6L+eQTL1iuq4Pqai8kbt0mw3XX3zYDvBC5dfCsFFhW26C5ebvJkzHTpkEkggGcW29F/+Mfqd0UlJS0/4WLH+3t15ZQvTIGwEf/Xc7hx1fQtVzmFRJie7PJQTNAZWUlr7/+OqtXr2b27NkYY+jbty/5+flbqz4hhBBih2KMYalZyjjfOIZYQzJdjhCig7n22mtpaGgA4Oabb+awww5j7733prCwkGeffTbD1QkhxMYprVFDh5K8/34v9HUc3H/8A73vvqjBg+HNNyES2XD7CwC/3+ulvLFtjPG2Wd8nw6JRL4QOh737/X6M63r9n20btbt8oqwjKiwOpJf9AU1Wti+D1QghttRmBc3N8vPzGdEBZmEVQgghtgdJk6SBBppME6vNakp0CWcHz5ZfcoQQ6zjooIPSy3369GH69OlUV1eTn58v/2YIIbYfXbp4k+8BqmtXzLRpmOnTUaNGYV5/3RuJvHaQrJS3Lh5ff4C8Np+vzeR+bfj9UFqK6tIF6/LLcf/wB9x33gFAH3001loTFIrMO/DwcqJNDosXNLLv+K5k50jQLMT2aIuCZiGEEGJHZIxh7T8ubptlADf1x5iWdQZDIvXHxcUxDkmSaDQKRURFCKsw43zjOMZ/DCNsecNWCLFxCxcuBKCioiLDlQghxOaxrrgC97nnwLJQBxxA8tJLIRbzJgNsbpnhOBs+wMZGMzcrKvJacMTj67bVyMrC+vBDdG4uSimSv/99y6G//hokaO5wtFYcdWJlpssQQvxIEjQLIXZozf3kDS0/fDYHh+tsu551re9bJ2T8ge03ucb1bbsJu2/OOTZ13+b1a9/f+vbmPnY/dLy11zU/zuuryTUuCRIYDIoNj3RJ36dSy4Z191GkH+fmILl53zZ/lEqHxa3/WFgoFFrp9H455NBFd8GnfOSrfApUAd11dyqsCvrpfnTRXbCV/K9XCLFhyWSSm266iT/+8Y/U19cDkJWVxQUXXMANN9yAzycjvIQQHZ/Kz8f65S8BcL75BjNjhhcsa+0FwfH4ujttSrjczLJg1SrIy4OampZ9bdsb6VxUBG+8Accd57XLGDEC89ZbXm3y6WwhhNhq5LddITqYJtPEGrOGRtOYDjObwzGF+sGArVnzx2uNWXf7kNMS5M1159Lk6jbBZuvA7ceEma2P90M1b8p51j7GpgaezcFgs+bQcIPnWM9drQNGnfqz0WNspi3ZZ0v2Wydo3cD9Gr3u9q22ab2+9e0NrW8+Zno7pda7r0bjx49WGgurzXoLi4iKUKJKCKogSq0TCae39+PHUlab50yhsLGxsNBKp59HCwsbG7/yEyCArWxsbDQaH7707eZlK/UnpEJt1mk0AQLy0XYhxI9ywQUX8OKLL3LXXXex5557AvDJJ59w4403smrVKiZMmJDhCoUQYtOZqiqciy6CWbO8MLi4GI49FpYvh2XLtvzArUdDl5TAwIGwYIEXPts2+P24f/sbANaJJ6IvuAA1ciT4fOhhw37cRQkhhNggCZqF6CCSJsk8dx4aTaEuZA97D4p1sRd4tQrFmkMzWDekaxPYpYK61vul/wQM//xqGUopLiooQ2t7nSB1fQFesx8KN1sHbT+47eYeez3bb+gxSF+Pans9fvzrBMVrB6DrO54fvxdKKpsQISxlrbv/eo65sW025b6NHXeTtt9A8Ln2cdZ+fbV+naWXJUQVQoit6umnn+aZZ57h4IMPTq/bZZddqKio4Kc//akEzUKI7Yr73nswf74XMhsDyST6sMNw//73lhYaW8pxvP1DIUgmoVcvbySz40B+vrdNKsxWSqH22OPHX5Do0IwxfPD2ctZUxxl7UBdy8/yZLkmITkeCZiE6gKiJMt2ZTh+rD6cGTuWngZ8SUqGte9KhW/fwQgghhNh8gUCAHj16rLO+Z8+e+P3yC7MQomMx0SjuK68AoA8/HBVq+zuM6tbNC5SbRyDn5MD//gd1dT8uZIaWCQOLimDZMtTgwVh33IH58EPc119HZWejDz98o4dw330X88knqJ13/sFtRcf36j8W8vxT8wD45P0q7vjT8MwWJEQnJEGzEBkWNVG+d79nF3sX7oncQ3+rf6ZLEkIIIUSGnH/++dxyyy089thjBAIBAGKxGLfddhvnn39+hqsTQoi23Hvvxf34Y+/GrFnoCy/E/ec/wedDjR+P+/XX3oR9zaHy4sW4v/sdRKM//uS27fV6XrbMG81cX48KBNC/+hX6pz+FcBi1kTfozOzZOPfe6420/uQT6NIFLf2bt2tzZtWll5csbCQadQgGrY3sIYRobxI0C5FhC9wF7GrtyoNZD9JVd902J43H4be/9ZavvhpkhJQQQgjRIXzzzTf897//pVu3bgwZMgSASZMmEY/HGTduHMccc0x62xdffDFTZQohBABm7tyW5XnzcO68EzNxorfi1Ve9SQDr61sm62tsbJ8Taw0FBZCV5U0GOHkyJi+P5GWXYd12G3rw4B+uvbq67QSEq1a1T20iY/YeV8rEL6pxHcPuexdLyCxEBkjQLEQGLXGXkKWyuCR0ybYLmQESCbjpJm/58sslaBZCCCE6iLy8PI499tg26yoqKjJUjRBCbJw+5BCcRx9NL7vNb4C5rhcyz5nz41tkrE8gAL17o3JzMcuXg+uiysq88373HWxC0KyGDkXtuitm4kRU796ovfdu/zrFNjVsjyLuemg4tTUJevfLznQ5QnRKEjQLkSGr3dXUm3p+Gfwlo32jM12OEEIIITqAxx57LNMlCCHEBpk1a3D/+leIxdCnnYY+6igoL8e5/36cBx6AsjJoasJMmeKNZE4m2/Zobg+p0cz6xhvRNTUwdCjub3/rBc4+H3ropk1Go2wb+5ZbME1N6/SWFtuvki4hSrrI8ylEpkjQLMQPMKmPUxnafk/fv5Hbzcsubno5aqJUmSpsbA70Hcj5Qem3KIQQQghPU1MTxhjC4TAA8+fP56WXXmLgwIEceOCBGa5OCNHZuQ88gPvZZwCYxYuxH3gA97XXMB99BIsWeaOXe/SA2lpoamrbmuLHyMnxQmzbRpWXoy+7DGv//dN3q3vuwXz7LapHD28Cws0gIbMQQrQfCZp3QMYYYqk/xhgMJh10tv4D4ODg0vJRpvWFqel1ZtOC1nXq2cTt116vUC3LStF8t8Gk79vQcuoA6boVar3nbd5nYzU1H7NNPa3Ps5H7FAoUaHR6vQ8fg63BnBg4kWP8x2Ar+WsohBBCCM+RRx7JMcccwznnnMOaNWsYOXIkfr+flStXcs899/CrX/0q0yUKIToxs2ZNy43UsvL5YOlSb/QywNy5XsDcXiEzQEkJ9jffoIPB9d6tcnJQo+VTokIIkWmScO1A4iZOlamixtSQpbIIEMDCa36vlU6HnQqFjY1GE1ABggSxlIWFhUKlvytUm/0sLGzs9DGhJVTVSre93SpYbV6v0RtcVqh0DZbyztN8LktZaHSbY7bev3UQrNEopdqco3m/tW83H1et9af1cVvXp5Vus25952+9vUKla/Hjx8I7X5bKolyXpx8zIYQQQohmX3/9Nffeey8Azz//PF26dOGbb77hhRde4Prrr5egWQiRUfqUU3Bvvx0Tj6PPPNNbd/bZXtuMqiqvrYUxoFT7tsuYNw/z2GMg/wYKIUSHJkHzdi5u4tSYGtaYNbi4lOgSjvUfy2H+wyjVpYQIodH4lT8d3CqlfvjAQgghhBBim2tsbCQ725vA6M033+SYY45Ba80ee+zB/PnzM1ydEKKz07vuinrmGW/yPcsbgKRKSrDfe4/kT34CNTXexOOrV0NjY/ud2LIwS5a03/GEEEJsFRI0b0cc47DarKbW1JIkiYuLDx85Kofh9nDG+8cz3jeeIl2U6VKFEEIIIcQW6NOnDy+//DJHH300//nPf7j44osBqKqqIicnJ8PVCSFEqq2hZXmtFevqMLW1uL//PaqsDPr0wXzxBYRC7Rs0DxjgTTwohBCiQ5OguQMwxuuh7OKSIEGSJI5xiBIlbuLEiafbM2SrbPpYfRhqDyVP5dHX6stwezgluiTDVyG2K8EgfP55y7IQQgghOoTrr7+ek046iYsvvphx48ax5557At7o5t122y3D1QnRucyaXsuTD83G79ecdUFfyisimS6pwzCJBM7112MmT4Y1azBZWTBlCixf7rXMaK+2GcEglJZi/9//oQcPbp9jCiGE2Gp22KC5eRK85snuXFwenvAwf37ozyyYtwCAfgP78etrf82Yg8ekt3NwiJs4SZLpSfRc4xInng6Am7dtPcmei0vCJGikEde46Qn25rnzWGPWtPT0VWq9k+o19/W1lZ3u55uv8imzyuhl9aKr7koP3YOB1kC6WZs3i64Q67AsGDEi01UIIYQQYi3HHXcco0ePZunSpQwZMiS9fty4cRx99NEZrEyIzufhe6ZTtTQKwON/ms01tw/5gT06BxONkrzjDswrr0C3blBbC7GY95VI/PgTWBZEItDUBJaFvuIKCZmFEGI70WGC5kbTyDRnGvOcecx351Nn6qg39dSYGqImmg6LndQf13jLTaapTeCbDodb3QYv1K0uqIZroVfvXhhjWPL3JZx5zJkMeH8AwZ2C6e1b/4GWEcet17eeAG5tzessZTHMHsYoexRhFcaPPx0kZ6ksAiqQnrAvqIL48BFREXJUDrkql1yVK/2UhRBCCCE6mS5dutClS5c260aOHJmhaoTovFzHrHe5s3PuvRfz6KPe5H8LF8LIkehdd8X97jt4+21w3S07sFJewNylC8RiqJ13RvXpg33uue17AUIIIbaajAbNS5wlvBx7mYXOQt5JvMMKs4KYiQFeWKvRWFhopdcJdtV6/rS29nqFonB8obdGeccuuL6AlX9difulS97AvA0es3n7tdf9kJnOTC4MXshB/oPa5wETor3E4/CHP3jLF14Ifn9m6xFCCCGEEKKD+fmF/fnrAzMJBCxOO6dPpsvpMMykSd7vE5EIOA569GisCy7APf10LyzeXCWpNpAFBdCjByoUQo0YgQoE0Mcd177FCyGE2KoyGjSfXHcyUaLUmTrydB4lqoSgCm6TUbzGMSx5aQluo0uX3bsQUdJvS3QiiQRccYW3fO65EjQLIYQQQgixloG75HH3I/JpAgD39ddxX3wRystRBx2Eef998PlQvXqh99kHd+JE+PbbLevN3LUrqqIC6447wBhU166owsJ2vwYhhBBbX8ZbZ3TRXehO9/RtBwe24qeS6qbU8emBn+JGXayIxW7/txuh/iGSJrn1TiqEEEIIIYQQQmyHTHU1zkMPgTGwfDm6Rw/sv/8d51//gu+/J3n++V5f5SVLNv2gWkM47LXZCIXQJ5yAHjRo612EEEKIbSKjQXODaSDqRrfpOU1vQ8/3e+LUOtS+UsvEX02kx6s9CAwItPu54nHDP6re4+v4inY/tmg/9ckmZtUuIu4mcMwP9xO7cciZDCvsvw0qE0IIIYQQQogMW/sTx0pBKATTpmE++QTq673AeHNGM4dCUFDg9WB+8UVUbm771iyEECIjMho03591P5GsDLSsKEh9Hw0Xfnsh5X8t54o/XdHupzn303t4ddlk8n0L2v3YYtPEnARxN4ljWn7o0UpjKwulFJbShKwAWXYIrRSWstAq1YtbgYXG1jZWap1SirjbDjMpCyGEEEJswFNPPcVDDz3E3Llz+eSTT6isrOS+++6jZ8+eHHnkkZkuTwjRyaj8fKzzzsP5xz9QJSWYNWtwLr8cZs6EZNL7Mj/wsWTL8sJoY7yRzAMHYt9+O2qvvVDB4La5ECGEEFtdRoPm3X27k+PLyWQJZJts8hJ5jPKNav9jN/yNQCRJSTC/3Y8twDUuMTdBwklSn2wi4Tq4xsUxTnpkcpYvhF/7sJQm35/NoLwelIYKyLK99QHLR7dwMQNyK4nYQUJWAL/ly/CVCSGEEKKzmjBhAtdffz0XXXQRt912G05qhGBeXh733XefBM1CiIxQvXujGhsx332HWbgQAgFv3pd4/IdDZr/fC5mb54UJh7FOOQU9btzWL1wIIcQ2lfEezdvSVVddxcEHH0z37t2pq6vj6aef5r333uM///lPpkvrdIwxuBiMMRgMrjGpkNjFxcU1be9LGoeYEydhHEzqBxnXuITtAD5t49c+SoL59M4uI9efRVEgl5JgHuXhYnpmdSVsBykK5G6TiSaFEEIIIbbU/fffz5///GeOOuoo7rjjjvT64cOHc9lll2WwMiFEZ+a++iqmrs4Ll+fO9UYxa+0FyEq1hM1+P/TrB4sWedsmk1BUBHl5UFKCGjwY65pr0KWlGb0eIYQQW0dGg+aoE8PvxNZZbwyY1IyAptW7o+l1bbY1be5rXm7erfVxFi5dxCmnnsLyZcvJyc1hp8GDePaV5xkyejhVTavXrYN1z732edfdZ+1rjNO0nmtce8O25/KO39IveN3rXvsgZq0N1j5e+r9tDtKyVctj1rJ1c/BrWgXCrZ+b9H6tDuzV7qKURgFeBwq1zvNo8NpSqFRLCq28thS2slB4LS1a35djh+mW24PiYC4VkRJyfBEK/NlUREooDRWQ64uQ5Quv8wgJIYQQQmxP5s6dy2677bbO+kAgQENDQwYqEkIIIBUMm7lzvYDZstYNmpUC20b17Yvp3h2VSGCmTIHsbPTo0Vi//z0qkoHWmUIIIbaZjAbNh71zJXbYv74EFdh4sLrhtWsHrK0cH6br8QfTJXUziuF3vMHv3nljgzWuHTBvjjx/FnWJRlZG12xgC7XeJQXp/sFrb6/a3lzP0dTaq1vWKe///S1bqPQ+OnW+5j7EOvXdUhYF/mwClp+A5WvT27g5KG7ubWwpjVY63ffY0posO4RP22il8CmboOUnZAewlYVf+/BpC1tb+JSNT9uE7ABBy09Q+/FpG0tpb8SytLNoX8EgvPtuy7IQQgghOoSePXsyceJEKisr26x/44032GmnnTJUlRCis9MnnABK4U6YgCkuhvnzvUkA8/K8UcvxOBQXo3r0gEQCvfvumC++QA0fjj7jDPT48ahQKNOXIYQQYivrGK0zVPo/bVatLzBtWdpACwS19pabd2v9azbgBzZc0FDFL/sdwUFlI1vtsm64rFpNNNe8zlYWYTvYEgWrtlfcvH3rY2rV/F2nj58OjpvvQ7fZ1lJW+viiE7EsGDs201UIIYQQYi2XXHIJ5513HtFoFGMMn3/+OX//+9+5/fbb+ctf/pLp8oQQnZSybayf/hTVty/OnXdCQQGqTx/MzJmgFKauzguSbRtVXo515ZWwciVkZ6OyszNdvuiAVq6I8s9nFuAPaI45qZJIlgwuE2JHkNGgucCfgy8QyGQJW9WypmoG5fZkUF7PTJcihBBCCCG2Az//+c8JhUJce+21NDY2ctJJJ1FWVsYf/vAHTjzxxEyXJ4To5PTw4ahnnkm3TnQffxyzaBHWoYeisrMxixejRo5E+f1QVpbhakVHdv/t05g7qw6ANdVxLrhyYIYrEkK0h4wGzUsaV2Dhz2QJW5VroDrqsKwhmelShGgrkSD81z8D0HjW2eDL3LvHBogmDUkXHGNwDakvr3FNeZZNUcjKWH1CCCHEtpJMJnn66ac56KCDOPnkk2lsbKS+vp6SkpJMlyaEEGnKavnZ3Pr5z9veN2DAti5HbKdWLI+ml1dWrWdeKyHEdimjQXO/nAp8kR13RPP/liT57WcW96hlmS5FiDaC0UY+vPRCAA7NH080mLmJFP2WItvvNXVRa7W+8brqKF49osv6dxZCCCF2ILZtc8455zBt2jQAwuEw4bBMdiyEEGLHc8xJlTz18GwsW3PECRWZLkcI0U4yGjT/da+ryMnJyWQJW9Xe/1jMqrhLOLz2pH5CZFbQaXlNhn0a7dv2r9FF9UlClqIkbDGuIkTEp7GUFy5rpdAKtILdinfcN6OEEEKItY0cOZJvvvlmnckAhRBCiB3J/oeWseeYYixbEwzKJ1iF2FF0jMkAd2DZfk2OX4Jm0bEE3JbXZLZf49/Gr9GVTQ4RW3HKgCwuHZqHpWUySiGEEALg3HPP5dJLL2XRokUMGzaMSCTS5v5ddtklQ5UJIYQQ7UsmABRixyNBsxBim2pKuqxocvhpvywuH5aHUhIyCyGEEM2aJ/z79a9/nV6nlMIYg1IKx3EyVZoQQgghhBAbJUGzEGKbMcYwvzbJTgU+rhkpIbMQQgixtrlz52a6BCGEEEIIIbaIBM1CiG1mWaNDYdDixt0LCNrSUkYIIYRYm/RmFkIIIYQQ2ysJmoUQ20R11KEm5vLzwdkMK5UJ/oQQQoj1efLJJzd6/2mnnbaNKhFCCCGEEGLzSNAsRCeU8Pm56bqn0stbW33cZVmDw/geIS7aNW+rn08IIYTYXl144YVtbicSCRobG/H7/YTDYQmahRBCCCFEhyVBsxCdkGvZfDl8/21yrtq4y/zaJOMqgtw2qoCALX2ZhRBCiA1ZvXr1OutmzZrFr371Ky6//PIMVCSEEEIIIcSmkSapQoitZkWTQ1Wjw5jyILeOKiAvYGW6JCGEEGK707dvX+644451RjsLIYQQQgjRkciIZiE6ISuZYOz7LwLw3phjcGxfux7fcQ1za5NoBUf0CnP7XgVoJSOZhRBCiC1l2zZLlizJdBlCCCGEEEJskATNQnRCdjLBRX+8CICP9jq8XYLmuGNYE3OpjbskXENp2OKk/lmcs3OOhMxCCCHEJnrllVfa3DbGsHTpUh544AH22muvDFUlhBBCCCHED5OgWQixWaJJl5q4IeEY4q4h6QIYbK3I8Wv27RZiZJcAY7sF6ZHTviOlhRBCiB3dUUcd1ea2Uori4mL2228/fv/732emKCGEEEIIITaBBM1CiE3SkHCZV5skbCtyA5ocn6Zfvo/u2TYVqa8B+X5KwtKHWQghhNhSrutu83POmzePW265hXfeeYdly5ZRVlbGKaecwjXXXIPf79/m9QghhOi4pn23hhlTath1RAE9emdnuhwhRAcjQbMQ4gfVxl0W1iXZuyzIQZVhDukZkon9hBBCiK3g5ptv5rLLLiMcDrdZ39TUxO9+9zuuv/76dj/n9OnTcV2Xhx9+mD59+jB58mTOPvtsGhoauPvuu9v9fEIIIbZPM6fVcMc132IMvPqPhdz+4DBKuoQyXZYQogPRmS5ACNGxLW90WFSX5OAeIX63dyEnDciSkFkIIYTYSm666Sbq6+vXWd/Y2MhNN920Vc45fvx4HnvsMQ488EB69erFEUccwWWXXcaLL764Vc4nhBBi+zRvdj3GeMuJuMui+Y2ZLUgI0eF0qqD59ttvZ8SIEWRnZ1NSUsJRRx3FjBkzMl2WEB1WddQhmnQ5pGeYW/cskLYYQgghxFZmjEGtZxLdSZMmUVBQsM3qqKmp2ej5YrEYtbW1bb6EEELs2HYbWUhWah6ekq5B+g/KyXBFQoiOplO1znj//fc577zzGDFiBMlkkquvvpoDDzyQqVOnEolEMl2eEB2KMYZVTQ4HdA/zxzGF6/2lVwghhBDtIz8/H6UUSin69evX5v+7juNQX1/POeecs01qmT17Nvfff/9G22bcfvvtW22EtRBCiI6puDTIHX8axpKFjXTvlUU43KkiJSHEJlDGNH/wYdupra0lNzeXmpoacnIy9w7YihUrKCkp4f3332efffZp9+Pv/Y/FxB1kFKjocLSTZM9P/w3AJ3scjGut+wPC8kYHgEfGFbFrcWCb1ieEEGL71VF+ztvePPHEExhjOOuss7jvvvvIzc1N3+f3++nRowd77rnnZh3zyiuv5M4779zoNtOmTWPAgAHp24sXL2bMmDGMHTuWv/zlLxvcLxaLEYvF0rdra2upqKiQ510IIYQQYge0qT/jd+q3n2pqagC26ccQhegIXMvmf3sdvsH7jTFURx1O2ylLQmYhhBBiGzj99NMB6NmzJ6NGjcLn8/3oY1566aWcccYZG92mV69e6eUlS5aw7777MmrUKB555JGN7hcIBAgE5GcEIYQQQgjRotMGza7rctFFF7HXXnsxePDgTJcjRIfyfU2S0rDFSf2zM12KEEII0amMGTMmvRyNRonH423u35zRwsXFxRQXF2/StosXL2bfffdl2LBhPPbYY2jdqaZyEUIIIYQQ7aDTBs3nnXcekydP5qOPPsp0KUJscxtrnVEbd7E1XLhrLn3yfvxoKiGEEEJsusbGRq644gqee+45Vq1atc79juO0+zkXL17M2LFjqays5O6772bFihXp+7p06dLu5xNCCCGEEDumThk0n3/++fzrX//igw8+oFu3bpkuR4htzpeIc+VdvwDguGe/J5YKml1jWFCXZFxFiGP7yASZQgghxLZ2+eWX8+677zJhwgROPfVUHnzwQRYvXszDDz/MHXfcsVXO+dZbbzF79mxmz569zs/GGZjORQghhBBCbKc61WfijDGcf/75vPTSS7zzzjv07Nkz0yUJ0aEsqncoDVlcNjQXS6sf3kEIIYQQ7erVV1/lT3/6E8ceeyy2bbP33ntz7bXX8tvf/pa//e1vW+WcZ5xxBsaY9X4JIYQQQgixqTpV0Hzeeefxf//3fzz99NNkZ2ezbNkyli1bRlNTU6ZLEyLjVsccYo7h0J4hBhT4M12OEEII0SlVV1enJ+jLycmhuroagNGjR/PBBx9ksjQhhBBCCCE2qlMFzRMmTKCmpoaxY8fStWvX9Nezzz6b6dKEyKika1jW4LBPWZDfDM/PdDlCCCFEp9WrVy/mzp0LwIABA3juuecAb6RzXl5eBisTQgghhBBi4zpVj2b5+J8Q67e43qEsYnPTnvn4LWmZIYQQQmTKmWeeyaRJkxgzZgxXXnklhx9+OA888ACJRIJ77rkn0+UJIYQQQgixQZ0qaBZCrKsu7pJwDUf3DtM1Iv8kCCGEEJl08cUXp5f3339/pk+fzldffUWfPn3YZZddMliZEEIIIYQQGyepkhCd3IomhzG9g/xql5xMlyKEEEKIVqLRKJWVlVRWVma6FCGEEEIIIX5Qp+rRLITwVLsWV5x1N7f96h4uGFHEH8cUEbTlnwMhhBAi0xzH4ZZbbqG8vJysrCzmzJkDwHXXXcejjz6a4eqEEEIIIYTYMEmWhOgkjDGsjjp8tzLOyqSm+sTTOP628zhz10LpyyyEEEJ0ELfddhuPP/44d911F36/P71+8ODB/OUvf8lgZUIIIYQQQmyctM4QYgfnGsOyBoc1MZfcgGb/ihCn7pTF6LIglpaAWQghhOhInnzySR555BHGjRvHOeeck14/ZMgQpk+fnsHKhBBCCCGE2DgJmoXYASVdQ33CpS5uqI27lIQszhiYxYGVYUaWBlCOA/9+3dv4oIPAln8KhBBCiI5g8eLF9OnTZ531ruuSSCQyUJEQQgghhBCbRtIlIbZzccdQE3eJO4aGhEEprydO2KcoDGpOHpDFkb3C9Mtv+fgtsRgcdpi3XF8vQbMQQgjRQQwcOJAPP/xwnQkAn3/+eXbbbbcMVSWEEEIIIcQPk3RJiO1AwjE0OYZo0tCY9EJlr+uFQgF5AU1RyGJwocXYbkF65PjolWtTmW2jlLTHEEIIIbYX119/PaeffjqLFy/GdV1efPFFZsyYwZNPPsm//vWvTJcnhBBCCCHEBknQLESGOMYQdwxJFxKuwTXe96akt2zwJvBLuhC0FaHUV//8AP3yfURsRUHQoiLbZmiJn7yAlelLEkIIIcSPdOSRR/Lqq69y8803E4lEuP766xk6dCivvvoqBxxwQKbLE0KIHVpjQ5IX/jaPxgaHo07sTmnXUKZLEkKI7YoEzUK0s6TbEh43pUYgO64XLGvljUB2AQUELLC0wq8VWnkjk3cutOkasfFpCFiKvIBmcJGf7tk2ZREbvyUjlIUQQogdzZw5c+jZsydKKfbee2/eeuutTJckhBCdzpMPz+bjd6sAmDOzjjsnDM9wRUIIsX2RoFmILZBwDbGkoSFpiKVaWmjl9UsOWAqfBbZWhG1FtywfhUGLimyLiE8TtBRZfk1ZxKIkZJEb0BQELUK2wtYSIgshhBCdUd++fVm6dCklJSUA/OQnP+GPf/wjpaWlGa5MCCE6j1UrYq2WoxmsRAghtk8SNAuxAUnXC5DjrqE+YYg7LgpF0oBPQ9BShH2KHjk++uf5KAlbdIlYhG1NtyyL/IB3W0YgCyGEEOKHGGPa3H799de5/fbbM1SNEEJ0Tkec0J0/zp5KPOZw3Kk9Ml2OEEJsdyRoFgJwjdfmoibm0pAwJI3BrxVBWxGwFH1ybQYV+imL2OQFNGVZlrSyEEIIIYQQQogdyM675fPg3/YgmTSEw1sWlyxd3Mg9N0+hemWMY0/pwSFHd2vnKoUQouOSoFl0Wo7rtb5Y1eTgGG+EcrZfMaZbkN65vvRXSdhrb7FD8fvhgQdaloUQQgiRUUoplFLrrBNCCLFt+f3Wj/oV6Z/PLmD5kiYAnn1sDmMP6rLFobUQQmxv5F870akkXENVo0NDwuupHLIV3bJtftI3i2Elfnrn+Yj4drBQeX18PjjvvExXIYQQQogUYwxnnHEGgUAAgGg0yjnnnEMkEmmz3YsvvpiJ8oQQQmyiSFZLzOIPWNi2vGkohOg8JGgWO7ympMuqqEtjwqAUFAQ1B3YPsWfXIAML/PTMtWUSPiGEEEJk1Omnn97m9imnnJKhSoQQQvwYx57cg6ZGh1UrYhxxQgV+v5XpkoQQYpuRoFnsEOKOIeoYXONN3BdNGgzQHB+XZ1mMrwwypMjPmG5BukY6+UvfceDDD73lvfcGS374EUIIITLpsccey3QJQggh2kE4YvOLi/pnugwhhMiITp62ie1J84R9SRdijqEx6RJ3QCsvUA77FJZSdAlb7FLkpzRs4bcU/fN8jCoLdo6WGJsqGoV99/WW6+thrY/lCiGEEEIIIYQQQgixOSRoFhnnGi88dg0YDK7xlmOOIeYYHANNSYPC66nstyBgKfrnB6jMtimNWFRk2Qwp9pPt0+QGtLTCEEIIIYQQQgghhBBiG5KgWQDeBDQmvQwGcEzzssFxvduuMalAuOW2gXQ43Hx/6+O4GDTrD34dY9BK4dPeyGSNQilv2W8pyiMWeUGL3rk2w0sCVOb4KAlpCkOWhMlCCCGEEEIIIYQQQnQQEjRvBmMMCRcSbipsTQWpBkPc8ULT5rYOJhW2NiRc6uMqHeJ6x2nej9Te3jrXtIS3jgtuq+2bt1v7GDQfp9Vt14DCgFLpeFep1IbK21e13hfvnCq1vUptr1VzWwqFpcDSXhDcvN6vFSFb49MQsBVZPo3fUgQtLzi2tMJWiiyfImQrIj5N2KfSx7C1FyYbA2URi4Cl8FsKWysClqIwqAlLuwshhBBCCCGEEOIH1dbEeeaxuUSbHI49pZLyCmmRKITYtjIaND89vQ4rTDqUbR4ZCy0jbFuPlk24qVYKrkmPtnWMF/A2t1gwrUbcNt/flDTpELg5rjVrBbPN23t1mNT5vGO3Pk9zINyseR+3Vc3Nx8sLaAKWojbuekFvihfktgqBaQl2g7YiaGmy/Rq/Vti6JezVytvOSn1plQqAlcLS3ndbe/cFbZ3ahvSIYZ/2trfTx00FvgrCPu98Vup8tlIEbZXeJ+xThG3vegJW8zFkRLEQQgghhBBCCNERPDFhNl/8byUAi+Y3cNdDIzJckRCis8lo0HzPNzXYIfeHN6RlBHB6NK5inaC2zejdNvcpdPONVuvXpta6odPH8u5pvt2cr6bvSrd88MLj5snpFtU7XDo0l4MqQ+hUUQpSYXBLcNzcMiJgKQK2hLdCCCGEEEIIIYTYPLVrEunlmtXxDFYihOisMho098ix8YV37O4dlTk2lTm+TJchhBBCCCGEEEKIHdixp1Ry361TicUcTvp570yXI4TohDKa8s6rTWIlkpksYaty6hP8+4WFzG3TXVmIzNPJODsfdhkA3z34Pa7tz3BF6/f5RytJJlyuv3tX+vTPyXQ5QgghhBBCCNFhDRicx4S/74nrGixL5jsSQmx7mW2dsXchkewdNzy67sKveOeLVXyVtWOP2hbbq7Het9kLM1rF+hgX6usTlHYNUVQapLFhx31DSgghhBBCCCHai1IKy5KWnEKIzMhoArpPtxA5OaFMlrBVFa6IklMWoqgkmOlShNhuOEmX+XMa6N4zi/N/sxMHHl6e6ZKEEEIIIYQQQgghxA+QobZCdELKOPSomQnAvNx+GGVluCKPMYYli5soKQvy2/uHMWBwXqZLEkIIIYQQQgghhBCbQIJmITohnxPnpo/OAeDn498gbneMTxasrIoRCGjOvWwnCZmFEEIIIYQQQgghtiPSHV4I0SFULWuitibB+CPL2f/QskyXI4QQQgghhBBCCCE2g4xoFkJklDGGhfMa0RoOOKyMc6/YKdMlCSGEEEIIIYQQQojNJEGzECJjjDHM+76eUNjmwMPLuPSGwSglMyQLIYQQQgghhBBCbG8kaBZCZITrGhbMbSA7x8f5Vw7kkKO7ZbokIYQQQgghhBBCCLGFJGgWQmxzDfVJFs5roGt5iHMuG8DBR0nILIQQQgghhBBCCLE9k6BZCLHNNPdjdhyXnYfmc/F1gxi8a36myxJCCCGEEEIIIYQQP5IEzUJ0Qo62eanvGenlrX4+x2X5kig1a+IUlwY5/rQ+/PRnvQgGra1+biGEEEIIIYQQQgix9UnQLEQn5GgfL/U/c6ufp74uQfXKGI0NDl3KQ+w7vguHHtedXYcXbPVzCyGEEEIIIYQQQohtR4JmIUS7cl3D6lUxVq6IEQ7b9O6fw5gDSjng8HK6loczXZ4QQgghhBBCtLFmdZy6mjjdKiMopTJdjhBCbLckaBaiE1LGpax+PgBLsioxSv/oY7quYdWKGKur4+QX+DngsDJGjS1l/JHlaC0/rAkhhBBCCCE6nimTVnPPzVNIxF32HFPCry4bkOmShBBiu/Xj06XtzAcffMDhhx9OWVkZSilefvnlTJckxDbnc2Lc/v4Z3P7+Gfic2BYfJxF3WbM6zpKFjcydVYcxhp13y+f2B4dx6x+GccjR3SRkFkIIIYQQQnRY77+5jETcBeCT96uor0tkuCIhhNh+dboRzQ0NDQwZMoSzzjqLY445JtPlCLHdScRdqlfGqKtNYPs0WTk2XbuFGTI8n8OOq6D/oFz5uJkQQgghhBBiu9CtMgKsAKCwOEAoLBOWCyHElup0QfPBBx/MwQcfnOkyhNhuJBIujQ1JalbHSSYNSkFOrp/ho4o47LgKdhtZSFFJQMJlIYQQQgghxHbn8OMriGTZrKyKst/BZVhWp/vgtxBCtJtOFzQLITbOdQ21axI0NiRpbEzi82nCEZsu5SFGjS1lwOBcdhlWQGnXoITLQgghhBBCdBLJpMszj81l8YIG9ju4jBGjijJdUrtQSjHukLJMlyGEEDsECZqFECSTLqtXxVm1IobtU+Tk+uhaEWbA4FyG7VHIzkPzKesWlmBZCCGEEEKITuqNfy7mzVcWAzB9cg33PDqS/IJAhqsSQgjRkUjQLERnZEx6cf6ceppUktx8P7sML2DMAaXsPa6UHr2zM1igEEIIIYQQoiNprE+ml52kIdrkZLAaIYQQHZEEzUJ0EsYYmhodli1pwoo1ptfvNqKQIWMrOOCwMkq6hDJYoRBCCCGEEKKjOuDwMiZ9Wc3iBY0ccHgZXcvDmS5JCCFEByNBsxA7KNc1NDYkaahPUl+XxEm6RLJ9VPbKYuTIcpbPPo+CogB33TUK/P5MlyuEEEIIIYTowPILAtx2/zCMMdJSTwghxHp1uqC5vr6e2bNnp2/PnTuXiRMnUlBQQPfu3TNYmRBbznFc6muTJBIu8ZhLY2MSJ2nIzfcTDFnsNtLrs9yzbzbD9yzE77eABzJdthBCCCGEEGI7IyGzEEKIDel0QfOXX37Jvvvum759ySWXAHD66afz+OOPZ6gqITadMYZE3KV6VZx4zCGZ9EYURLIsAgGLLmUhyirCdOsRYcwBXajslUU40un+qgshhBBCCCHEDkFGkQshthedLn0aO3YsptVEaEJ0dIm4S21tgro1cRJJg20pLFuRleOjz4Acdhmaz4Cdc6nslUWP3lmb9gOI68KCBd5y9+6g9da9CCGEEEIIIYTooIwxfPJ+FcmkYdTYEmx76/9+lEi4PPrHmcyeUcuosSUcc1KPdbZZXR3jruu+Y8nCRvY/rIxTf9Fnq9clhBA/RqcLmoXoaFzXEI+5OI4hkXBJxF2iTQ7JhIvrGmy/JhKx2XlYASNGFRHJtunZJ5u+O+WQm7eFvZWbmqBnT2+5vh4ikfa7ICGEEEIIIYTYjvzfn7/nrVeXAPDtV6s5/zc7bfVzfvDWMj5+rwqAl/++gF1HFNKrb3abbd56dQmLFzSml8cdUkZZN5mEUQjRcUnQLMRmMsZgjPfdcQyu44XFxnjfXddgXO8d6ljUASAed1MjjQ0tA45V+liBoIVlKWxbEY7YlHQN0r1nFn13yvG+BuRQVBLM1CULIYQQQgghxA5r+nc16eVp361p12NP/GIVC+Y2MHJ0MV3KQun1a3/Qen2fvM7K8aWXLVsRClvtWpsQQrQ3CZrFDqEl/E2Fvq7Bdb37msNfJ+kFw83buqltjGtwDThJl2TS29dq9VEp7//33j4YIBUUa62wLIXSeN+VQmtvvVJeYNy1Wwh/wKJ7zwglXULp+y1bEQx5PZVDYYtulRHCEZusHB8FhX7pvyWEEEIIIYQQ28jwUUUsnNcAwMi9irboGLGYN8goELCIxRyef2oe3361mtnTa4lk2bzxz8Xc9dBwsrK98HjMgV2YObWG72fUMWrfEnr3y1nnmAceXsaa6hgL5zWw/6Fl5BcEtvAKhRBi25CgWWSEMYZok0Njo0O00cE1BkzbwNgYb2QwAIpWI4JV+t3e9Ju+qQBYay/sVUqhLYUCVGqdZSksW6NTgXAgaHlfAQt/QBMMWpR0DeL3awqKAtg+jW0rfH6NP2ARCGgsW2NZ3v62TxOO2Pj9mkDQwudT+PwWgaC3TXaOTwJjIYQQQgghhOjgjv5pJTvtnEsiYRi8a95m7//ZRyt46PfTAfj5r/sx7/t6/vPPxSxZ2MiqFTEG75ZHfW2CFcuj6aDZ59Oce/nGW3TYtuakn/Xe7HqEECJTJGgW21Qy6bJscROxmEsgqAmFbXr1yyY3349lef8j1akWEj6/JhSysH06PQo4ELCIZNlesOvX6XYTSit8PoXt0wQC3n1+v0Zp7x1l2+eNMI5k2V7gbMnkd0IIIYQQQgghPAMG523xvi/+bT5O0qSXe/Xzei3nFfhZURXFdaHPgGy6VcrcOEKIHZsEzWKbcBzD4gUNNDY4lHcPc9AR5QwZUcCgIXnk5G7hhHZCCCGEEEIIIUSGFRYHWLqoESfpEk+4jBxdxNRv1wBw6Q2DGblXEb36ZePzyYAnIcSOTYJmsVXF4w6rqmKsWhmje88Ihx5byjEnV663/5QQQgghhMiMI444gokTJ1JVVUV+fj77778/d955J2VlZZkuTQghtrmVVVHuu20qK5dHOfqkSg46onyj2//i4v489/gcXnthEY4bZcLdM7jilsH07JNNICAT+AkhOg8JmsUmae6d3DxZXnMPZW9yPcCA4xpiTQ6xmEsy6WIM+HyK7Fw/hx5bwsk/7/WjPo4k2pFtw7nntiwLIYQQolPbd999ufrqq+natSuLFy/msssu47jjjuPjjz/OdGlCCLHNvfLcAhbMqQfg6b98z177lqR7K69PXr6f/Q4p4+VnFhBdGUNr+PbL1QwYlLeNKhZCiI5BEqYdQDTqsGJZlETCmzlPpf9DeuI87zuk56ZLTZ6HMRhvwVud2iY9yV4rSqX6IStvG6UVllao1OR7Snk9qMq7R+jZN4uSLkF69MlmwOBccvOkPUaHEgjAgw9mugohhBBCdBAXX3xxermyspIrr7ySo446ikQigc+34XBFCCF2RJalmDOrjob6JCVdglj2hid5/+SDKl56ej6L5zeyZFEjTtJQsyZO/8G527BiIYToGCRo3s6tXhWjanmUbpURdh9dTDBkYVle6Ku1gtR3rRWWpdDaC4i1Vvj93sR7WoNlaXx+7d2vWvZXitQ2XsgcybLTk/D5/NqblM+XmpTPp8nOsWWiPSGEEEKI7Vh1dTV/+9vfGDVqlITMQohOKb8wgNaKQEATDFosXtBIn/7rtn+MRh0euXcGTtIwZ3Yd2Tk+srJ9RLJtdhman4HKhRAisyRo3o45jkvVsij7H1bGxdcOoqgkmOmSxPbCGFi50lsuKmo11F0IIYQQndVvfvMbHnjgARobG9ljjz3417/+tcFtY7EYsVgsfbu2tnZblCiEENtEJMumR++s9O1ok8MnH1RR2SuLsm7h9PpZ02uoWR0nkmVTWBSgoT5BcWmQsQd1QcnvWEKITkiGnm6njDEsnNdIefcw51w6QEJmsXkaG6GkxPtqbMx0NUIIIYTYCq688srUJ9U2/DV9+vT09pdffjnffPMNb775JpZlcdppp2HW108NuP3228nNzU1/VVRUbKvLEkKIrW7MgV3Y54AudKuMcOSJFfzlDzOZ8LvpXHfh18ydXQfAf19fwu+um0w85g0A22u/Uib8fRQ3/H5Xzjq/X4avQAghMkOZDf30uBXV1taSm5tLTU0NOTnrfvxkR3Hk3m+TiLvtHgIbY5gzs45Ito9fX7UThx3XvV2PLzqBhgbISr1DX18PkUhm6xFCCLHD6Cw/520PVqxYwapVqza6Ta9evfD7151LY9GiRVRUVPDxxx+z5557rnP/+kY0V1RUyPMuhOhwXNfw3TerCUds+g7Y/H+fpkxazZ3Xfpe+fcLpPTnsuAruuv47Jn+zGvA+IPrXl0ZLG0khxA5rU3/Gl9YZ25lE3GXenHoKigKcc0l/CZmFEEIIIcR6FRcXU1xcvEX7uq43yXTrMLm1QCBAIBDY4tqEEGJbefieGXzyfhUAJ5/dm4OOKN+s/St6RMjKtpkyaQ0N9UlmTfdaBQ0ckpcOmvsNypWQWQghkKB5u1JXk2Dxokb67ZTDZTcOZtcRhZkuSQghhBBCbOc+++wzvvjiC0aPHk1+fj7ff/891113Hb17917vaGYhhNiefP6/FenlLz9eudlBc06un8OO7878OQ0UdwnyzWermDJpNYcdW0F5RZjamgR77LNlb+oJIcSORoLm7UAs5rBwXgNaKUaMKuKme3aTnsxCCCGEEKJdhMNhXnzxRW644QYaGhro2rUr48eP59prr5VRy0KI7d5OO7eMPO4/OHeLjpGb56OwuOXfw+aJ/nYbKYO/hBCiNQmaOzDXMaxZHWfViii9+maz/2HlnHx2L/x+K9OlCSGEEEKIHcTOO+/MO++8k+kyhBBiq7jwmoH8790qIlk2I/cq2uB2X3y8kpVVUfbat4Sc3La96/ccU8KMKTVM+66GEaOKGLhL3lauWgghtk8SNHdA8bjDyuUxok0O2bk+9jmgCxdcNZBu3WXCNiGEEEIIIYQQYlMFAhb7je+60W3++/oSnpgwG4B331jK7Q8Oa9NzWWvFWef326p1CiHEjkCC5g4imXSpq0mwZnUcpRS5+T6OPLE7/9/encdFWe1/AP/MwqwMq6w6gOC+rxiYaW6o5dK1LLNCM72Vlua1srpXs1Kr22J5zcy6at0Wu7ncfpaWaVouWSqoKSKKCCoICAgzDLOe3x/GxCgqi/Io83m/XuQz59m+z5wHOs93zpwzYkwUoprr3V/NIbomlEogOfnPZSIiIiIiIi+VkVbqXs47bYGpzAH/ANUV9iAiouowwyQBl1PAanWi3OyAqcwBu80FuUIGg58PjDF63DchFrcOCENQMMfEo+tErQZWrJA6CiIiIiIiIsnF3xqCX34qgMsl0K5zAPz8fardruBsBb77+jQCAlUYMqoplEp5tds5HC4sejUNB/YWoVP3IDwxq+1ltyUiakxuukSzEOKi13+WVV3lcok/1l1I7NrtLo8y8cey0yngcgnYbS73cuV2DrsLDoeAcAnY7QIOh8u9X+V57XYBa4UT1gonbFYXLOUOOBwCTueFYHKyzCgtsQMyQCYDXK4LX7vxUcmg0yvRqp0/2nXyR9MoPRL6haKpUQe5nL2XiYiIiIiIiBpCt17BmL+4O4oKrWjTwd/9jeJ1X5zE9i1n0aKNHyY+0Qqv/v0ACvIqAACmMjvumxBb7fH2/nIOKbvPAQBSdp/DbzsLkXBbaMNcDBGRhCRNNCeP/Alyme5CorhK8vaiXPKfxBVfeq4TF/4j/tiw6nHd//7xwiP5XOXALiEgXIDAH/967P9HctsFOF0Crj8Sy1VHuPBRKdClZzC63RIMHx85/AN9oNMrER6pRWCwGk2jdPw6DklDCKC8/MKyTud54xIREREREXmZyGY6RDbTuV9nZpRhzacnAQD5uRVo3sLgTjIDwJlT5Zc9lk6vvOJrIqLGStK/dgVnK6BU3BxfH5HJAc9U3J+vlKg+SWcyFUMT/DtKnRbACZzLvVD++7HrFiZRjfjYbHh+/nwAwPznn4ddxQ88CHC5XNi3bx8AQKfT4d///jf0ek5CSkRERETeY/V/svC/L7Nh8PeByyXc3ziWy4FBwyOx6f/OwEclx8A7Ii97jI5dAzEmuTn27ylCx26B6Nw9qKHCJyKSlKSJ5lcX94Cvr0HKEK6rSZMfwdcbfkFgkL/UoRB50LpceP6P5f/+97+wyG+OD3zo+ikvL4fD4UBERASCg4PhcrmkDomIiIiIqEGczbXgu69Pw2J24D/LjqOkyAYAaNspAM2idGgWrUd4Uy0imumQ0DcEYRE6GPwujOOck2XCR4sy4HAIjH+8BVq09gMA3Hm3EXfebZTsmoiIpCBporlT9yD4+flJGcJ1pfEtREzzKISGciwmurGoHQ4gIwMAEBcXB6uSX+XyZjabDRkZGUhISMCMGTMQHx/vHpeOiIiIiKixys+zYN/uc/hy5Qk47AJlpXYU5le4J+7z8ZHhjruN+PDdo/jso0wolTJ0jQ/GSwu7uRPNyxcfQ+bRMgDAsoVH8dqSHpJdDxGR1JhdIiLycllZWWjZsiUWLVrED8aIiIiIyCuUldoxd2YqcrLMSD90Hq3b+cM/SIVm0XoU5lvha1BCp1fi1RcOIOeEGUIAKrUcZ/MsSP3tHAbd2RQA4HL9OXtU1WUiIm/ERDMRkRcrKSmBTqfDtGnTmGQmIiIiIq9xOtuM7EwTso6b4HQKZBw5j1bt/DHxiZY4sK8YNqsLKb+eQ84JMyzlDsjlMmh0amg0CsS0uDAE6PkSG0yldhxPL4UxxhcTn2gp8VUREUmLiWYiIi927tw5dOrUCcOGDZM6FCIiIiKiBhMd5wvZHxP96XQKOF0C2ZkmvPDEPjQJ0yCymRYZh0vhdF7opaxQAi3aGPDUP9qjZZsLQ4B+szoH+XkViPtjXOaQcK00F0NEdIPgDGBERF5KCAGXy4WBAwdKHQoRERERUYPSapX4+2ud0bKNH2JaGiCDDA6HgBBAUYEVuacscLoEIAOEAHx8FNBolTh84Lz7GD6qP1MqcoUMSiXnOSEi78YezUReyCWTYXtEhHuZvFNFRQVUKhW6dOkidShERERERA0uvncIFv3nFpzOLsebc3/H4f0lUGvksFY4kXuqHPhjyGW5HAiN0EAh93x2uvNuIwrPWpF7uhxDRjaFf4BKgqsgIrpxMNFM5IXsCgVe695d6jBIYmazGb6+vmjdurXUoRARERERSaKpUY+mRj0++LI33ns9Dfv3FqMwvwKZR8vgdLogkwNNo3TontAETY063DU2yr2vVqvEYzPbSBg9EdGNhYlmIiIvZTab0b59exgMBqlDISIiIiKSlJ+/D4aNNqKwoAJpB4phrXBCJpPBYPDBwGGReOVddtQhIroaJpqJiLyU1WpFp06dpA6DiIiIiKhBZWaU4ZOlx6BUyjF+Sgs0Nerx6YeZ2LjuFHZty4e1wgmXC5ArBGRyoEVbP6lDJiK6KTDRTOSF1A4Hvtq4EQBw95AhsCr5p8DbCCEgk8kQFxcndShERERERA3mxLEyTLpnB8pNdhhjfPHvRRl48K9x2LUtH0WFVlitLjhdF7ZVKuUIDb90bGYiIqoes0tERF7IarVCpVIx0UxEREREXqO4yIqZk35Fbk455AogO8sEq9WJjLRSnM4ph93mBADI/viPyyVwrtCKDetO4Za+oWjZhj2biYiuhIlmIiIvVF5eDp1Oh+bNm0sdChERERFRg1j4ymGczDRDAHDYBdRqBZRKOQAgspkWOl8lTGUOWModEAIQLgGDnwpCACm7zzHRTER0FXKpAyAiooZXXl6O0NBQBAYGSh0KEREREdF1ZzbZkZNlgjFGD51eiaZROnzwZSKimusBAMXnbMg4XAprhRMBASro9EpotEqUlthwJqccLdoYcDLThNLzNomvhIjoxsVEMxGRF7JYLOjatStkMo43R0RERESN2/YtZzHlgV9wJrscNqsTnboHYv7iHmjdPgBPPNcWCf1C4HC4kJ9XAblcBpPZgXKzAxqtAhHNdOjVJwRbNuTiH9P2Yeak35CZUSb1JRER3ZA4dAYRkZcRQgAA2rZtK3EkRERERETX37ovTsLlFAiN0MLgp8SC93rAz1+FPbsK8e6Cwzh7uhwZ6WWwVbigVMqgUMoQGqFFucmBiGZKjH4gGotfOwIAqLA4sX3LWcS2NEh8VURENx4mmomIvIzdbodSqeT4zERERETU6H347lHs2lYAu82FuNYGNI3SY/niYyg7b0NhfgV+TynG2TMWuFyVewj4+qkR28oAuQy4d3wsOnUPgq+fD0yldgBAs2i9ZNdDRHQjY6KZyAu5ZDL8FhrqXibvYrFYoNVq0axZM6lDISIiIiK6brKOl+GnTXmIjtUj77QF4ZFanDhuwi/b8gEACoUMVquzSpIZcAlAq1MgOESN9p0DMXhEJFQqBV54tRO2bz6LiGY63DYwXKIrIiK6sTHRTOSF7AoFXoqPlzoMkojZbEZwcDDCwsKkDoWIiIiI6LrxNfhArpBBCTnCIrRoEqrGzq35cLlcqLC44HC4oFIrIJMBf4wuB7VKDr2vEiqVHNmZJrzy7H50v6UJBo+IxL3jY6W9ICKiGxwTzUREXqa8vBx9+vSBUsn/BRARERFR49UkVIPHn26Dbd/n4pefC5F28DzMJgdMpU64XAJNwjSw21yw25xw2AWEAPQGH9jtLhxLK0VhgRXni234PaUYJ46VYfoL7aW+JCKiGxqzDEREXqhDhw5Sh0BEREREdM3knbFg7WcnodEqcM9DMfA1+AAA4nuHoEOXQBzctxN5p8tRbnYAMkAmA0LD1cg9bYFarYROD9jtAr4GJXx85DhXaEOFxQkAcLmAnCyzlJdHRHRTYKKZyAupHQ78Z9MmAMADgwbByp6tXsPhcAAAoqOjJY6EiIiIiOjaWfjKIZzJKQcAWModePzptu51Or0SPRKb4D/LjsHpEBBCwOkSOJ1jgUolgxVAudkJpRIoPmeFXCGDwy4Q08IXdpsLBj8lBgyLlOjKiIhuHswuEXkpjdMpdQgkgbKyMvj6+qJFixZSh0JEREREdM0Un7O6l4sKrZesf2JWW/j5+2D+8wdgKrVDLr8wMLNG44OgJhpkZ5oRHKLCmRwL1Bo5AoJUGDqqGcZNioMQQHiktiEvh4jopiSXOgAiImo4hYWFaN++PWJiYqQOhYiIiIjomhmT3BxyuQzl5Q6Uldrx5coTcDpdHttUVDihUsmgUsuh9JGh9LwDZpMdWp0Sao0cEUYdDP4+iDDq0LKNH3z9fBAWoWWSmYiohtijmYjIS1RUVEChUGD06NGQyWRSh0NEREREdM0MGBaJ9l0C8Oxje5B7yoL1X+XAP1CFpBFNAQCH9pfgh/VnoFRe6G/ndLigUitgKrPjyMESRMfpYfDzwftfJGD3z4Uw+Pvg/omxUl4SEdFNh4lmIiIvcebMGURFRaF///5Sh0JEREREdM3Z7QLij07MuafKsfCVQ/jlp3xM/3t7aLQKZGaUwekUUKnksArAJQRsFS4olcDZ3ArofX3Qoo0/bu0f7j5m6Xkbvll9CkofGe682witlmkUIqLL4dAZREReoKKiAi6XCyNGjIBer5c6HCIiIiKia84YrcftQyJgrXCiuMgG/0AVjqeX4bv/nUZcKwP0vkq4XAKhERqoNXI4HQIAIJMDEIBGq0CTULXHMRctSMOGtafwf1/mYPm/MiS4KiKimwc/iiMi8gKnTp1CXFwcHnjgAalDISIiIiK6pkxldqz+TxasVhf+cn807rynGZ6etAcu14VE8s5tZ7H4tTQU5luh9JHBWuFC5x5BcLkEjhw8D2uFCxqtAn+b08E9tEal0znl7uUzpywNel1ERDcb9mgm8kJCJsPBoCAcDAqC4Fi9jV55+YXG8YQJE2AwGCSOhoiIiIjo2vr3vzKw+dtcbN98Fu8uOIyQUC0mz2iN0HANgpqo8H9f5uDEsTKYyuzQapVoFq1H5+5B0GmVUKnkiG1tgM5XiXfmHcaP3+V6HHvYX5oBAORyGYaOairF5RER3TTYo5nIC9kUCjyfmCh1GNQAKioqkJWVhXbt2uGOO+6QOhwiIiIiomvuXIH1kuWMtFLk51XgUGoxrFYX5DLA5RQwm+w4m2tB+qHziDDqIJMD5wptyM0ph1Ihx4rFGWjR2gBjjC8A4M7RRiT0DYVCIUNAoEqS6yMiulmwRzMRUSNks9mQlZWF7OxstGjRAq+99ho0Go3UYRERERERXXMj742Cj0oOuVyG0Q/EAAC2/tEzWekjh1argEIpg1+ADxJvD4NwAScyTMg+YcKY8bEwGJTw8/dBWKQGQgBmk8Pj+MFN1EwyExHVAHs0ExE1Ik6nEwUFBSguLkZUVBRGjBiB5ORkBAYGSh0aEREREdF10a1XMJZ8ngCnU0CrvZDmiInzRcqv56DTK+EX4ANLuROdugUiP88Ck8kOCCDIpMIdf2mG/kMj8PZLh5BxpBSJ/ULRur2/xFdERHRzYqKZyAupHQ58tGULAGBi//6wKvmn4GbndDpx5swZFBcXIzIyEpMmTcIjjzyC4OBgqUMjIiIiIrruVCqFx+t+SRHY8WM+NFoFzhVUIKq5LwrzrSjMt6JVW3/YbC70SGwCmUwGnU6JF17tLFHkRESNB7NLRF7K32aTOgSqJyEESktLkZeXB5fLhZCQENx1111ITk5GTEyM1OEREREREUnmTE45wiO1AICTmSak/HYOFRYnNFoFQsI10OoUaNPBD0IIyDhBOhHRNcFEMxHRTaaiogJFRUUoKSmBv78/OnbsiFGjRqFPnz5MMBMRERERAeieEIwfvjkDU6kdWp0C50tsgAAcdoFjR0rRsWsQ1n91CoAMY5KbSx0uEVGjwEQzEdFNwOFwoLCwEOfOnYNWq0VgYCAGDRqE++67D507d2YvDCIiIiLyemkHS3DimAndbwlGq7b+GD0uGu/9Mw0QgEIuA2QyKJUyVFhc7n0yjpRKGDERUePCRDMR0Q1GCAGz2Yzi4mJYrVZ3WUBAAPr3748hQ4Zg6NCh0Ov1EkdKRERERCStcrMDXyzPxNG0Uhw7UgqdTon1/83Gq0t6YNe2ApzKtsBhd8JHJYefvw+ahGkQf2sIck6YAQAJfUMlvgIiosbDKxPNixcvxj//+U/k5eWhc+fOWLRoEeLj46UOi4i8mMViQXFxMcxmM4QQ0Gg0CAkJwaBBgxAaGoqIiAi0a9cOUVFRUodKRERERHTDWLXiBLZ+l4e80xYU5FegQ9dAmMocyD1lgdJHBqfDBadDQOkjx8j7ovH8gk7w8ZEj/dB56PRKRDX3lfoSiIgaDa9LNK9atQozZszA+++/j169emHhwoVISkpCeno6QkP5SSYRXX9WqxUlJSUwm81wOp2QyWRQKBQICgrC8OHD0bFjR0RFRaFTp05Qq9VSh0tEREREdMM6X3JhknO/AB/k51kAIRBh1CO8qRYD74zErp8KcCKjDGq1AmkHSvDtmlMYdV802nQIkDZwIqJGyOsSzW+99RYmTZqECRMmAADef/99fPPNN/j3v/+NWbNmSRwdUcMQMhky/P3dy3T9OJ1OmM1mlJaWwmw2Qy6XQ6lUwmAwIDY2FomJiYiNjUVERATi4+Oh0WikDpmIiIiI6KYx8t4oHDtSCrlchufmd0KbjgEIj9Rg7t9SUJhvRUQzDYRLwD9ABbVGgdLzdpSV2rHsnXScy7di1Nho9ExsIvVlEBE1Cl6VaLbZbNi7dy+ee+45d5lcLsfAgQOxa9cuCSMjalg2hQIz+vSROoxGx263w2w2o7y8HGazGTKZDEII6PV6hISEYPDgwWjdujVatGiB9u3bIzg4WOqQiYiIiIhuas1bGLDo41vgdAoUn7NBp1dg3+5zKMy/MNeJ0w7cNigcRw+dR0i4BkNHNcOaT7OQ+msRAGDJG0fQ8bMEaDQKKS+DiKhR8KpEc2FhIZxOJ8LCwjzKw8LCcOTIEYmiIqKbhdPpREVFBSwWi/vfymQyACiVSmi1WgQHB6NDhw5o06aN+9/o6GioVCqJr4CIiIiIqPGRyWT4zwfHsGVDLtQaBe4d3xwyGSAEIFfI8ODkODSN0kGhkAMA7Hbh3tflFO72PBER1Y9XJZqJiGqicriLymSyzWZzJ5Q1Gg20Wi3i4uLQtGlTxMTEwGg0Qq/Xw2AwuMtkHJKEiIiIiKhBlJc7sGVDLoQQyMky4z/LjmPsxFicL7ahY7egSyb8u+v+aJzJKUdhfgVGPxADrZapESKia8Gr/po2adIECoUCZ8+e9Sg/e/YswsPDJYqKqOGpnU4s3roVADClXz9YFd73NTGXy4Xy8nJUVFTAZrOhoqICDocDcvmFXg56vR46nQ4xMTGIj49Hs2bNoNPpEB0djebNm8NgMEh8BUREREREBAAajQKBwSocPVyK09lmOB0urPs8G29+2BN6X59Ltg9uosbsf3Zp+ECJiBo5r0o0q1QqdO/eHZs3b8aoUaMAXEg2bd68GVOnTpU2OKKGJATCLBb3cmNWOW6yw+GAxWKB3W6HzWaDj48P1Go1tFotQkJCEBUVhZYtWyIqKgrBwcGIiopCXFwcFF6YhCciIiIiutEd2l+M9V/lICRMg/sficOseZ3wyrP74XIJhIZrUG524HyJvdpEMwCczjFj0YI0lJXa8cDkOCTcFtrAV0BE1Ph4VaIZAGbMmIHk5GT06NED8fHxWLhwIcxmMyZMmCB1aERUTxaLBSaTCRaLBVar1T18hcFggEqlQlRUFGJjYxEeHo6YmBi0a9cOcXFx0Ov1EkdOREREREQ1VVHhxMJXDsNa4QQAaHVKjH04FrPmdcKC5w/AVGpHj8QmiGiqvewxvlyZhTM55QCAj949ilv6hHD4OyKievK6RPO9996LgoICzJ49G3l5eejSpQs2btx4yQSBRHRjE0LAYrGgqKgIFosFLpcLarUaBoMBRqMR8fHxiI2NRUREBFq1aoWIiAgolV73J4+IiIiIqNFx2F3uJDMAmMrsAABjtB5vfRSPsvN2NAlVXzFxrFLJPZaZZCYiqj+vzLpMnTqVQ2UQ3UScTidMJhNMJhPOnz8PlUoFIQTUajWaNGmC+Ph4xMXFoVWrVujWrRt8fX2vflAiIiIiIrop+Rp8cPeDMVj7+UkEh6gx/J4o9zqNRgGN5urD393/SCysFU6UldoxJrn59QyXiMhreGWimYhubEIIlJWVobS0FGazGQAQEBCAkJAQDBs2DP7+/oiNjUXz5s3Rrl07aDQaiSMmIiIiIqKGNGJMFIbfY7xsT+Svv8zGhrWnEGnUYdoL7eDnr/JYHxikxozZHRoiVCIir8FEMxHdEBwOB0pKSpCfnw8hBAIDAxEaGoq+ffuiVatW6NChA1q1agW5XH71gxERERERUaN3uSRzYX4FvvokCwCQkVaKDWtP4d7xsQ0YGRGRd2KimcgbyWTIrhxeQsKxyEpLS1FcXAyz2QwfHx8EBASgd+/eGDBgADp06IBu3bpxrDQiIiIiIqoVhVIGuVwGl0sAAFTqqw+lQURE9cdEM5EXsioUmNKvnyTndrlcKCwsRFFRETQaDeLi4pCYmIhWrVohMTERoaGhksRFRERERESNQ2CQGpOmt8L3/3cGkUYdht7VTOqQiIi8AhPNRNQgLBYLCgoKYLFYEBQUhDvvvBMjRozAbbfdBoWCPQyIiIiIiKj2TGV2nCuwolm0DgrFn8Ps9b49DL1vD5MwMiIi78NEMxFdV0VFRcjLy4NOp0OTJk0wevRoDB06FHFxcVKHRkREREREN7GTmSa8Mms/ck6YENXcF+9+3AsaDdMcRERS4V9gIi+kdjrx1s8/AwBm9OkD6zXuUWyz2VBYWIiSkhL4+vqiZ8+emDp1Krp27Qq9Xn9Nz0VERETXjtVqRa9evbB//36kpKSgS5cuUodERHRZO7fmI+1ACc4X23A6uxwL5x3GrJc7SR0WEZHXYqKZyBsJgSiTyb18rbhcLpw4cQJ2ux2RkZHuoTH69u0LuVx+9QMQERGRpJ555hlERkZi//79UodCRHRVxhg9ys0OAIBSKUd+boXEEREReTcmmomo3oQQKCoqQn5+PkJDQ5GUlIRp06YhICBA6tCIiIiohjZs2IDvv/8eq1evxoYNG6QOh4joqm7tH4bRD0Tjxw15CAxWof+QCKlDIiLyakw0E1G9mM1m5OTkwM/PD3fccQf++te/ol27dlKHRURERLVw9uxZTJo0CevWrYNOp5M6HCKiGnthQReMfbgMCoUM0bG+UodDROTVmGgmojoxm804deoUZDIZunbtimeffRbdunWDTCaTOjQiIiKqBSEExo8fj0cffRQ9evRAVlbWVfexWq2wWq3u16WlpdcxQiKiK4ttaUDpeRs+XnoMMhkw6r5oGPx8pA6LiMjrMNFMRLVisVhw6tQp+Pj4oFWrVhg1ahTGjBkDPz8/qUMjIiKiKmbNmoXXXnvtitukpaXh+++/R1lZGZ577rkaH3vBggWYO3dufUMkIqq1kmIbNqw9Ba1OgaF3NYNafWFi88WvH0HagRIAQH5uBf42p4OEURIReScmmonoqoQQKC4uRkFBAXx8fGA0GvHkk09i6NChUCr5Z4SIiOhG9Le//Q3jx4+/4jaxsbHYsmULdu3aBbVa7bGuR48eGDduHFauXHnJfs899xxmzJjhfl1aWgqj0XhN4iYiupK3Xz6EExllAIDCfCseebIVAKAgz+Le5myupdp9iYjo+mKGiMgbyWQ4q9W6l6+kqKgIZ8+ehcFgQGJiIu6//37ceuutHL+RiIjoBhcSEoKQkJCrbvfuu+/ilVdecb8+c+YMkpKSsGrVKvTq1avafdRq9SWJaSKihnAmp7za5RH3RmHF4mOADBh5b5QUoREReT0mmom8kFWhwCMDBlx2vdPphNlsRm5uLrRaLXr37o0JEyagb9++HIOZiIiokYmK8kzI+PpemEwrLi4OzZo1kyIkIqLLGnpXU6z7PBtyhQyDhke6y/sNjkCPhCaQyQC9L8dnJiKSAhPNRATgwvAYJSUlyM/Ph0wmg6+vLzp06IDk5GSMGDGCCWYiIiIiIpLcX+6PQZ8B4fBRyREQqPJY52tggpmISEpMNBMRhBDIyMiASqVCv379cNttt6Fr165o27Yt5HK51OERERFRA4qJiYEQQuowiIguKyRMI3UIRERUDSaaibyQyunEqzt3AgBmxscjPTsbQUFBmDx5MsaPH8/ey0REREREREREVCtMNBN5IZkQaHn+PADg2NGjCI+JwTPPPINhw4ZJHBkREREREREREd2MmGgm8nLDhg3D9BdeQNOmTaUOhYiIiIiIiIiIblJMNBN5ofz8fPfyvHnzoAoMlDAaIiIiIiKimjOb7Fjz2UnYrC6MvC8KTUI4ZjMR0Y2AiWYiL3Pu3DmUl5a6X6tUqitsTUREREREdGNZvvgYft1eAAA4mWnCS293kzgiIiICALnUARBRw6moqEBeXh5uu+02qUMhIiIiIiKqk4KzFe7lwirLREQkLSaaibyEEAIZGRmIjY3FK6+8InU4REREREREdTLy3ij4qOSQyYDRD8RIHQ4REf2BQ2cQeYnTp08jJCQE06dPh5+fH9CkidQhERERERER1Vq3XsFY/GkCXE4BnZ5pDSKiGwX/IhN5gYKCAlitVowZMwZ33nlnZaG0QREREREREdWRRqOQOgQiIroIh84gauTMZjMKCwtx9913Y+bMmVKHQ0REREREREREjRATzUSNmBACWVlZ6NixI/72t7/Bx8dH6pCIiIiIiIiIiKgRYqKZqJESQuDkyZMICgrC008/DX9//z9XWixAv34XfiwWqUIkIiIiIiIiIqJGgmM0EzVCQgicPn0aSqUSM2fOREJCgucGLhewbdufy0RERERERERERPXAHs1EjdDJkycBAOPHj8d9990HmUwmcURERERERERERNSYsUczUSNTWloKh8OBadOmYeLEiVKHQ0REREREREREXoA9mokakeLiYpw6dQr9+/fHAw88wJ7MRERERERERETUINijmagREEKgoKAApaWl6NevH15//XVoNBqpwyIiIiIiIiIiIi/BHs1ENzmTyYSDBw/C6XRi7NixWLp0KfR6vdRhERERERERERGRF2GPZqKb2NmzZ1FUVITOnTtjzpw56NatW82Hy9Dprm9wRERERERERETkNZhoJrpJ5eXlwWKxYMyYMXjuuedgMBhqvrNeD5jN1y84IiIiIiIiIiLyKkw0E91EhBAoLi5GQUEBDAYD7r33Xjz//PNQKBRSh0ZERERERERERF6MiWaim4Ddbsf58+eRn5+PwMBAxMfHY/LkyejTp0/Nh8ogIiIiIiIiIiK6TphoJroBOZ1OlJaWorS0FGVlZdBoNDAYDEhISMD06dPRo0eP+p2gogIYPfrC8urVgEZT/6CJiIiIiIiIiMhrMdFMJAEhBFwul/vfiooKWCwWWCwW2Gw2AICfnx+MRiN69uyJnj17omPHjjAajdemB7PTCXz77Z/LRERERERERERE9cBEM9FlCCE8EsLVvXY4HKioqIDNZnOXV+7rcrncZXK5HDKZzGO9XC4HACgUCqhUKuj1esTFxSEuLg7dunVD586dERsby6ExiIiIiIiIiIjohsdEs8Qqk5VOp/OShGbVxGbVpOXVjneldVUTnfWJuT4xXBxLXfap7loqE7Iymaza5OzF210p7srjy+Vyd5IYgMdrmUwGhUIBrVaL5s2bQ6/XQ6FQQKFQQC6XQ6fTwWAwQK1WQ6PRQK1WQ6/XQ6PRIDAwEGq1GnK5HGq1GgEBAYiNjeWkfkREREREREREdFNiorkGXC4XysvL3cMblJWVwWazobS0FOXl5e5tKpPCZrMZVqsVAJCVlYXS0tJqk6GVyUylUulOTlYmMKv+VCY3lUrlJceodHHZxesqf9Rq9SX7XLzdxa50novLLi6v7LV7cRxKpRI+Pj7udVWTuVVfVy1TqVTu90qhUHgsy+Vy97+VSV2lUnnJcases+py5f6Vx618vyuTxFXPodVq3efWaDQICwtjgpiIiIiIiIiIiLzaTZdoFkLA6XTCbrfD4XDA5XLB6XRCCAG73Q673Q6XywWr1QqHwwGHwwGLxYLS0lKYTCZ3eWUPYbvdDrPZjJKSEneC2GKx4Ny5c7BYLKioqIDdbnf3OHY6ne79K3siA9UnduVyOXr06IHOnTtDoVDAYDBAo9FAq9V69HANCgqCXq93J1KrJp6VSiVUKhW0Wi3UajWHUSAiIiIiIiIiIqIbjqSJ5pUrV0KtVqOiosKd0LXb7bDZbLBarSgpKYHJZHInecvLy2GxWKodZgK4dIK1ynWVyWHg0l63F4+ZW5kgrprsrezJWtnT1cfHx73NxT1mqzp69CiefPJJJCUlXed3koiIiIiIiIiIiEg6kiSaK5O7b731FuRyea3GIK6NqsM0VCaNr3T8yt7JAGCz2ep9frlcDrPZjNLS0nofi+iaMpv/XC4tBarc+0RERPVR2e65lm06uvFV1jfbvURERESNT03b+DIhwVNAZmYm4uLiGvq0RERERNRAjh8/jtjYWKnDoAZy6tQpGI1GqcMgIiIiousoJycHzZo1u+x6SXo0BwUFAQCys7Ph7+8vRQjXXWlpKYxGI3JycuDn5yd1OFQPrMvGhfXZeLAuGw/WZeNy/vx5REVFudt75B0iIyORk5MDg8Hg1XOK8O8ZVcV89JGdAAAkJElEQVT7gS7Ge4Kq4v1AVd3o94MQAmVlZYiMjLzidpIkmuVyOQDA39//hnzzriU/P79Gf43egnXZuLA+Gw/WZePBumxcKtt75B3kcvkVe7d4G/49o6p4P9DFeE9QVbwfqKob+X6oSWdhPgEQERERERERERERUb0w0UxERERERERERERE9SJJolmtVmPOnDlQq9VSnL5BeMM1egvWZePC+mw8WJeNB+uycWF9kjfj/U9V8X6gi/GeoKp4P1BVjeV+kAkhhNRBEBEREREREREREdHNi0NnEBEREREREREREVG9MNFMRERERERERERERPXCRDMRERERERERERER1QsTzURERERERERERERULw2SaC4qKsK4cePg5+eHgIAATJw4ESaT6Yr7fPDBB+jXrx/8/Pwgk8lQUlLSEKHWyuLFixETEwONRoNevXrh119/veL2//3vf9GmTRtoNBp07NgR3377bQNFSldTm7pctmwZ+vTpg8DAQAQGBmLgwIFXrXtqWLX93az0xRdfQCaTYdSoUdc3QKqx2tZlSUkJpkyZgoiICKjVarRq1Yp/a28Qta3LhQsXonXr1tBqtTAajXjqqadQUVHRQNHS5fz0008YPnw4IiMjIZPJsG7duqvus3XrVnTr1g1qtRotWrTAihUrrnucRFLLysrCxIkT0bx5c2i1WsTFxWHOnDmw2WxSh0YSmTdvHhITE6HT6RAQECB1OCSBuj6jUONTl/YUNV4LFixAz549YTAYEBoailGjRiE9PV3qsOqsQRLN48aNw6FDh7Bp0yasX78eP/30EyZPnnzFfcrLyzFkyBA8//zzDRFira1atQozZszAnDlzsG/fPnTu3BlJSUnIz8+vdvudO3di7NixmDhxIlJSUjBq1CiMGjUKv//+ewNHTherbV1u3boVY8eOxY8//ohdu3bBaDRi8ODBOH36dANHTtWpbX1WysrKwsyZM9GnT58GipSuprZ1abPZMGjQIGRlZeGrr75Ceno6li1bhqZNmzZw5HSx2tblZ599hlmzZmHOnDlIS0vDRx99hFWrVt2wbQJvYjab0blzZyxevLhG2584cQJ33HEHbr/9dqSmpmL69Ol45JFH8N13313nSImkdeTIEbhcLixduhSHDh3C22+/jffff59/x7yYzWbDPffcg8cee0zqUEgCdX1Gocaptu0paty2bduGKVOm4JdffsGmTZtgt9sxePBgmM1mqUOrG3GdHT58WAAQv/32m7tsw4YNQiaTidOnT191/x9//FEAEMXFxdcxytqLj48XU6ZMcb92Op0iMjJSLFiwoNrtx4wZI+644w6Psl69eom//vWv1zVOurra1uXFHA6HMBgMYuXKldcrRKqFutSnw+EQiYmJ4sMPPxTJycli5MiRDRApXU1t63LJkiUiNjZW2Gy2hgqRaqi2dTllyhTRv39/j7IZM2aI3r17X9c4qXYAiLVr115xm2eeeUa0b9/eo+zee+8VSUlJ1zEyohvT66+/Lpo3by51GCSx5cuXC39/f6nDoAZW32dOarxq0p4i75Kfny8AiG3btkkdSp1c9x7Nu3btQkBAAHr06OEuGzhwIORyOXbv3n29T39d2Gw27N27FwMHDnSXyeVyDBw4ELt27ap2n127dnlsDwBJSUmX3Z4aRl3q8mLl5eWw2+0ICgq6XmFSDdW1Pl966SWEhoZi4sSJDREm1UBd6vLrr79GQkICpkyZgrCwMHTo0AHz58+H0+lsqLCpGnWpy8TEROzdu9f9ldLMzEx8++23GDZsWIPETNcO2z9Efzp//jzbi0Re6Fo8cxKR9zh//jwA3LRtBuX1PkFeXh5CQ0M9T6pUIigoCHl5edf79NdFYWEhnE4nwsLCPMrDwsJw5MiRavfJy8urdvub9T1oLOpSlxd79tlnERkZecmDNDW8utTn9u3b8dFHHyE1NbUBIqSaqktdZmZmYsuWLRg3bhy+/fZbHDt2DI8//jjsdjvmzJnTEGFTNepSl/fffz8KCwtx6623QggBh8OBRx99lF85vwldrv1TWloKi8UCrVYrUWREDevYsWNYtGgR3njjDalDIaIGdi2eOYnIO7hcLkyfPh29e/dGhw4dpA6nTurco3nWrFmQyWRX/OEfTWrsXn31VXzxxRdYu3YtNBqN1OFQLZWVleHBBx/EsmXL0KRJE6nDoXpyuVwIDQ3FBx98gO7du+Pee+/FCy+8gPfff1/q0KiWtm7divnz5+O9997Dvn37sGbNGnzzzTd4+eWXpQ6NiLxcXZ6BTp8+jSFDhuCee+7BpEmTJIqcrgc+ExMR0bU0ZcoU/P777/jiiy+kDqXO6tyj+W9/+xvGjx9/xW1iY2MRHh5+yQD3DocDRUVFCA8Pr+vpJdWkSRMoFAqcPXvWo/zs2bOXvabw8PBabU8Noy51WemNN97Aq6++ih9++AGdOnW6nmFSDdW2Po8fP46srCwMHz7cXeZyuQBc+OZFeno64uLirm/QVK26/G5GRETAx8cHCoXCXda2bVvk5eXBZrNBpVJd15ipenWpy3/84x948MEH8cgjjwAAOnbsCLPZjMmTJ+OFF16AXN4gcxnTNXC59o+fnx97M9NNqabPQJXOnDmD22+/HYmJifjggw+uc3TU0Gp7P5B3qs8zJxF5j6lTp2L9+vX46aef0KxZM6nDqbM6P6mFhISgTZs2V/xRqVRISEhASUkJ9u7d6953y5YtcLlc6NWr1zW5iIamUqnQvXt3bN682V3mcrmwefNmJCQkVLtPQkKCx/YAsGnTpstuTw2jLnUJAK+//jpefvllbNy40WP8cZJWbeuzTZs2OHjwIFJTU90/I0aMwO23347U1FQYjcaGDJ+qqMvvZu/evXHs2DH3hwUAcPToUURERDDJLKG61GV5efklyeTKDxCEENcvWLrm2P6hxqamz0DAhZ7M/fr1Q/fu3bF8+XJ+SNYI1eZ+IO9V12dOIvIOQghMnToVa9euxZYtW9C8eXOpQ6qfhphxcMiQIaJr165i9+7dYvv27aJly5Zi7Nix7vWnTp0SrVu3Frt373aX5ebmipSUFLFs2TIBQPz0008iJSVFnDt3riFCvqovvvhCqNVqsWLFCnH48GExefJkERAQIPLy8oQQQjz44INi1qxZ7u137NghlEqleOONN0RaWpqYM2eO8PHxEQcPHpTqEugPta3LV199VahUKvHVV1+J3Nxc909ZWZlUl0BV1LY+L5acnCxGjhzZQNHSldS2LrOzs4XBYBBTp04V6enpYv369SI0NFS88sorUl0C/aG2dTlnzhxhMBjE559/LjIzM8X3338v4uLixJgxY6S6BPpDWVmZSElJESkpKQKAeOutt0RKSoo4efKkEEKIWbNmiQcffNC9fWZmptDpdOLpp58WaWlpYvHixUKhUIiNGzdKdQlEDeLUqVOiRYsWYsCAAeLUqVMebUbyTidPnhQpKSli7ty5wtfX1/23lM8Q3uFqbSHyLldrT5F3eeyxx4S/v7/YunWrR3uhvLxc6tDqpEESzefOnRNjx44Vvr6+ws/PT0yYMMHjf6gnTpwQAMSPP/7oLpszZ44AcMnP8uXLGyLkGlm0aJGIiooSKpVKxMfHi19++cW9rm/fviI5Odlj+y+//FK0atVKqFQq0b59e/HNN980cMR0ObWpy+jo6GrvzTlz5jR84FSt2v5uVsVE842ltnW5c+dO0atXL6FWq0VsbKyYN2+ecDgcDRw1Vac2dWm328WLL74o4uLihEajEUajUTz++OOiuLi44QMnDz/++GO1/w+srL/k5GTRt2/fS/bp0qWLUKlUIjY29oZqyxFdL8uXL6/2d6WB+vnQDSg5Obna+6HqMzA1bldqC5F3uVp7irzL5doLN2ubWSYEv4NKRERERERERERERHXHgcKIiIiIiIiIiIiIqF6YaCYiIiIiIiIiIiKiemGimYiIiIiIiIiIiIjqhYlmIiIiIiIiIiIiIqoXJpqJiIiIiIiIiIiIqF6YaCYiIiIiIiIiIiKiemGimYiIiIiIiIiIiIjqhYlmokZi69atkMlkKCkpabBzvvjii+jSpYv79fjx4zFq1Cj36379+mH69OkNFk9jJoTA5MmTERQUBJlMhtTU1GrLavOeS3HPXEsrVqxAQECA1GEQERERUSPy4osvIiwsDDKZDOvWrWuQ81V9prrZ5OXlYdCgQdDr9WybExETzUQ3A5lMdsWfF198UZK4Zs6cic2bN0ty7tq4XEL1ZkqEb9y4EStWrMD69euRm5uLDh06VFu2Zs0avPzyyzU6ZmJiInJzc+Hv73/N4szKynInvYmIiIioeuPHj6+2XX/s2LFrcnx+IF83aWlpmDt3LpYuXYrc3FwMHTr0mh6/oZLXALBmzRoMHjwYwcHBdWqfx8TEYOHChVfd7u2330Zubi5SU1Nx9OjRugVbj/MT0Y1FKXUARHR1ubm57uVVq1Zh9uzZSE9Pd5f5+vpiz549DR6Xr68vfH19G/y83uj48eOIiIhAYmLiFcuCgoJqfEyVSoXw8PBrGicRERER1cyQIUOwfPlyj7KQkBCJork8u90OHx8fqcNoEMePHwcAjBw5EjKZrM7HuRHeM7PZjFtvvRVjxozBpEmTrtt5jh8/ju7du6Nly5bX7Rz1YbPZoFKppA6DyGuwRzPRTSA8PNz94+/vD5lM5lFWNdm7d+9e9OjRAzqdDomJiR4JaQD43//+h27dukGj0SA2NhZz586Fw+G47Lm3bt2K+Ph491ehevfujZMnTwKo2de8XC4XnnnmGQQFBSE8PPyS3tfZ2dkYOXIkfH194efnhzFjxuDs2bPu9RcPxwEA06dPR79+/TzOsWDBAjRv3hxarRadO3fGV199BeBCD9vbb78dABAYGAiZTIbx48dj/Pjx2LZtG9555x13D5KsrCwAwO+//46hQ4fC19cXYWFhePDBB1FYWHjF69yxYwf69esHnU6HwMBAJCUlobi4GABgtVrx5JNPIjQ0FBqNBrfeeit+++03j/2vdM7x48fjiSeeQHZ2NmQyGWJiYqotAy7tpW21WvHss8/CaDRCrVajRYsW+OijjwBU39N7+/bt6NOnD7RaLYxGI5588kmYzWb3+piYGMyfPx8PP/wwDAYDoqKi8MEHH7jXN2/eHADQtWtXyGQyj3qqWl/NmjXDkiVLPMpTUlIgl8vd99dbb72Fjh07Qq/Xw2g04vHHH4fJZLpsHdT3XgGA4uJijBs3DiEhIdBqtWjZsuUlD4BERERE14JarfZo04eHh0OhUAC4epv9Su2krVu3YsKECTh//vwl34CsrkdtQEAAVqxYAeDPb6etWrUKffv2hUajwaeffgoA+PDDD9G2bVtoNBq0adMG77333hWv76uvvkLHjh2h1WoRHByMgQMHutuVle22uXPnIiQkBH5+fnj00Udhs9nc+2/cuBG33norAgICEBwcjDvvvNOdCK506tQpjB07FkFBQdDr9ejRowd2797tXl+bZ58XX3wRw4cPBwDI5XJ3otnlcuGll15Cs2bNoFar0aVLF2zcuNG935Xes6oq2+t33XWXR/u90ieffIKYmBj4+/vjvvvuQ1lZmXvd1dqw1XnwwQcxe/ZsDBw4sNr1Qgi8+OKLiIqKglqtRmRkJJ588kkAF54pTp48iaeeesp9D1UnJiYGq1evxscff+x+zgKAkpISPPLII+667d+/P/bv3+/e7/jx4xg5ciTCwsLg6+uLnj174ocffnCvv9z5q3v+XLhwocd7WXlvzZs3D5GRkWjdujUAICcnB2PGjEFAQACCgoIwcuRI9/MfEV07TDQTNTIvvPAC3nzzTezZswdKpRIPP/ywe93PP/+Mhx56CNOmTcPhw4exdOlSrFixAvPmzav2WA6HA6NGjULfvn1x4MAB7Nq1C5MnT67Vp/srV66EXq/H7t278frrr+Oll17Cpk2bAFxoMI0cORJFRUXYtm0bNm3ahMzMTNx77721uuYFCxbg448/xvvvv49Dhw7hqaeewgMPPIBt27bBaDRi9erVAID09HTk5ubinXfewTvvvIOEhARMmjQJubm5yM3NhdFoRElJCfr374+uXbtiz5492LhxI86ePYsxY8Zc9vypqakYMGAA2rVrh127dmH79u0YPnw4nE4nAOCZZ57B6tWrsXLlSuzbtw8tWrRAUlISioqKAOCq53znnXfcjdvc3Fz89ttv1ZZV56GHHsLnn3+Od999F2lpaVi6dOlle6EfP34cQ4YMwejRo3HgwAGsWrUK27dvx9SpUz22e/PNN9GjRw+kpKTg8ccfx2OPPeb+QOPXX38FAPzwww/Izc3FmjVrLjmPXC7H2LFj8dlnn3mUf/rpp+jduzeio6Pd27377rs4dOgQVq5ciS1btuCZZ565bD3UxJXuFQD4xz/+gcOHD2PDhg1IS0vDkiVL0KRJk3qdk4iIiKg2atJmv1I7KTExEQsXLoSfn5+7nTtz5sxaxTBr1ixMmzYNaWlpSEpKwqefforZs2dj3rx5SEtLw/z58/GPf/wDK1eurHb/3NxcjB07Fg8//DDS0tKwdetW/OUvf4EQwr3N5s2b3es+//xzrFmzBnPnznWvN5vNmDFjBvbs2YPNmzdDLpfjrrvugsvlAgCYTCb07dsXp0+fxtdff439+/fjmWeeca+v7bPPzJkz3R0MKt834EJb/M0338Qbb7yBAwcOICkpCSNGjEBGRsYV37OLVbbXly9ffkn7/fjx41i3bh3Wr1+P9evXY9u2bXj11Vfd66/Whq2L1atX4+2338bSpUuRkZGBdevWoWPHjgAuDLvRrFkzvPTSSx7vRXXXNGTIEIwZM8b9nAUA99xzD/Lz87Fhwwbs3bsX3bp1w4ABA9zPPyaTCcOGDcPmzZuRkpKCIUOGYPjw4cjOzq7V+S9n8+bNSE9Px6ZNm7B+/XrY7XYkJSXBYDDg559/xo4dO+Dr64shQ4Z4fLhBRNeAIKKbyvLly4W/v/8l5T/++KMAIH744Qd32TfffCMACIvFIoQQYsCAAWL+/Pke+33yySciIiKi2nOdO3dOABBbt26tdv2cOXNE586d3a+Tk5PFyJEj3a/79u0rbr31Vo99evbsKZ599lkhhBDff/+9UCgUIjs7273+0KFDAoD49ddfqz2mEEJMmzZN9O3bVwghREVFhdDpdGLnzp0e20ycOFGMHTtWCPHne1NcXOyxTd++fcW0adM8yl5++WUxePBgj7KcnBwBQKSnp1f7PowdO1b07t272nUmk0n4+PiITz/91F1ms9lEZGSkeP3112t8zrfffltER0d7bFNdWdVrSk9PFwDEpk2bqo3t4vdl4sSJYvLkyR7b/Pzzz0Iul7vvoejoaPHAAw+417tcLhEaGiqWLFkihBDixIkTAoBISUmp9pyVUlJShEwmEydPnhRCCOF0OkXTpk3dx6nOf//7XxEcHOx+ffHvwrW4V4YPHy4mTJhwxdiJiIiI6is5OVkoFAqh1+vdP3fffbcQovZtdiGu3k6qBECsXbvWo8zf318sX75cCPFnW27hwoUe28TFxYnPPvvMo+zll18WCQkJ1cazd+9eAUBkZWVVuz45OVkEBQUJs9nsLluyZInw9fUVTqez2n0KCgoEAHHw4EEhhBBLly4VBoNBnDt3rtrt6/I+rl27VlycJomMjBTz5s3zKOvZs6d4/PHHhRCXf8+qU937P2fOHKHT6URpaam77Omnnxa9evUSQtSsDXsll2ufv/nmm6JVq1bCZrNVu190dLR4++23r3r8kSNHiuTkZPfrn3/+Wfj5+YmKigqP7eLi4sTSpUsve5z27duLRYsWXfH8Fz9/CnHpM1FycrIICwsTVqvVXfbJJ5+I1q1bC5fL5S6zWq1Cq9WK77777qrXSEQ1xzGaiRqZTp06uZcjIiIAAPn5+YiKisL+/fuxY8cOj0/xnU4nKioqUF5eDp1O53GsoKAgjB8/HklJSRg0aBAGDhyIMWPGuI9b23gqY8rPzwdwYbINo9EIo9HoXt+uXTsEBAQgLS0NPXv2vOrxjx07hvLycgwaNMij3GazoWvXrjWOs9L+/fvx448/Vtvr9/jx42jVqtUl5ampqbjnnnuqPd7x48dht9vRu3dvd5mPjw/i4+ORlpZW53PWRGpqKhQKBfr27Vuj7ffv348DBw54fNVPCAGXy4UTJ06gbdu2ADzrtHIYl8o6rakuXbqgbdu2+OyzzzBr1ixs27YN+fn5Hu/jDz/8gAULFuDIkSMoLS2Fw+G47L1aEzW5Vx577DGMHj0a+/btw+DBgzFq1CiPMbCJiIiIrpXbb7/dYygxvV4PADVqs1/rdtLFevTo4V42m804fvw4Jk6c6DHWr8PhuOyk0p07d8aAAQPQsWNHJCUlYfDgwbj77rsRGBjosU3VWBMSEmAymZCTk4Po6GhkZGRg9uzZ2L17NwoLC909lbOzs9GhQwekpqaia9eul52jpLbPPtUpLS3FmTNnPNryANC7d2+PoSAAz/estmJiYmAwGNyvqz4zXevnnUr33HMPFi5ciNjYWAwZMgTDhg3D8OHDoVTWL020f/9+mEwmBAcHe5RbLBb30CcmkwkvvvgivvnmG+Tm5sLhcMBisbh7NNdXx44dPcZl3r9/P44dO+bxHgNARUXFJcOxEFH9MNFM1MhUnXSi6rhiwIX/oc+dOxd/+ctfLtlPo9FUe7zly5fjySefxMaNG7Fq1Sr8/e9/x6ZNm3DLLbfUOp7KmCrjqQm5XO7xFTvgwuQalSrHovvmm2/QtGlTj+3UanWNz1P1eMOHD8drr712ybrLJdi1Wm2tz1Pfc9ZEbeMymUz461//6h6braqoqCj3cn3rtNK4cePciebPPvsMQ4YMcTdIs7KycOedd+Kxxx7DvHnzEBQUhO3bt2PixImw2WzVPhhci3tl6NChOHnyJL799lts2rQJAwYMwJQpU/DGG2/U+vqIiIiIrkSv16NFixaXlF+tzV6XdlIlmUx2xfZS1diqxgMAy5YtQ69evTy2qxxT+mIKhQKbNm3Czp078f3332PRokV44YUXsHv3bvecHlczfPhwREdHY9myZYiMjITL5UKHDh3cQx1cra1bl2ef+qj6ntXWldrX1/p5p5LRaER6ejp++OEHbNq0CY8//jj++c9/Ytu2bfWayNBkMiEiIgJbt269ZF1AQACAC8OUbNq0CW+88QZatGgBrVaLu++++6rDWFytvV/p4rowmUzo3r17tWNn34gTcBLdzJhoJvIi3bp1Q3p6erUN2ivp2rUrunbtiueeew4JCQn47LPPapxovpK2bdsiJycHOTk57l7Nhw8fRklJCdq1awfgwv/4f//9d4/9UlNT3Y2fdu3aQa1WIzs7+7I9dys/za4cM7lq+cVl3bp1w+rVqxETE1PjT/M7deqEzZs3e4wpVykuLg4qlQo7duxwjz1st9vx22+/uSftq8s5a6Jjx45wuVzYtm3bZScBqapbt244fPhwre+Pqi73Xlfn/vvvx9///nfs3bsXX331Fd5//333ur1798LlcuHNN9+EXH5hOoEvv/zyise7FvdK5XGSk5ORnJyMPn364Omnn2aimYiIiBrM1drsNWknVdfOBS60c6qOd5uRkYHy8vIrxhMWFobIyEhkZmZi3LhxNb4OmUyG3r17o3fv3pg9ezaio6Oxdu1azJgxA8CFXqYWi8WdMP7ll1/g6+sLo9GIc+fOIT09HcuWLUOfPn0AXJi0uqpOnTrhww8/RFFRUbW9muv67FOVn58fIiMjsWPHDo/2444dOxAfH1/r4/n4+NSonVxVTduwdaHVajF8+HAMHz4cU6ZMQZs2bXDw4EF069btsvfQ1XTr1g15eXlQKpWXTHhYaceOHRg/fjzuuusuABcSwRdPzFfd+UNCQpCXlwchhLtTVWpqao1iWrVqFUJDQ+Hn51frayKimuNkgEReZPbs2fj4448xd+5cHDp0CGlpafjiiy/w97//vdrtT5w4geeeew67du3CyZMn8f333yMjI8M9hEJ9DRw4EB07dsS4ceOwb98+/Prrr3jooYfQt29f91fP+vfvjz179uDjjz9GRkYG5syZ45FMNBgMmDlzJp566imsXLkSx48fx759+7Bo0SL35CTR0dGQyWRYv349CgoK3L0CYmJisHv3bmRlZbm/jjdlyhQUFRVh7Nix+O2333D8+HF89913mDBhwmUbWs899xx+++03PP744zhw4ACOHDmCJUuWoLCwEHq9Ho899hiefvppbNy4EYcPH8akSZNQXl6OiRMnAkCdzlkTMTExSE5OxsMPP4x169bhxIkT2Lp162UTts8++yx27tyJqVOnIjU1FRkZGfjf//53yWSAVxIaGgqtVuue0PD8+fNXjC8xMRETJ06E0+nEiBEj3OtatGgBu92ORYsWITMzE5988olHIro61+JemT17Nv73v//h2LFjOHToENavX3/N7nciIiKimrham70m7aSYmBiYTCZs3rwZhYWF7mRy//798a9//QspKSnYs2cPHn300Rr1Xp07dy4WLFiAd999F0ePHsXBgwexfPlyvPXWW9Vuv3v3bsyfPx979uxBdnY21qxZg4KCAo92lc1mw8SJE3H48GF8++23mDNnDqZOnQq5XI7AwEAEBwfjgw8+wLFjx7BlyxZ3grrS2LFjER4ejlGjRmHHjh3IzMzE6tWrsWvXrhq9jzX19NNP47XXXsOqVauQnp6OWbNmITU1FdOmTavVcYAL9bJ582bk5eWhuLi4RvvUpA1bnaKiIqSmpuLw4cMALkyMnpqairy8PADAihUr8NFHH+H3339HZmYm/vOf/0Cr1bo7x8TExOCnn37C6dOnUVhYWONrHDhwIBISEjBq1Ch8//33yMrKws6dO/HCCy9gz549AICWLVtizZo1SE1Nxf79+3H//fdf8g3J6s7fr18/FBQU4PXXX8fx48exePFibNiw4aoxjRs3Dk2aNMHIkSPx888/u5+LnnzySZw6darG10ZENSDlANFEVHtXmwyw6oR3KSkpAoA4ceKEu2zjxo0iMTFRaLVa4efnJ+Lj48UHH3xQ7bny8vLEqFGjREREhFCpVCI6OlrMnj3bPUFHTSYDvHiyvYsnizh58qQYMWKE0Ov1wmAwiHvuuUfk5eV57DN79mwRFhYm/P39xVNPPSWmTp3qnuBNiAsT0i1cuFC0bt1a+Pj4iJCQEJGUlCS2bdvm3uall14S4eHhQiaTuc+fnp4ubrnlFqHVaj3ep6NHj4q77rpLBAQECK1WK9q0aSOmT5/uMXnExbZu3SoSExOFWq0WAQEBIikpyV0XFotFPPHEE6JJkyZCrVaL3r17uyc7rHS1c9ZlMsDKcz/11FPuOmzRooX497//LYSo/p759ddfxaBBg4Svr6/Q6/WiU6dOHpOfVDcpR+fOncWcOXPcr5ctWyaMRqOQy+Ue9VSd9957TwAQDz300CXr3nrrLRERESG0Wq1ISkoSH3/8sUe81f0u1Pdeefnll0Xbtm2FVqsVQUFBYuTIkSIzM/OK10BERERUW9VNYlzV1drsV2snCSHEo48+KoKDgwUAd1vt9OnTYvDgwUKv14uWLVuKb7/9ttrJAKub2PnTTz8VXbp0ESqVSgQGBorbbrtNrFmzptr4Dx8+LJKSkkRISIhQq9WiVatWHhO9VV7/7NmzRXBwsPD19RWTJk3ymEBu06ZNom3btkKtVotOnTqJrVu3XjKZXlZWlhg9erTw8/MTOp1O9OjRQ+zevbvG7+PFqpsM0Ol0ihdffFE0bdpU+Pj4iM6dO4sNGza419d0MmwhhPj6669FixYthFKpdLfjazLBXU2edy62fPlyAeCSn8p7Ye3ataJXr17Cz89P6PV6ccstt3hMLL9r1y7RqVMnoVarL3lPqrr4+U4IIUpLS8UTTzwhIiMjhY+PjzAajWLcuHHuSeBPnDghbr/9dqHVaoXRaBT/+te/LnmOudz5lyxZIoxGo9Dr9eKhhx4S8+bNu2QywOp+t3Jzc8VDDz3kfiaLjY0VkyZNEufPn7/stRFR7cmEuGiAGyIiIiIiIiKi62T8+PEoKSnBunXrpA6FiIiuIQ6dQURERERERERERET1wkQzEREREREREREREdULh84gIiIiIiIiIiIionphj2YiIiIiIiIiIiIiqhcmmomIiIiIiIiIiIioXphoJiIiIiIiIiIiIqJ6YaKZiIiIiIiIiIiIiOqFiWYiIiIiIiIiIiIiqhcmmomIiIiIiIiIiIioXphoJiIiIiIiIiIiIqJ6YaKZiIiIiIiIiIiIiOqFiWYiIiIiIiIiIiIiqpf/B3e9cALlh13bAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.cm as cm\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from sklearn.cluster import KMeans\n", + "from sklearn.datasets import make_blobs\n", + "from sklearn.metrics import silhouette_samples, silhouette_score\n", + "\n", + "\n", + "for label_name in [\"level1\", \"level2\", \"level3\"]:\n", + " y = test_data.obs[label_name]\n", + " n_clusters = y.nunique()\n", + " # Create a subplot with 1 row and 2 columns\n", + " fig, (ax1, ax2) = plt.subplots(1, 2)\n", + " fig.set_size_inches(18, 7)\n", + "\n", + " # The 1st subplot is the silhouette plot\n", + " # The silhouette coefficient can range from -1, 1 but in this example all\n", + " # lie within [-0.1, 1]\n", + " ax1.set_xlim([-0.1, 1])\n", + " # The (n_clusters+1)*10 is for inserting blank space between silhouette\n", + " # plots of individual clusters, to demarcate them clearly.\n", + " ax1.set_ylim([0, len(X) + (n_clusters + 1) * 10])\n", + "\n", + " # # Initialize the clusterer with n_clusters value and a random generator\n", + " # # seed of 10 for reproducibility.\n", + " # clusterer = KMeans(n_clusters=n_clusters, random_state=10)\n", + " label_encoder = LabelEncoder()\n", + " cluster_labels = label_encoder.fit_transform(y)\n", + "\n", + " # The silhouette_score gives the average value for all the samples.\n", + " # This gives a perspective into the density and separation of the formed\n", + " # clusters\n", + " silhouette_avg = silhouette_score(X, cluster_labels)\n", + " print(\n", + " \"For n_clusters =\",\n", + " n_clusters,\n", + " \"The average silhouette_score is :\",\n", + " silhouette_avg,\n", + " )\n", + "\n", + " # Compute the silhouette scores for each sample\n", + " sample_silhouette_values = silhouette_samples(X, cluster_labels)\n", + "\n", + " y_lower = 10\n", + " for i in range(n_clusters):\n", + " # Aggregate the silhouette scores for samples belonging to\n", + " # cluster i, and sort them\n", + " ith_cluster_silhouette_values = sample_silhouette_values[cluster_labels == i]\n", + "\n", + " ith_cluster_silhouette_values.sort()\n", + "\n", + " size_cluster_i = ith_cluster_silhouette_values.shape[0]\n", + " y_upper = y_lower + size_cluster_i\n", + "\n", + " color = cm.nipy_spectral(float(i) / n_clusters)\n", + " ax1.fill_betweenx(\n", + " np.arange(y_lower, y_upper),\n", + " 0,\n", + " ith_cluster_silhouette_values,\n", + " facecolor=color,\n", + " edgecolor=color,\n", + " alpha=0.7,\n", + " )\n", + "\n", + " # Label the silhouette plots with their cluster numbers at the middle\n", + " ax1.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))\n", + "\n", + " # Compute the new y_lower for next plot\n", + " y_lower = y_upper + 10 # 10 for the 0 samples\n", + "\n", + " ax1.set_title(\"The silhouette plot for the various clusters.\")\n", + " ax1.set_xlabel(\"The silhouette coefficient values\")\n", + " ax1.set_ylabel(\"Cluster label\")\n", + "\n", + " # The vertical line for average silhouette score of all the values\n", + " ax1.axvline(x=silhouette_avg, color=\"red\", linestyle=\"--\")\n", + "\n", + " ax1.set_yticks([]) # Clear the yaxis labels / ticks\n", + " ax1.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])\n", + "\n", + " # 2nd Plot showing the actual clusters formed\n", + " colors = cm.nipy_spectral(cluster_labels.astype(float) / n_clusters)\n", + " ax2.scatter(\n", + " X[:, 0], X[:, 1], marker=\".\", s=30, lw=0, alpha=0.7, c=colors, edgecolor=\"k\"\n", + " )\n", + "\n", + " # # Labeling the clusters\n", + " # centers = clusterer.cluster_centers_\n", + " # # Draw white circles at cluster centers\n", + " # ax2.scatter(\n", + " # centers[:, 0],\n", + " # centers[:, 1],\n", + " # marker=\"o\",\n", + " # c=\"white\",\n", + " # alpha=1,\n", + " # s=200,\n", + " # edgecolor=\"k\",\n", + " # )\n", + "\n", + " # for i, c in enumerate(centers):\n", + " # ax2.scatter(c[0], c[1], marker=\"$%d$\" % i, alpha=1, s=50, edgecolor=\"k\")\n", + "\n", + " ax2.set_title(\"The visualization of the clustered data.\")\n", + " ax2.set_xlabel(\"Feature space for the 1st feature\")\n", + " ax2.set_ylabel(\"Feature space for the 2nd feature\")\n", + "\n", + " plt.suptitle(\n", + " \"Silhouette analysis for KMeans clustering on sample data with n_clusters = %d\"\n", + " % n_clusters,\n", + " fontsize=14,\n", + " fontweight=\"bold\",\n", + " )\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Clustering" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "AnnData object with n_obs × n_vars = 15066 × 14087\n", + " obs: 'GEX_n_genes_by_counts', 'GEX_pct_counts_mt', 'GEX_size_factors', 'GEX_phase', 'ADT_n_antibodies_by_counts', 'ADT_total_counts', 'ADT_iso_count', 'cell_type', 'batch', 'ADT_pseudotime_order', 'GEX_pseudotime_order', 'Samplename', 'Site', 'DonorNumber', 'Modality', 'VendorLot', 'DonorID', 'DonorAge', 'DonorBMI', 'DonorBloodType', 'DonorRace', 'Ethnicity', 'DonorGender', 'QCMeds', 'DonorSmoker', 'is_train', 'level1', 'level2', 'level3', 'description'\n", + " var: 'feature_types', 'gene_id'\n", + " uns: 'dataset_id', 'genome', 'organism', 'log1p', 'neighbors', 'umap', 'cell_type_colors'\n", + " obsm: 'ADT_X_pca', 'ADT_X_umap', 'ADT_isotype_controls', 'GEX_X_pca', 'GEX_X_umap', 'latent_omiiwae', 'X_umap', 'X_pca', 'latent_embedding_gex'\n", + " layers: 'counts'\n", + " obsp: 'distances', 'connectivities'" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_data" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.stats import entropy\n", + "\n", + "def calculate_entropy_metric_for_leiden_custering(adata, use_rep, target_name):\n", + " sc.pp.neighbors(adata, n_neighbors=30, use_rep=use_rep)\n", + " sc.tl.leiden(adata, resolution=1.0)\n", + " cluster_labels = adata.obs['leiden']\n", + " num_clusters = len(cluster_labels.unique())\n", + " print(f'Target name: {target_name}')\n", + " print(f\"Rep: {use_rep}\")\n", + " print(f\"Number of clusters: {num_clusters}\")\n", + " crosstab = pd.crosstab(test_data.obs['leiden'], test_data.obs[target_name])\n", + " cluster_entropies = np.apply_along_axis(entropy, axis=1, arr=crosstab.values)\n", + " num_samples_per_cluster = crosstab.sum(axis=1)\n", + " total_num_samples = num_samples_per_cluster.sum()\n", + " cluster_weights = num_samples_per_cluster / total_num_samples\n", + " weighted_entropy = np.sum(cluster_entropies * cluster_weights)\n", + " print(f\"Weighted entropy: {weighted_entropy}\")\n", + " return weighted_entropy " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Entropy metric for leiden clustering: level1" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Target name: level1\n", + "Rep: latent_omiiwae\n", + "Number of clusters: 29\n", + "Weighted entropy: 0.14120317590647122\n" + ] + }, + { + "data": { + "text/plain": [ + "0.14120317590647122" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculate_entropy_metric_for_leiden_custering(test_data, use_rep='latent_omiiwae', target_name='level1')" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Target name: level2\n", + "Rep: latent_omiiwae\n", + "Number of clusters: 29\n", + "Weighted entropy: 0.4210108926351834\n" + ] + }, + { + "data": { + "text/plain": [ + "0.4210108926351834" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculate_entropy_metric_for_leiden_custering(test_data, use_rep='latent_omiiwae', target_name='level2')" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Target name: level3\n", + "Rep: latent_omiiwae\n", + "Number of clusters: 29\n", + "Weighted entropy: 0.7696762409727608\n" + ] + }, + { + "data": { + "text/plain": [ + "0.7696762409727608" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculate_entropy_metric_for_leiden_custering(test_data, use_rep='latent_omiiwae', target_name='level3')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Entropy metric for leiden clustering: batch" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Target name: batch\n", + "Rep: latent_omiiwae\n", + "Number of clusters: 29\n", + "Weighted entropy: 0.9562673500925665\n" + ] + }, + { + "data": { + "text/plain": [ + "0.9562673500925665" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculate_entropy_metric_for_leiden_custering(test_data, use_rep='latent_omiiwae', target_name='batch')" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def create_dendroogram_plot(adata, use_rep, target_name):\n", + " sc.tl.dendrogram(adata, groupby=target_name, use_rep=use_rep)\n", + " sc.pl.dendrogram(adata, groupby=target_name)\n", + " plt.show()\n", + "\n", + "create_dendroogram_plot(test_data, use_rep='latent_omiiwae', target_name='level3')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Downstream task" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "test_data.obsm['latent_embedding_gex'] = np.random.randn(15066, 16)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "LATENT_DIM = 16\n", + "DATA = test_data\n", + "LEVEL = 'level1'\n", + "LATENT_NAME = \"latent_embedding_gex\"\n", + "HIDDEN_DIM = 16 * 4" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "# Extract the labels (cell types)\n", + "labels = DATA.obs[LEVEL].values\n", + "\n", + "# Encode labels to integers\n", + "label_encoder = LabelEncoder()\n", + "labels_encoded = label_encoder.fit_transform(labels)\n", + "\n", + "# Convert to PyTorch tensors\n", + "X = torch.tensor(DATA.obsm[LATENT_NAME], dtype=torch.float32)\n", + "y = torch.tensor(labels_encoded, dtype=torch.long)\n", + "\n", + "# Split the data into training and testing sets\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", + "\n", + "# Create DataLoader for training and testing sets\n", + "train_dataset = TensorDataset(X_train, y_train)\n", + "test_dataset = TensorDataset(X_test, y_test)\n", + "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n", + "test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "from models.building_blocks import Block\n", + "\n", + "\n", + "class ClassificationModel(pl.LightningModule):\n", + " def __init__(self, latent_dim, num_classes, hidden_dim, do_batch_norm=False):\n", + " super().__init__()\n", + " self.layers = nn.Sequential(\n", + " nn.Linear(latent_dim, hidden_dim),\n", + " nn.BatchNorm1d(hidden_dim) if do_batch_norm else nn.Identity(),\n", + " nn.SiLU(),\n", + " nn.Linear(hidden_dim, num_classes),\n", + " )\n", + " self.loss = nn.CrossEntropyLoss() # Adjust\n", + "\n", + " def forward(self, z):\n", + " return self.layers(z)\n", + "\n", + " def training_step(self, batch, batch_idx):\n", + " x, y = batch\n", + " y_hat = self.forward(x)\n", + " loss = self.loss(y_hat, y)\n", + " self.log(\n", + " \"train_loss\", loss, on_step=True, on_epoch=True, prog_bar=True, logger=True\n", + " )\n", + " return loss\n", + "\n", + " def validation_step(self, batch, batch_idx):\n", + " x, y = batch\n", + " y_hat = self.forward(x)\n", + " loss = self.loss(y_hat, y)\n", + " self.log(\n", + " \"val_loss\", loss, on_step=False, on_epoch=True, prog_bar=True, logger=True\n", + " )\n", + " \n", + " return loss\n", + "\n", + " def configure_optimizers(self):\n", + " # Define optimizer here\n", + " optimizer = torch.optim.Adam(\n", + " self.parameters(), lr=0.001\n", + " ) # Adjust learning rate\n", + " return optimizer" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'TensorBoardLogger' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[38], line 16\u001b[0m\n\u001b[0;32m 8\u001b[0m \u001b[38;5;66;03m# Define a trainer\u001b[39;00m\n\u001b[0;32m 9\u001b[0m checkpoint_callback \u001b[38;5;241m=\u001b[39m ModelCheckpoint(\n\u001b[0;32m 10\u001b[0m monitor\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mval_loss\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[0;32m 11\u001b[0m dirpath\u001b[38;5;241m=\u001b[39m\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlogs/classification_checkpoints/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mLATENT_NAME\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 14\u001b[0m mode\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmin\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[0;32m 15\u001b[0m )\n\u001b[1;32m---> 16\u001b[0m logger \u001b[38;5;241m=\u001b[39m \u001b[43mTensorBoardLogger\u001b[49m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m./logs\u001b[39m\u001b[38;5;124m\"\u001b[39m, name\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbabel_gex_classifing_logs\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 17\u001b[0m trainer \u001b[38;5;241m=\u001b[39m pl\u001b[38;5;241m.\u001b[39mTrainer(max_epochs\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m, callbacks\u001b[38;5;241m=\u001b[39m[checkpoint_callback])\n\u001b[0;32m 19\u001b[0m \u001b[38;5;66;03m# Train the model\u001b[39;00m\n", + "\u001b[1;31mNameError\u001b[0m: name 'TensorBoardLogger' is not defined" + ] + } + ], + "source": [ + "output_dim = len(np.unique(labels_encoded))\n", + "\n", + "model = ClassificationModel(latent_dim=LATENT_DIM,\n", + " num_classes=output_dim,\n", + " hidden_dim=HIDDEN_DIM,\n", + " do_batch_norm=False)\n", + "\n", + "# Define a trainer\n", + "checkpoint_callback = ModelCheckpoint(\n", + " monitor='val_loss',\n", + " dirpath=f'logs/classification_checkpoints/{LATENT_NAME}',\n", + " filename='model-{epoch:02d}-{val_loss:.2f}',\n", + " save_top_k=1,\n", + " mode='min',\n", + ")\n", + "logger = TensorBoardLogger(\"./logs\", name=\"babel_gex_classifing_logs\")\n", + "trainer = pl.Trainer(max_epochs=1, callbacks=[checkpoint_callback])\n", + "\n", + "# Train the model\n", + "trainer.fit(model, train_loader, test_loader)" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'C:\\\\Users\\\\adamb\\\\Documents\\\\Projects\\\\D4L-Hackaton\\\\src\\\\logs\\\\classification_checkpoints\\\\latent_embedding_gex\\\\model-epoch=00-val_loss=1.65.ckpt'" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "checkpoint_callback.best_model_path" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Accuracy: 42.00%\n" + ] + } + ], + "source": [ + "# Loading the best model for evaluation\n", + "best_model_path = checkpoint_callback.best_model_path\n", + "best_model = ClassificationModel.load_from_checkpoint(\n", + " best_model_path,\n", + " latent_dim=LATENT_DIM,\n", + " num_classes=output_dim,\n", + " hidden_dim=HIDDEN_DIM,\n", + " do_batch_norm=False).cpu()\n", + "\n", + "# Evaluate the model on test set\n", + "best_model.eval()\n", + "correct = 0\n", + "total = 0\n", + "with torch.no_grad():\n", + " for data, target in test_loader:\n", + " output = best_model(data)\n", + " _, predicted = torch.max(output.data, 1)\n", + " total += target.size(0)\n", + " correct += (predicted == target).sum().item()\n", + "\n", + "accuracy = correct / total\n", + "print(f'Test Accuracy: {accuracy * 100:.2f}%')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/old_code/old_notebooks/intro_eda_hackaton_data.ipynb b/old_code/old_notebooks/intro_eda_hackaton_data.ipynb new file mode 100644 index 0000000..2538d5e --- /dev/null +++ b/old_code/old_notebooks/intro_eda_hackaton_data.ipynb @@ -0,0 +1,513 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DnuqYO_-PwSV", + "outputId": "979ae3e7-463b-479d-b5fe-3152a9da4da7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting anndata\n", + " Downloading anndata-0.10.7-py3-none-any.whl (122 kB)\n", + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/122.4 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m71.7/122.4 kB\u001b[0m \u001b[31m1.9 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m122.4/122.4 kB\u001b[0m \u001b[31m2.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting array-api-compat!=1.5,>1.4 (from anndata)\n", + " Downloading array_api_compat-1.6-py3-none-any.whl (36 kB)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anndata) (1.2.1)\n", + "Requirement already satisfied: h5py>=3.1 in /usr/local/lib/python3.10/dist-packages (from anndata) (3.9.0)\n", + "Requirement already satisfied: natsort in /usr/local/lib/python3.10/dist-packages (from anndata) (8.4.0)\n", + "Requirement already satisfied: numpy>=1.23 in /usr/local/lib/python3.10/dist-packages (from anndata) (1.25.2)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from anndata) (24.0)\n", + "Requirement already satisfied: pandas!=2.1.0rc0,!=2.1.2,>=1.4 in /usr/local/lib/python3.10/dist-packages (from anndata) (2.0.3)\n", + "Requirement already satisfied: scipy>1.8 in /usr/local/lib/python3.10/dist-packages (from anndata) (1.11.4)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas!=2.1.0rc0,!=2.1.2,>=1.4->anndata) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas!=2.1.0rc0,!=2.1.2,>=1.4->anndata) (2023.4)\n", + "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas!=2.1.0rc0,!=2.1.2,>=1.4->anndata) (2024.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas!=2.1.0rc0,!=2.1.2,>=1.4->anndata) (1.16.0)\n", + "Installing collected packages: array-api-compat, anndata\n", + "Successfully installed anndata-0.10.7 array-api-compat-1.6\n" + ] + } + ], + "source": [ + "!pip install anndata" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NY9S3FfvQypC", + "outputId": "0523a635-b3aa-48dd-afd5-e2643032e8e9" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting scanpy\n", + " Downloading scanpy-1.10.1-py3-none-any.whl (2.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.1/2.1 MB\u001b[0m \u001b[31m10.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: anndata>=0.8 in /usr/local/lib/python3.10/dist-packages (from scanpy) (0.10.7)\n", + "Requirement already satisfied: h5py>=3.1 in /usr/local/lib/python3.10/dist-packages (from scanpy) (3.9.0)\n", + "Requirement already satisfied: joblib in /usr/local/lib/python3.10/dist-packages (from scanpy) (1.4.2)\n", + "Collecting legacy-api-wrap>=1.4 (from scanpy)\n", + " Downloading legacy_api_wrap-1.4-py3-none-any.whl (15 kB)\n", + "Requirement already satisfied: matplotlib>=3.6 in /usr/local/lib/python3.10/dist-packages (from scanpy) (3.7.1)\n", + "Requirement already satisfied: natsort in /usr/local/lib/python3.10/dist-packages (from scanpy) (8.4.0)\n", + "Requirement already satisfied: networkx>=2.7 in /usr/local/lib/python3.10/dist-packages (from scanpy) (3.3)\n", + "Requirement already satisfied: numba>=0.56 in /usr/local/lib/python3.10/dist-packages (from scanpy) (0.58.1)\n", + "Requirement already satisfied: numpy>=1.23 in /usr/local/lib/python3.10/dist-packages (from scanpy) (1.25.2)\n", + "Requirement already satisfied: packaging>=21.3 in /usr/local/lib/python3.10/dist-packages (from scanpy) (24.0)\n", + "Requirement already satisfied: pandas>=1.5 in /usr/local/lib/python3.10/dist-packages (from scanpy) (2.0.3)\n", + "Requirement already satisfied: patsy in /usr/local/lib/python3.10/dist-packages (from scanpy) (0.5.6)\n", + "Collecting pynndescent>=0.5 (from scanpy)\n", + " Downloading pynndescent-0.5.12-py3-none-any.whl (56 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.8/56.8 kB\u001b[0m \u001b[31m5.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: scikit-learn>=0.24 in /usr/local/lib/python3.10/dist-packages (from scanpy) (1.2.2)\n", + "Requirement already satisfied: scipy>=1.8 in /usr/local/lib/python3.10/dist-packages (from scanpy) (1.11.4)\n", + "Requirement already satisfied: seaborn>=0.13 in /usr/local/lib/python3.10/dist-packages (from scanpy) (0.13.1)\n", + "Collecting session-info (from scanpy)\n", + " Downloading session_info-1.0.0.tar.gz (24 kB)\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: statsmodels>=0.13 in /usr/local/lib/python3.10/dist-packages (from scanpy) (0.14.2)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from scanpy) (4.66.4)\n", + "Collecting umap-learn!=0.5.0,>=0.5 (from scanpy)\n", + " Downloading umap_learn-0.5.6-py3-none-any.whl (85 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m85.7/85.7 kB\u001b[0m \u001b[31m8.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: array-api-compat!=1.5,>1.4 in /usr/local/lib/python3.10/dist-packages (from anndata>=0.8->scanpy) (1.6)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anndata>=0.8->scanpy) (1.2.1)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.6->scanpy) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.6->scanpy) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.6->scanpy) (4.51.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.6->scanpy) (1.4.5)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.6->scanpy) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.6->scanpy) (3.1.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.6->scanpy) (2.8.2)\n", + "Requirement already satisfied: llvmlite<0.42,>=0.41.0dev0 in /usr/local/lib/python3.10/dist-packages (from numba>=0.56->scanpy) (0.41.1)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.5->scanpy) (2023.4)\n", + "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.5->scanpy) (2024.1)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=0.24->scanpy) (3.5.0)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.10/dist-packages (from patsy->scanpy) (1.16.0)\n", + "Collecting stdlib_list (from session-info->scanpy)\n", + " Downloading stdlib_list-0.10.0-py3-none-any.whl (79 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m79.8/79.8 kB\u001b[0m \u001b[31m8.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hBuilding wheels for collected packages: session-info\n", + " Building wheel for session-info (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for session-info: filename=session_info-1.0.0-py3-none-any.whl size=8026 sha256=a5623746fce132d6b8312d844a9acfd47376e923dbbc90d77fc5bbe2f774cf31\n", + " Stored in directory: /root/.cache/pip/wheels/6a/aa/b9/eb5d4031476ec10802795b97ccf937b9bd998d68a9b268765a\n", + "Successfully built session-info\n", + "Installing collected packages: stdlib_list, legacy-api-wrap, session-info, pynndescent, umap-learn, scanpy\n", + "Successfully installed legacy-api-wrap-1.4 pynndescent-0.5.12 scanpy-1.10.1 session-info-1.0.0 stdlib_list-0.10.0 umap-learn-0.5.6\n" + ] + } + ], + "source": [ + "!pip install scanpy" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "kpM6sqfoQzx-" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "EnI8524WHLYu" + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from pandas import DataFrame\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import scipy.stats as stats\n", + "import plotly.express as px\n", + "import plotly.graph_objects as go\n", + "import plotly.subplots as sp\n", + "import os\n", + "import gdown\n", + "import json\n", + "from pathlib import Path\n", + "from sklearn.preprocessing import LabelEncoder\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "from sklearn.svm import SVC, LinearSVC, NuSVC\n", + "from sklearn.model_selection import GridSearchCV\n", + "import anndata\n", + "\n", + "from typing import List\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "pd.set_option(\"display.max_columns\", None)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "rxuadXLoIY7z" + }, + "outputs": [], + "source": [ + "# Link do danych: https://drive.google.com/file/d/1xWr8w3x6X2NKH_qjyKIvUx-jE7FADnJ2/view?usp=sharing" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "UxEKIXcUNsd8", + "outputId": "a3ee59f9-116a-4420-d80c-8ac75119dd45" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading...\n", + "From (original): https://drive.google.com/uc?id=1xWr8w3x6X2NKH_qjyKIvUx-jE7FADnJ2\n", + "From (redirected): https://drive.google.com/uc?id=1xWr8w3x6X2NKH_qjyKIvUx-jE7FADnJ2&confirm=t&uuid=e11ad22d-6bef-422b-bc6b-17280b9e07b6\n", + "To: /content/hackaton_data.gz\n", + "100% 616M/616M [00:18<00:00, 32.5MB/s]\n" + ] + } + ], + "source": [ + "# !gdown 1xWr8w3x6X2NKH_qjyKIvUx-jE7FADnJ2" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "jFbKoOXEHVU3" + }, + "outputs": [], + "source": [ + "# !mkdir data" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "_iIFILTYHYYh" + }, + "outputs": [], + "source": [ + "# !gunzip hackaton_data.gz" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ylBbjGI2O5Bb", + "outputId": "d6ff77cd-ca82-4fce-e95f-0f892c2e552b" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/anndata/_core/anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + } + ], + "source": [ + "TRAIN_ANNDATA_PATH: Path = \"/content/hackaton_data\"\n", + "train_anndata = anndata.read_h5ad(TRAIN_ANNDATA_PATH)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "PId3eIaKROEE", + "outputId": "bb9d80c4-b641-406c-f9c8-d021b3a02d4d" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "AnnData object with n_obs × n_vars = 90261 × 14087\n", + " obs: 'GEX_n_genes_by_counts', 'GEX_pct_counts_mt', 'GEX_size_factors', 'GEX_phase', 'ADT_n_antibodies_by_counts', 'ADT_total_counts', 'ADT_iso_count', 'cell_type', 'batch', 'ADT_pseudotime_order', 'GEX_pseudotime_order', 'Samplename', 'Site', 'DonorNumber', 'Modality', 'VendorLot', 'DonorID', 'DonorAge', 'DonorBMI', 'DonorBloodType', 'DonorRace', 'Ethnicity', 'DonorGender', 'QCMeds', 'DonorSmoker', 'is_train'\n", + " var: 'feature_types', 'gene_id'\n", + " uns: 'dataset_id', 'genome', 'organism'\n", + " obsm: 'ADT_X_pca', 'ADT_X_umap', 'ADT_isotype_controls', 'GEX_X_pca', 'GEX_X_umap'\n", + " layers: 'counts'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_anndata" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4eUTXQhBRXVI", + "outputId": "c0e82f01-8d74-4f4c-c845-e0218ce54f06" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/anndata/_core/anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + }, + { + "data": { + "text/plain": [ + "AnnData object with n_obs × n_vars = 90261 × 14087\n", + " obs: 'GEX_n_genes_by_counts', 'GEX_pct_counts_mt', 'GEX_size_factors', 'GEX_phase', 'ADT_n_antibodies_by_counts', 'ADT_total_counts', 'ADT_iso_count', 'cell_type', 'batch', 'ADT_pseudotime_order', 'GEX_pseudotime_order', 'Samplename', 'Site', 'DonorNumber', 'Modality', 'VendorLot', 'DonorID', 'DonorAge', 'DonorBMI', 'DonorBloodType', 'DonorRace', 'Ethnicity', 'DonorGender', 'QCMeds', 'DonorSmoker', 'is_train'\n", + " var: 'feature_types', 'gene_id', 'n_counts'\n", + " uns: 'dataset_id', 'genome', 'organism'\n", + " obsm: 'ADT_X_pca', 'ADT_X_umap', 'ADT_isotype_controls', 'GEX_X_pca', 'GEX_X_umap'\n", + " layers: 'counts'" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import scanpy as sc\n", + "\n", + "pbmc = train_anndata.copy()\n", + "pbmc.var_names_make_unique()\n", + "pbmc.layers[\"counts\"] = pbmc.X.copy()\n", + "sc.pp.filter_genes(pbmc, min_counts=1)\n", + "pbmc" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AgHAFsX4c8pg" + }, + "source": [ + "GEX: Gene Expression\n", + "ADT: Antibody Capture" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "FYftprDsQkqG", + "outputId": "a011b1e5-299b-4eff-9930-06d70d45f0ac" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "feature_types\n", + "GEX 13953\n", + "ADT 134\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pbmc.var[\"feature_types\"].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "id": "puulRw4cQrep" + }, + "outputs": [], + "source": [ + "protein = pbmc[:, pbmc.var[\"feature_types\"] == \"ADT\"].copy()\n", + "rna = pbmc[:, pbmc.var[\"feature_types\"] == \"GEX\"].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hNA-MGgfcf8e", + "outputId": "b709218f-e0d8-4653-81c5-1878cb53bb0e" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "((90261, 13953), (90261, 134))" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(rna.shape, protein.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GygpcUrHhM-l" + }, + "source": [ + "Protein\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "N-nOvxD2hOMb" + }, + "outputs": [], + "source": [ + "protein.var[\"control\"] = protein.var_names.str.contains(\"control\")\n", + "sc.pp.calculate_qc_metrics(\n", + " protein,\n", + " percent_top=(5, 10, 15),\n", + " var_type=\"antibodies\",\n", + " qc_vars=(\"control\",),\n", + " inplace=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MXgrMvqzhVLo" + }, + "source": [ + "TODO: I would like to include some justification for the change in normalization. It definitley has a much different distribution than transcripts. I think this could be shown through the qc plots, but it’s a huge pain to move around these matplotlib plots. This might be more appropriate for the in-depth guide though.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ZtPKBLh6hVhy" + }, + "outputs": [], + "source": [ + "# sns.jointplot(\"log1p_total_counts\", \"n_antibodies_by_counts\", protein.obs, kind=\"hex\", norm=mpl.colors.LogNorm())\n", + "# sns.jointplot(\"log1p_total_counts\", \"log1p_total_counts_control\", protein.obs, kind=\"hex\", norm=mpl.colors.LogNorm()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "JLhGQ3QUhX66" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cFJpXsl1iDFA" + }, + "source": [ + "Labelling" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ecLP3uO9iCh3" + }, + "outputs": [], + "source": [ + "# markers = {\n", + "# \"CD4\": [\"CD4_TotalSeqB\", \"CD4\"],\n", + "# \"CD8\": [\"CD8a_TotalSeqB\", \"CD8A\", \"CD8B\"],\n", + "# \"B-cell\": [\"CD19_TotalSeqB\"],\n", + "# \"Monocytes\": [\"CD86_TotalSeqB\", \"CD11b_TotalSeqB\", \"CD14\", \"CD14_TotalSeqB\", \"FCGR3A\", \"CD14_TotalSeqB\"],\n", + "# \"NK Cells\": [\"FCGR3A\", \"NKG7\"],\n", + "# \"T-Cell Activation\": [\"CCL5\", \"CD45RO_TotalSeqB\", \"CCR7\", \"CD45RA_TotalSeqB\"],\n", + "# }" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "tWGXpA8niGex" + }, + "outputs": [], + "source": [ + "sc.pl.dotplot( # Should we use z-scores for the hue in these?\n", + " pbmc,\n", + " markers,\n", + " groupby=\"lowlevel\",\n", + ")" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/old_code/old_notebooks/pp-architecture-tries.ipynb b/old_code/old_notebooks/pp-architecture-tries.ipynb new file mode 100644 index 0000000..c3b9e82 --- /dev/null +++ b/old_code/old_notebooks/pp-architecture-tries.ipynb @@ -0,0 +1,1462 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.chdir(\"../src\")\n", + "\n", + "from utils import data_utils\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import anndata as ad\n", + "import scanpy as sc\n", + "\n", + "\n", + "pd.set_option(\"display.max_columns\", None)\n", + "\n", + "import argparse" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Subsampling anndata with fraction 1.0...\n" + ] + } + ], + "source": [ + "adata = data_utils.load_anndata(\n", + " mode=\"train\",\n", + " normalize=True,\n", + " remove_batch_effect=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(21087.0, 16.863785)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adata.layers[\"counts\"].toarray().max(), adata.X.toarray().max()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import pytorch_lightning as pl\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "class Encoder(nn.Module):\n", + " def __init__(\n", + " self, latent_dims, hidden_dims, input_dims, dropout, z_dropout\n", + " ): # dropout, z_dropout define the dropout rates of the encoder/latent space\n", + " super(Encoder, self).__init__()\n", + " self.encoder = nn.Sequential(\n", + " nn.Linear(input_dims, hidden_dims),\n", + " nn.BatchNorm1d(hidden_dims),\n", + " nn.ReLU(),\n", + " nn.Dropout(p=dropout),\n", + " nn.Linear(hidden_dims, hidden_dims),\n", + " nn.BatchNorm1d(hidden_dims),\n", + " nn.ReLU(),\n", + " nn.Dropout(p=dropout),\n", + " nn.Linear(hidden_dims, hidden_dims),\n", + " nn.ReLU(),\n", + " nn.Dropout(p=dropout),\n", + " ) # two layer, fully connected encoder with dropout\n", + "\n", + " self.mu = nn.Sequential(\n", + " nn.Linear(hidden_dims, latent_dims),\n", + " # nn.Dropout(p = z_dropout)\n", + " )\n", + "\n", + " # self.sigma = nn.Sequential(nn.Linear(hidden_dims, latent_dims),\n", + " # nn.Dropout(p = z_dropout)\n", + " # )\n", + "\n", + " self.N = torch.distributions.Normal(0, 1)\n", + " self.N.loc = self.N.loc.to(device)\n", + " self.N.scale = self.N.scale.to(device)\n", + " self.kl = 0\n", + "\n", + " def forward(self, x):\n", + " x = self.encoder(x)\n", + " mu = self.mu(x)\n", + " # sigma = torch.exp(self.sigma(x)) # exp for numeric stability\n", + " z = mu # + sigma*self.N.sample(mu.shape)\n", + " # self.kl = (0.5*sigma**2 + 0.5*mu**2 - torch.log(sigma) - 1/2).sum() #calculation of kullback-leibler divergence\n", + "\n", + " return z" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class Decoder(nn.Module):\n", + " def __init__(self, latent_dims, hidden_dims, input_dims, dropout):\n", + " super(Decoder, self).__init__()\n", + " self.decoder = nn.Sequential(\n", + " nn.Linear(latent_dims, hidden_dims),\n", + " nn.BatchNorm1d(hidden_dims),\n", + " nn.ReLU(),\n", + " nn.Dropout(p=dropout),\n", + " nn.Linear(hidden_dims, hidden_dims),\n", + " nn.BatchNorm1d(hidden_dims),\n", + " nn.ReLU(),\n", + " nn.Dropout(p=dropout),\n", + " nn.Linear(hidden_dims, input_dims),\n", + " )\n", + "\n", + " def forward(self, z):\n", + " decoded = self.decoder(z)\n", + " return decoded" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "class AE(nn.Module):\n", + " def __init__(self, latent_dims, hidden_dims, input_dims, dropout, z_dropout):\n", + " super(AE, self).__init__()\n", + " self.encoder = Encoder(latent_dims, hidden_dims, input_dims, dropout, z_dropout)\n", + " self.decoder = Decoder(latent_dims, hidden_dims, input_dims, dropout)\n", + "\n", + " def forward(self, x):\n", + " z = self.encoder(x)\n", + " x_hat = self.decoder(z)\n", + " return x_hat, z\n", + "\n", + "\n", + "def train(model, dataloader, optimizer, epochs):\n", + " model.train()\n", + " for epoch in range(epochs):\n", + " sum_loss = 0.0\n", + " for i, data in enumerate(dataloader):\n", + " optimizer.zero_grad()\n", + " x = data.to(device)\n", + " x_hat, z = model(x)\n", + " # loss = F.mse_loss(x_hat, x)# + model.encoder.kl\n", + " # x_fst, x_snd = x_hat.split([13953, 134])\n", + " loss = F.mse_loss(x_hat[:, :13953], x[:, :13953]) + F.mse_loss(\n", + " x_hat[:, 13953:], x[:, 13953:]\n", + " )\n", + " loss.backward()\n", + " optimizer.step()\n", + " sum_loss += loss.item()\n", + " print(f\"Epoch {epoch+1}, Loss: {sum_loss/len(dataloader)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# from torch.utils.data import DataLoader, random_split\n", + "\n", + "# # adata.obsm['ADT_X_pca']\n", + "# data = np.concatenate([adata.obsm['ADT_X_pca'], adata.obsm['GEX_X_pca']], axis=1)\n", + "\n", + "# print(data.mean(axis=0))\n", + "# print(data.std(axis=0))\n", + "\n", + "# # Hyperparameters\n", + "# input_dims = data.shape[1]\n", + "# latent_dims = 10\n", + "# hidden_dims = 50\n", + "# batch_size = 128\n", + "# dropout = 0.0\n", + "# z_dropout = 0.0\n", + "# learning_rate = 1e-2\n", + "# max_epochs = 50\n", + "\n", + "# # Data\n", + "# ADT_data_train, ADT_data_val = random_split(data, [0.9, 0.1])\n", + "\n", + "# train_loader = DataLoader(ADT_data_train, batch_size=batch_size, shuffle=True)\n", + "# val_loader = DataLoader(ADT_data_val, batch_size=batch_size)\n", + "\n", + "# # Model\n", + "# model = AE(latent_dims, hidden_dims, input_dims, dropout, z_dropout)\n", + "\n", + "# # Trainer\n", + "# train(model, train_loader, torch.optim.Adam(model.parameters(), lr=learning_rate), max_epochs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[15], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43msc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpca\u001b[49m\u001b[43m(\u001b[49m\u001b[43madata\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 2\u001b[0m sc\u001b[38;5;241m.\u001b[39mpp\u001b[38;5;241m.\u001b[39mneighbors(adata, n_neighbors\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m, n_pcs\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m, use_rep\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mX_pca\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m 3\u001b[0m sc\u001b[38;5;241m.\u001b[39mtl\u001b[38;5;241m.\u001b[39mumap(adata)\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\preprocessing\\_pca.py:276\u001b[0m, in \u001b[0;36mpca\u001b[1;34m(***failed resolving arguments***)\u001b[0m\n\u001b[0;32m 272\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msklearn\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mdecomposition\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m PCA\n\u001b[0;32m 274\u001b[0m svd_solver \u001b[38;5;241m=\u001b[39m _handle_sklearn_args(svd_solver, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPCA (with sparse input)\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m--> 276\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43m_pca_with_sparse\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 277\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_comps\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msolver\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msvd_solver\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrandom_state\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrandom_state\u001b[49m\n\u001b[0;32m 278\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 279\u001b[0m \u001b[38;5;66;03m# this is just a wrapper for the results\u001b[39;00m\n\u001b[0;32m 280\u001b[0m X_pca \u001b[38;5;241m=\u001b[39m output[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mX_pca\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\preprocessing\\_pca.py:440\u001b[0m, in \u001b[0;36m_pca_with_sparse\u001b[1;34m(X, npcs, solver, mu, random_state)\u001b[0m\n\u001b[0;32m 437\u001b[0m X_pca \u001b[38;5;241m=\u001b[39m (u \u001b[38;5;241m*\u001b[39m s)[:, idx]\n\u001b[0;32m 438\u001b[0m ev \u001b[38;5;241m=\u001b[39m s[idx] \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m/\u001b[39m (X\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m--> 440\u001b[0m total_var \u001b[38;5;241m=\u001b[39m \u001b[43m_get_mean_var\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m)\u001b[49m[\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39msum()\n\u001b[0;32m 441\u001b[0m ev_ratio \u001b[38;5;241m=\u001b[39m ev \u001b[38;5;241m/\u001b[39m total_var\n\u001b[0;32m 443\u001b[0m output \u001b[38;5;241m=\u001b[39m {\n\u001b[0;32m 444\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mX_pca\u001b[39m\u001b[38;5;124m\"\u001b[39m: X_pca,\n\u001b[0;32m 445\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvariance\u001b[39m\u001b[38;5;124m\"\u001b[39m: ev,\n\u001b[0;32m 446\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvariance_ratio\u001b[39m\u001b[38;5;124m\"\u001b[39m: ev_ratio,\n\u001b[0;32m 447\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcomponents\u001b[39m\u001b[38;5;124m\"\u001b[39m: v,\n\u001b[0;32m 448\u001b[0m }\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\preprocessing\\_utils.py:36\u001b[0m, in \u001b[0;36m_get_mean_var\u001b[1;34m(X, axis)\u001b[0m\n\u001b[0;32m 32\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_get_mean_var\u001b[39m(\n\u001b[0;32m 33\u001b[0m X: _SupportedArray, \u001b[38;5;241m*\u001b[39m, axis: Literal[\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[0;32m 34\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28mtuple\u001b[39m[NDArray[np\u001b[38;5;241m.\u001b[39mfloat64], NDArray[np\u001b[38;5;241m.\u001b[39mfloat64]]:\n\u001b[0;32m 35\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(X, sparse\u001b[38;5;241m.\u001b[39mspmatrix):\n\u001b[1;32m---> 36\u001b[0m mean, var \u001b[38;5;241m=\u001b[39m \u001b[43msparse_mean_variance_axis\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 37\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 38\u001b[0m mean \u001b[38;5;241m=\u001b[39m axis_mean(X, axis\u001b[38;5;241m=\u001b[39maxis, dtype\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39mfloat64)\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\preprocessing\\_utils.py:75\u001b[0m, in \u001b[0;36msparse_mean_variance_axis\u001b[1;34m(mtx, axis)\u001b[0m\n\u001b[0;32m 66\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m sparse_mean_var_major_axis(\n\u001b[0;32m 67\u001b[0m mtx\u001b[38;5;241m.\u001b[39mdata,\n\u001b[0;32m 68\u001b[0m mtx\u001b[38;5;241m.\u001b[39mindices,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 72\u001b[0m dtype\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39mfloat64,\n\u001b[0;32m 73\u001b[0m )\n\u001b[0;32m 74\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m---> 75\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43msparse_mean_var_minor_axis\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmtx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmtx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindices\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfloat64\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\numba\\core\\dispatcher.py:420\u001b[0m, in \u001b[0;36m_DispatcherBase._compile_for_args\u001b[1;34m(self, *args, **kws)\u001b[0m\n\u001b[0;32m 418\u001b[0m return_val \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m 419\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 420\u001b[0m return_val \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompile\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mtuple\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margtypes\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 421\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m errors\u001b[38;5;241m.\u001b[39mForceLiteralArg \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m 422\u001b[0m \u001b[38;5;66;03m# Received request for compiler re-entry with the list of arguments\u001b[39;00m\n\u001b[0;32m 423\u001b[0m \u001b[38;5;66;03m# indicated by e.requested_args.\u001b[39;00m\n\u001b[0;32m 424\u001b[0m \u001b[38;5;66;03m# First, check if any of these args are already Literal-ized\u001b[39;00m\n\u001b[0;32m 425\u001b[0m already_lit_pos \u001b[38;5;241m=\u001b[39m [i \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m e\u001b[38;5;241m.\u001b[39mrequested_args\n\u001b[0;32m 426\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(args[i], types\u001b[38;5;241m.\u001b[39mLiteral)]\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\numba\\core\\dispatcher.py:938\u001b[0m, in \u001b[0;36mDispatcher.compile\u001b[1;34m(self, sig)\u001b[0m\n\u001b[0;32m 936\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m existing\u001b[38;5;241m.\u001b[39mentry_point\n\u001b[0;32m 937\u001b[0m \u001b[38;5;66;03m# Try to load from disk cache\u001b[39;00m\n\u001b[1;32m--> 938\u001b[0m cres \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_cache\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload_overload\u001b[49m\u001b[43m(\u001b[49m\u001b[43msig\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtargetctx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 939\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cres \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 940\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_cache_hits[sig] \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\numba\\core\\caching.py:633\u001b[0m, in \u001b[0;36mCache.load_overload\u001b[1;34m(self, sig, target_context)\u001b[0m\n\u001b[0;32m 628\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 629\u001b[0m \u001b[38;5;124;03mLoad and recreate the cached object for the given signature,\u001b[39;00m\n\u001b[0;32m 630\u001b[0m \u001b[38;5;124;03musing the *target_context*.\u001b[39;00m\n\u001b[0;32m 631\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 632\u001b[0m \u001b[38;5;66;03m# Refresh the context to ensure it is initialized\u001b[39;00m\n\u001b[1;32m--> 633\u001b[0m \u001b[43mtarget_context\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrefresh\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 634\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_guard_against_spurious_io_errors():\n\u001b[0;32m 635\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_load_overload(sig, target_context)\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\numba\\core\\base.py:267\u001b[0m, in \u001b[0;36mBaseContext.refresh\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 262\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 263\u001b[0m \u001b[38;5;124;03mRefresh context with new declarations from known registries.\u001b[39;00m\n\u001b[0;32m 264\u001b[0m \u001b[38;5;124;03mUseful for third-party extensions.\u001b[39;00m\n\u001b[0;32m 265\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 266\u001b[0m \u001b[38;5;66;03m# load target specific registries\u001b[39;00m\n\u001b[1;32m--> 267\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload_additional_registries\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 269\u001b[0m \u001b[38;5;66;03m# Populate the builtin registry, this has to happen after loading\u001b[39;00m\n\u001b[0;32m 270\u001b[0m \u001b[38;5;66;03m# additional registries as some of the \"additional\" registries write\u001b[39;00m\n\u001b[0;32m 271\u001b[0m \u001b[38;5;66;03m# their implementations into the builtin_registry and would be missed if\u001b[39;00m\n\u001b[0;32m 272\u001b[0m \u001b[38;5;66;03m# this ran first.\u001b[39;00m\n\u001b[0;32m 273\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minstall_registry(builtin_registry)\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\numba\\core\\cpu.py:75\u001b[0m, in \u001b[0;36mCPUContext.load_additional_registries\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 69\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mnumba\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mcpython\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m (builtins, charseq, enumimpl, \u001b[38;5;66;03m# noqa F401\u001b[39;00m\n\u001b[0;32m 70\u001b[0m hashing, heapq, iterators, \u001b[38;5;66;03m# noqa F401\u001b[39;00m\n\u001b[0;32m 71\u001b[0m listobj, numbers, rangeobj, \u001b[38;5;66;03m# noqa F401\u001b[39;00m\n\u001b[0;32m 72\u001b[0m setobj, slicing, tupleobj, \u001b[38;5;66;03m# noqa F401\u001b[39;00m\n\u001b[0;32m 73\u001b[0m unicode,) \u001b[38;5;66;03m# noqa F401\u001b[39;00m\n\u001b[0;32m 74\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mnumba\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mcore\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m optional \u001b[38;5;66;03m# noqa F401\u001b[39;00m\n\u001b[1;32m---> 75\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mnumba\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mmisc\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m gdb_hook, literal \u001b[38;5;66;03m# noqa F401\u001b[39;00m\n\u001b[0;32m 76\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mnumba\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mnp\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m linalg, arraymath, arrayobj \u001b[38;5;66;03m# noqa F401\u001b[39;00m\n\u001b[0;32m 77\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mnumba\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mnp\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mrandom\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m generator_core, generator_methods \u001b[38;5;66;03m# noqa F401\u001b[39;00m\n", + "File \u001b[1;32m:1354\u001b[0m, in \u001b[0;36m_find_and_load\u001b[1;34m(name, import_)\u001b[0m\n", + "File \u001b[1;32m:1316\u001b[0m, in \u001b[0;36m_find_and_load_unlocked\u001b[1;34m(name, import_)\u001b[0m\n", + "File \u001b[1;32m:1256\u001b[0m, in \u001b[0;36m_find_spec\u001b[1;34m(name, path, target)\u001b[0m\n", + "File \u001b[1;32m:1524\u001b[0m, in \u001b[0;36mfind_spec\u001b[1;34m(cls, fullname, path, target)\u001b[0m\n", + "File \u001b[1;32m:1498\u001b[0m, in \u001b[0;36m_get_spec\u001b[1;34m(cls, fullname, path, target)\u001b[0m\n", + "File \u001b[1;32m:1597\u001b[0m, in \u001b[0;36mfind_spec\u001b[1;34m(self, fullname, target)\u001b[0m\n", + "File \u001b[1;32m:147\u001b[0m, in \u001b[0;36m_path_stat\u001b[1;34m(path)\u001b[0m\n", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "sc.pp.pca(adata)\n", + "sc.pp.neighbors(adata, n_neighbors=10, n_pcs=10, use_rep=\"X_pca\")\n", + "sc.tl.umap(adata)\n", + "sc.pl.umap(adata, color=\"cell_type\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pp.neighbors(adata, n_neighbors=10, n_pcs=10, use_rep=\"ADT_X_pca\")\n", + "sc.tl.umap(adata)\n", + "sc.pl.umap(adata, color=\"cell_type\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pp.neighbors(adata, n_neighbors=10, n_pcs=10, use_rep=\"GEX_X_pca\")\n", + "sc.tl.umap(adata)\n", + "sc.pl.umap(adata, color=\"cell_type\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "latent_embeddings = model.encoder(torch.tensor(data))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "adata.obsm[\"latent_embeddings\"] = latent_embeddings.detach().numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pp.neighbors(adata, n_neighbors=10, use_rep=\"latent_embeddings\")\n", + "sc.tl.umap(adata)\n", + "sc.pl.umap(adata, color=\"cell_type\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.Size([66175, 10]), (66175, 50), (66175, 50))" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "latent_embeddings.shape, adata.obsm[\"ADT_X_pca\"].shape, adata.obsm[\"GEX_X_pca\"].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(66175, 14087)\n", + "Epoch 1, Loss: 0.1162506396696692\n" + ] + } + ], + "source": [ + "from torch.utils.data import DataLoader, random_split\n", + "\n", + "# adata.obsm['ADT_X_pca']\n", + "data = adata.X.toarray()\n", + "print(data.shape)\n", + "\n", + "# print(data.mean(axis=0))\n", + "# print(data.std(axis=0))\n", + "\n", + "# Hyperparameters\n", + "input_dims = data.shape[1]\n", + "latent_dims = 10\n", + "hidden_dims = 50\n", + "batch_size = 128\n", + "dropout = 0.0\n", + "z_dropout = 0.0\n", + "learning_rate = 1e-2\n", + "max_epochs = 1\n", + "\n", + "# Data\n", + "# ADT_data_train, ADT_data_val = random_split(data, [0.9, 0.1])\n", + "train_data = torch.tensor(data).float()\n", + "train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True)\n", + "# val_loader = DataLoader(ADT_data_val, batch_size=batch_size)\n", + "\n", + "# Model\n", + "model = AE(latent_dims, hidden_dims, input_dims, dropout, z_dropout)\n", + "\n", + "# Trainer\n", + "train(\n", + " model,\n", + " train_loader,\n", + " torch.optim.Adam(model.parameters(), lr=learning_rate),\n", + " max_epochs,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "latent_embeddings = model.encoder(torch.tensor(data))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\przem\\AppData\\Local\\Temp\\ipykernel_4640\\3925707529.py:1: ImplicitModificationWarning: Setting element `.obsm['latent_embeddings2']` of view, initializing view as actual.\n", + " adata.obsm['latent_embeddings2'] = latent_embeddings.detach().numpy()\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + } + ], + "source": [ + "adata.obsm[\"latent_embeddings2\"] = latent_embeddings.detach().numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pp.neighbors(adata, n_neighbors=10, use_rep=\"latent_embeddings2\")\n", + "sc.tl.umap(adata)\n", + "sc.pl.umap(adata, color=\"cell_type\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# OMI AE" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from abc import ABC, abstractmethod\n", + "from argparse import Namespace\n", + "from typing import Dict, Optional, Tuple, Union\n", + "\n", + "import anndata as ad\n", + "import pytorch_lightning as pl\n", + "import torch\n", + "import torch.distributions as td\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "from anndata import AnnData\n", + "from sklearn.metrics import balanced_accuracy_score\n", + "from torch import Tensor\n", + "\n", + "from models.building_blocks import Block, ResidualBlock, ShortcutBlock\n", + "from models.ModelBase import ModelBase\n", + "from utils.data_utils import get_dataloader_from_anndata, get_dataset_from_anndata\n", + "\n", + "\n", + "class OmiAE(pl.LightningModule):\n", + " def __init__(self):\n", + " super(OmiAE, self).__init__()\n", + " input_dims = 14087\n", + " latent_dims = 10\n", + " hidden_dims = 50\n", + " dropout = 0.0\n", + " z_dropout = 0.0\n", + "\n", + " self.encoder = Encoder(latent_dims, hidden_dims, input_dims, dropout, z_dropout)\n", + " self.decoder = Decoder(latent_dims, hidden_dims, input_dims, dropout)\n", + "\n", + " def forward(self, x):\n", + " z = self.encoder(x)\n", + " x_hat = self.decoder(z)\n", + " return x_hat, z\n", + "\n", + " def training_step(self, batch: Tensor) -> Tensor:\n", + " x_hat, z = self.forward(batch)\n", + " loss = F.mse_loss(x_hat, batch)\n", + " self.log(\"Train loss\", loss, on_epoch=True, prog_bar=True)\n", + " return loss\n", + "\n", + " def validation_step(self, batch: Tensor) -> Tensor:\n", + " x_hat = self(batch)\n", + " loss = F.mse_loss(x_hat, batch)\n", + " self.log(\"Val loss\", loss, on_epoch=True, prog_bar=True)\n", + " return loss\n", + "\n", + " def configure_optimizers(self):\n", + " return optim.Adam(self.parameters(), lr=1e-2)\n", + "\n", + "\n", + "class OmiModel:\n", + " def __init__(self, cfg: Namespace):\n", + " super(OmiModel, self).__init__()\n", + " self.model = OmiAE()\n", + " self.trainer = pl.Trainer(\n", + " max_epochs=cfg.max_epochs,\n", + " log_every_n_steps=cfg.log_every_n_steps,\n", + " )\n", + "\n", + " def train(self, train_dataloader: DataLoader, val_data: AnnData = None) -> None:\n", + " # print(\"batch_size\", self.cfg.batch_size)\n", + " self.trainer.fit(\n", + " model=self.model,\n", + " train_dataloaders=train_dataloader,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: False, used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n" + ] + } + ], + "source": [ + "omimodel = OmiModel(Namespace(max_epochs=50, log_every_n_steps=1))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([128, 14087])" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "next(iter(train_loader)).shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data = adata.X.toarray()\n", + "\n", + "# print(data.mean(axis=0))\n", + "# print(data.std(axis=0))\n", + "\n", + "ADT_data_train, ADT_data_val = random_split(data, [0.9, 0.1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([128, 14087])" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_loader = DataLoader(ADT_data_train, batch_size=128, shuffle=True)\n", + "next(iter(train_loader)).shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\configuration_validator.py:74: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------\n", + "0 | encoder | Encoder | 710 K \n", + "1 | decoder | Decoder | 721 K \n", + "------------------------------------\n", + "1.4 M Trainable params\n", + "0 Non-trainable params\n", + "1.4 M Total params\n", + "5.728 Total estimated model params size (MB)\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=3` in the `DataLoader` to improve performance.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 4: 11%|█▏ | 53/466 [00:02<00:19, 21.55it/s, v_num=12, Train loss_step=0.024, Train loss_epoch=0.0239] " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\call.py:54: Detected KeyboardInterrupt, attempting graceful shutdown...\n" + ] + } + ], + "source": [ + "omimodel.train(train_dataloader=train_loader)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# OMI AE 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from abc import ABC, abstractmethod\n", + "from argparse import Namespace\n", + "from typing import Dict, Optional, Tuple, Union\n", + "\n", + "import anndata as ad\n", + "import pytorch_lightning as pl\n", + "import torch\n", + "import torch.distributions as td\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "from anndata import AnnData\n", + "from sklearn.metrics import balanced_accuracy_score\n", + "from torch import Tensor\n", + "\n", + "from models.building_blocks import Block, ResidualBlock, ShortcutBlock\n", + "from models.ModelBase import ModelBase\n", + "from utils.data_utils import get_dataloader_from_anndata, get_dataset_from_anndata\n", + "from utils.loss_utils import (\n", + " adt_reconstruction_loss,\n", + " gex_reconstruction_loss,\n", + " kld_stdgaussian,\n", + ")\n", + "from utils.paths import LOGS_PATH\n", + "\n", + "\n", + "class OmiAE(pl.LightningModule):\n", + " def __init__(self, cfg: Namespace):\n", + " super(OmiAE, self).__init__()\n", + " self.assert_cfg(cfg)\n", + " self.cfg = cfg\n", + " self.fstmod_in = ShortcutBlock(\n", + " input_size=cfg.first_modality_dim,\n", + " output_size=cfg.first_modality_embedding_dim,\n", + " hidden_size=cfg.first_modality_hidden_dim,\n", + " batch_norm=cfg.batch_norm,\n", + " )\n", + " # self.fstmod_in = nn.Sequential(\n", + " # nn.BatchNorm1d(cfg.first_modality_dim),\n", + " # nn.Linear(cfg.first_modality_dim, 1000),\n", + " # nn.Dropout(0.5),\n", + " # nn.ReLU(),\n", + " # nn.BatchNorm1d(1000),\n", + " # nn.Linear(1000, 400),\n", + " # nn.ReLU(),\n", + " # nn.BatchNorm1d(400),\n", + " # )\n", + " self.sndmod_in = ShortcutBlock(\n", + " input_size=cfg.second_modality_dim,\n", + " output_size=cfg.second_modality_embedding_dim,\n", + " hidden_size=cfg.second_modality_hidden_dim,\n", + " batch_norm=cfg.batch_norm,\n", + " )\n", + " # self.sndmod_in = nn.Sequential(\n", + " # nn.Linear(cfg.second_modality_dim, 10),\n", + " # nn.ReLU(),\n", + " # nn.BatchNorm1d(10),\n", + " # )\n", + " self.encoder = nn.Sequential(\n", + " Block(\n", + " input_size=cfg.first_modality_embedding_dim\n", + " + cfg.second_modality_embedding_dim,\n", + " output_size=cfg.encoder_out_dim,\n", + " hidden_size=cfg.encoder_hidden_dim,\n", + " batch_norm=cfg.batch_norm,\n", + " ),\n", + " nn.SiLU(),\n", + " ResidualBlock(\n", + " input_size=cfg.encoder_out_dim,\n", + " hidden_size=cfg.encoder_hidden_dim,\n", + " batch_norm=cfg.batch_norm,\n", + " ),\n", + " )\n", + " # self.encoder = nn.Sequential(\n", + " # nn.Linear(410, 500),\n", + " # nn.ReLU(),\n", + " # nn.BatchNorm1d(500),\n", + " # nn.Linear(500, 200),\n", + " # nn.ReLU(),\n", + " # nn.BatchNorm1d(200),\n", + " # )\n", + " self.decoder = nn.Sequential(\n", + " ShortcutBlock(\n", + " input_size=cfg.decoder_in_dim,\n", + " output_size=cfg.decoder_in_dim * 2,\n", + " hidden_size=cfg.decoder_hidden_dim,\n", + " batch_norm=cfg.batch_norm,\n", + " ),\n", + " nn.SiLU(),\n", + " Block(\n", + " input_size=cfg.decoder_in_dim * 2,\n", + " output_size=cfg.first_modality_embedding_dim\n", + " + cfg.second_modality_embedding_dim,\n", + " hidden_size=cfg.decoder_hidden_dim,\n", + " batch_norm=cfg.batch_norm,\n", + " ),\n", + " )\n", + " # self.decoder = nn.Sequential(\n", + " # nn.Linear(200, 500),\n", + " # nn.ReLU(),\n", + " # nn.BatchNorm1d(500),\n", + " # nn.Linear(\n", + " # 500,\n", + " # cfg.first_modality_embedding_dim + cfg.second_modality_embedding_dim,\n", + " # ),\n", + " # nn.ReLU(),\n", + " # nn.BatchNorm1d(\n", + " # cfg.first_modality_embedding_dim + cfg.second_modality_embedding_dim\n", + " # ),\n", + " # )\n", + " self.fstmod_out = ShortcutBlock(\n", + " input_size=cfg.first_modality_embedding_dim,\n", + " output_size=cfg.first_modality_dim,\n", + " hidden_size=cfg.first_modality_hidden_dim,\n", + " batch_norm=cfg.batch_norm,\n", + " )\n", + " # self.fstmod_out = nn.Sequential(\n", + " # nn.Linear(cfg.first_modality_embedding_dim, cfg.first_modality_dim),\n", + " # nn.ReLU(),\n", + " # )\n", + " self.sndmod_out = ShortcutBlock(\n", + " input_size=cfg.second_modality_embedding_dim,\n", + " output_size=cfg.second_modality_dim,\n", + " hidden_size=cfg.second_modality_hidden_dim,\n", + " batch_norm=cfg.batch_norm,\n", + " )\n", + " # self.sndmod_out = nn.Sequential(\n", + " # nn.Linear(cfg.second_modality_embedding_dim, cfg.second_modality_dim),\n", + " # nn.ReLU(),\n", + " # )\n", + " if cfg.classification_head:\n", + " self.classification_head = Block(\n", + " input_size=cfg.decoder_in_dim,\n", + " output_size=cfg.num_classes,\n", + " hidden_size=cfg.num_classes * 2,\n", + " batch_norm=cfg.batch_norm,\n", + " )\n", + "\n", + " def _encode(self, x_fst: Tensor, x_snd: Tensor) -> Tensor:\n", + " x_fst = self.fstmod_in(x_fst)\n", + " # print(\"encode 0 passed\")\n", + " x_snd = self.sndmod_in(x_snd)\n", + " # print(\"encode 1 passed\")\n", + " encoder_out = self.encoder(torch.cat([x_fst, x_snd], dim=-1))\n", + " # print(encoder_out, encoder_out.shape)\n", + " return encoder_out\n", + "\n", + " def _decode(self, z: Tensor) -> Tuple[Tensor]:\n", + " # print(z.shape)\n", + " x_fst, x_snd = self.decoder(z).split(\n", + " [\n", + " self.cfg.first_modality_embedding_dim,\n", + " self.cfg.second_modality_embedding_dim,\n", + " ],\n", + " dim=-1,\n", + " )\n", + " # print(\"decode 0 passed\")\n", + " x_fst = self.fstmod_out(x_fst)\n", + " # print(\"decode 1 passed\")\n", + " x_snd = self.sndmod_out(x_snd)\n", + " # print(\"decode 2 passed\")\n", + "\n", + " return x_fst, x_snd\n", + "\n", + " def _classification_processing(\n", + " self, latent_representation: Tensor, y: Tensor, compute_accuracy: bool\n", + " ) -> Tuple[Tensor, Optional[Tensor], Optional[Tensor]]:\n", + " logits = self.classification_head(latent_representation)\n", + " c_loss = F.cross_entropy(logits, y, weight=self.cfg.class_weights)\n", + " if compute_accuracy:\n", + " acc = ((torch.argmax(logits, dim=1) == y).float().mean()).item()\n", + " bac = balanced_accuracy_score(\n", + " y.cpu().numpy(), torch.argmax(logits, dim=1).cpu().numpy()\n", + " )\n", + " return c_loss, acc, bac\n", + "\n", + " return c_loss, None, None\n", + "\n", + " def forward(\n", + " self, batch: Tuple[Tensor], compute_accuracy: bool = False\n", + " ) -> Tuple[Tensor, Dict[str, float]]:\n", + " metrics = {}\n", + " total_loss = 0.0\n", + " # x_fst, x_snd, *packed_labels_potentially = batch\n", + " x_fst, x_snd = batch.split(\n", + " [self.cfg.first_modality_dim, self.cfg.second_modality_dim], dim=-1\n", + " )\n", + " assert isinstance(x_fst, Tensor), TypeError(\n", + " f\"x_fst must be a Tensor, got {type(x_fst)} instead.\"\n", + " )\n", + " assert isinstance(x_snd, Tensor), TypeError(\n", + " f\"x_snd must be a Tensor, got {type(x_snd)} instead.\"\n", + " )\n", + " z = self._encode(x_fst, x_snd)\n", + " assert isinstance(z, Tensor), TypeError(\n", + " f\"z must be a Tensor, got {type(z)} instead.\"\n", + " )\n", + " x_fst_hat, x_snd_hat = self._decode(z)\n", + " assert isinstance(x_fst_hat, Tensor), TypeError(\n", + " f\"x_fst_hat must be a Tensor, got {type(x_fst_hat)} instead.\"\n", + " )\n", + " assert isinstance(x_snd_hat, Tensor), TypeError(\n", + " f\"x_snd_hat must be a Tensor, got {type(x_snd_hat)} instead.\"\n", + " )\n", + " recon_loss = F.mse_loss(x_fst_hat, x_fst) + F.mse_loss(x_snd_hat, x_snd)\n", + " metrics[\"recon_loss\"] = recon_loss.item()\n", + " total_loss += self.cfg.recon_loss_coef * recon_loss\n", + "\n", + " if self.cfg.classification_head:\n", + " c_loss, acc, bac = self._classification_processing(\n", + " z, *packed_labels_potentially, compute_accuracy\n", + " )\n", + " metrics[\"class_loss\"] = c_loss.item()\n", + " if acc is not None:\n", + " metrics[\"acc\"] = acc\n", + " metrics[\"bac\"] = bac\n", + " total_loss += self.cfg.c_loss_coef * c_loss\n", + "\n", + " return total_loss, metrics\n", + "\n", + " def training_step(self, batch: Tensor) -> Tensor:\n", + " loss, loss_components = self(batch)\n", + " self.log(\"Train loss\", loss, on_epoch=True, prog_bar=True)\n", + " for k, v in loss_components.items():\n", + " self.log(f\"Train {k}\", v, on_epoch=True, prog_bar=True)\n", + "\n", + " def validation_step(self, batch: Tensor) -> Tensor:\n", + " loss, loss_components = self(batch)\n", + " self.log(\"Val loss\", loss, on_epoch=True, prog_bar=True)\n", + " for k, v in loss_components.items():\n", + " self.log(f\"Val {k}\", v, on_epoch=True, prog_bar=True)\n", + "\n", + " def _predict(self, x: Tensor) -> Tensor:\n", + " if not self.classification_head:\n", + " raise ValueError(\"Model does not have a classification head\")\n", + " mu, _ = self._encode(x)\n", + " logits = self.classification_head(mu)\n", + "\n", + " return logits\n", + "\n", + " def _predict_proba(self, data: AnnData):\n", + " if not self.classification_head:\n", + " raise ValueError(\"Model does not have a classification head\")\n", + " mu, _ = self._encode(data)\n", + " logits = self.classification_head(mu)\n", + " return torch.softmax(logits, dim=1)\n", + "\n", + " def _get_decoder_jacobian(self, z: Tensor) -> Tensor:\n", + " return torch.autograd.functional.jacobian(self.decoder, z)\n", + "\n", + " def configure_optimizers(self):\n", + " return optim.Adam(self.parameters(), lr=self.cfg.lr)\n", + "\n", + " def assert_cfg(self, cfg: Namespace) -> None:\n", + " default_cfg = {\n", + " \"max_epochs\": 5,\n", + " \"log_every_n_steps\": 1,\n", + " \"first_modality_hidden_dim\": 50,\n", + " \"second_modality_hidden_dim\": 10,\n", + " \"first_modality_embedding_dim\": 50,\n", + " \"second_modality_embedding_dim\": 10,\n", + " \"encoder_hidden_dim\": 5000,\n", + " \"encoder_out_dim\": 40,\n", + " \"decoder_in_dim\": 20,\n", + " \"decoder_hidden_dim\": 20,\n", + " \"recon_loss_coef\": 1,\n", + " \"c_loss_coef\": 1,\n", + " \"kld_loss_coef\": 1,\n", + " \"lr\": 0.001,\n", + " }\n", + " for attr, default_value in default_cfg.items():\n", + " if not hasattr(cfg, attr):\n", + " setattr(cfg, attr, default_value)\n", + " print(f\"{attr} set as {default_value}\")\n", + "\n", + "\n", + "class OmiGMPriorProbabilisticAE(OmiAE):\n", + " def __init__(self, cfg: Namespace):\n", + " super(OmiGMPriorProbabilisticAE, self).__init__(cfg)\n", + " self.assert_cfg(cfg)\n", + " self.component_logits = nn.Parameter(\n", + " data=torch.zeros(size=(cfg.no_components,)), requires_grad=True\n", + " )\n", + " self.means = nn.Parameter(\n", + " torch.randn(cfg.no_components, cfg.latent_dim), requires_grad=True\n", + " )\n", + " # STDs of GMM\n", + " self.register_buffer(\n", + " \"stds\", cfg.components_std * torch.ones(cfg.no_components, cfg.latent_dim)\n", + " )\n", + "\n", + " def _var_transformation(self, logvar: Tensor) -> Tensor:\n", + " return torch.exp(0.5 * logvar)\n", + "\n", + " def forward(\n", + " self, batch: Tuple[Tensor], compute_accuracy: bool = False\n", + " ) -> Tuple[Tensor]:\n", + " metrics: Dict[str, float] = {}\n", + " total_loss: Tensor = 0.0\n", + " (\n", + " x_fst,\n", + " x_snd,\n", + " labels,\n", + " ) = batch # ASSUMPTION THAT ALL LABELS ARE AVAILABLE (the extension to the mix of alebeled + unlabeled is not difficuls, but it is not implemented here as it may not be necessary for the task at hand)\n", + " # print(x_fst.shape)\n", + " labels = torch.bernoulli(torch.ones_like(labels) * 0.5).long()\n", + " # assert (\n", + " # False\n", + " # ), \"The labels are random for now, this should be changed to the actual labels\"\n", + " z_means, z_stds = self._encode(x_fst, x_snd).chunk(2, dim=1)\n", + " z_stds = self._var_transformation(z_stds)\n", + " normal_rv = self._make_normal_rv(z_means, z_stds)\n", + " entropy_per_batch_sample = normal_rv.entropy().sum(dim=1).unsqueeze(0) # [1, B]\n", + " assert entropy_per_batch_sample.shape == (1, x_fst.shape[0]), AssertionError(\n", + " f\"Entropy shape is {entropy_per_batch_sample.shape}, expected {(1, x_fst.shape[0])}\"\n", + " )\n", + " z_sample = normal_rv.rsample(\n", + " sample_shape=(self.cfg.no_latent_samples,)\n", + " ).unsqueeze(\n", + " 2\n", + " ) # [K, B, 1, latent_dim]\n", + " assert z_sample.shape == (\n", + " self.cfg.no_latent_samples,\n", + " x_fst.shape[0],\n", + " 1,\n", + " self.cfg.latent_dim,\n", + " ), AssertionError(\n", + " f\"z_sample shape is {z_sample.shape}, expected {(self.cfg.no_latent_samples, x_fst.shape[0], 1, self.cfg.latent_dim)}\"\n", + " )\n", + "\n", + " gmm = self._make_gmm()\n", + " per_component_logprob = gmm.component_distribution.log_prob(\n", + " z_sample\n", + " ) # [K, B, no_components]\n", + " assert per_component_logprob.shape == (\n", + " self.cfg.no_latent_samples,\n", + " x_fst.shape[0],\n", + " self.cfg.no_components,\n", + " ), AssertionError(\n", + " f\"per_component_logprob shape is {per_component_logprob.shape}, expected {(self.cfg.no_latent_samples, x_fst.shape[0], self.cfg.no_components)}\"\n", + " )\n", + " component_indicator = torch.arange(self.cfg.no_components).unsqueeze(0).repeat(\n", + " (x_fst.shape[0], 1)\n", + " ) == labels.unsqueeze(1)\n", + " assert component_indicator.shape == (\n", + " x_fst.shape[0],\n", + " self.cfg.no_components,\n", + " ), AssertionError(\n", + " f\"component_indicator shape is {component_indicator.shape}, expected {(x_fst.shape[0], self.cfg.no_components)}\"\n", + " )\n", + " gmm_likelihood_per_k = per_component_logprob[:, component_indicator] # [K, B]\n", + " assert gmm_likelihood_per_k.shape == (\n", + " self.cfg.no_latent_samples,\n", + " x_fst.shape[0],\n", + " ), AssertionError(\n", + " f\"gmm_likelihood_per_k shape is {gmm_likelihood_per_k.shape}, expected {(self.cfg.no_latent_samples, x_fst.shape[0])}\"\n", + " )\n", + " x_fst_hat, x_snd_hat = self._decode(z_sample.squeeze(2))\n", + " recon_loss_per_k = F.mse_loss(\n", + " x_fst_hat, x_fst.repeat(self.cfg.no_latent_samples, 1, 1), reduction=\"none\"\n", + " ).mean(dim=-1) + F.mse_loss(\n", + " x_snd_hat, x_snd.repeat(self.cfg.no_latent_samples, 1, 1), reduction=\"none\"\n", + " ).mean(\n", + " dim=-1\n", + " ) # [K, B]\n", + " assert recon_loss_per_k.shape == (\n", + " self.cfg.no_latent_samples,\n", + " x_fst.shape[0],\n", + " ), AssertionError(\n", + " f\"recon_loss_per_k shape is {recon_loss_per_k.shape}, expected {(self.cfg.no_latent_samples, x_fst.shape[0])}\"\n", + " )\n", + "\n", + " if self.cfg.no_latent_samples > 1: # IWAE with no_latent_samples latent samples\n", + " total_loss = -torch.logsumexp(\n", + " # gmm_likelihood_per_k + recon_loss_per_k + entropy_per_batch_sample,\n", + " self.cfg.gmm_likelihood_loss_coef * gmm_likelihood_per_k\n", + " + self.cfg.entropy_loss_coef * entropy_per_batch_sample\n", + " + self.cfg.recon_loss_coef * recon_loss_per_k,\n", + " dim=0,\n", + " ).mean()\n", + " else: # IWAE reduces to VAE with one latent sample\n", + " total_loss = -(\n", + " gmm_likelihood_per_k + recon_loss_per_k + entropy_per_batch_sample\n", + " ).mean()\n", + "\n", + " metrics[\"entropy\"] = entropy_per_batch_sample.mean().item()\n", + " metrics[\"gmm_likelihood\"] = gmm_likelihood_per_k.mean().item()\n", + " metrics[\"recon_loss\"] = recon_loss_per_k.mean().item()\n", + "\n", + " if self.cfg.classification_head:\n", + " c_loss, acc, bac = self._classification_processing(\n", + " z_means, labels, compute_accuracy\n", + " )\n", + " metrics[\"class_loss\"] = c_loss.item()\n", + " if acc is not None:\n", + " metrics[\"acc\"] = acc\n", + " metrics[\"bac\"] = bac\n", + " total_loss += self.cfg.c_loss_coef * c_loss\n", + "\n", + " return total_loss, metrics\n", + "\n", + " def _make_normal_rv(self, mu: Tensor, logvar: Tensor):\n", + " return td.Normal(mu, self._var_transformation(logvar))\n", + "\n", + " def _make_gmm(self):\n", + " categorical = td.Categorical(logits=self.component_logits)\n", + " comp = td.Independent(\n", + " td.Normal(self.means, self.stds), reinterpreted_batch_ndims=1\n", + " )\n", + " return td.MixtureSameFamily(categorical, comp)\n", + "\n", + " def assert_cfg(self, cfg: Namespace) -> None:\n", + " super(OmiGMPriorProbabilisticAE, self).assert_cfg(cfg)\n", + " default_cfg = {\n", + " \"no_components\": 2,\n", + " \"components_std\": 1,\n", + " \"no_latent_samples\": 16,\n", + " \"gmm_likelihood_loss_coef\": 0.1,\n", + " \"entropy_loss_coef\": 0.1,\n", + " }\n", + " for attr, default_value in default_cfg.items():\n", + " if not hasattr(cfg, attr):\n", + " setattr(cfg, attr, default_value)\n", + " print(f\"{attr} set as {default_value}\")\n", + "\n", + " assert cfg.latent_dim * 2 == cfg.encoder_out_dim, ValueError(\n", + " \"The latent dimension must be twice the encoder output dimension\"\n", + " )\n", + "\n", + "\n", + "# class OmiHierarchicalGMPriorProbabilisticAE(OmiGMPriorProbabilisticAE): :) to be continued...\n", + "\n", + "# class M1M2 MODEL :) to be continued...\n", + "\n", + "# CLASS NALEŚNIK MODEL IF IT EVEN DIFFERES FROM THE ABOVE MODELS :) to be continued...\n", + "\n", + "_OMIVAE_IMPLEMENTATIONS = {\n", + " \"OmiAE\": OmiAE,\n", + " \"OmiGMPriorProbabilisticAE\": OmiGMPriorProbabilisticAE,\n", + "}\n", + "\n", + "\n", + "class OmiModel(ModelBase):\n", + " def __init__(self, cfg: Namespace):\n", + " super(OmiModel, self).__init__()\n", + " self.assert_cfg(cfg)\n", + " self.cfg = cfg\n", + " self.model = _OMIVAE_IMPLEMENTATIONS[cfg.omivae_implementation](cfg)\n", + " self.trainer = pl.Trainer(\n", + " max_epochs=cfg.max_epochs,\n", + " log_every_n_steps=cfg.log_every_n_steps,\n", + " logger=pl.loggers.TensorBoardLogger(\n", + " LOGS_PATH, name=cfg.omivae_implementation\n", + " ),\n", + " # callbacks=(\n", + " # [\n", + " # pl.callbacks.EarlyStopping(\n", + " # monitor=\"val_loss\",\n", + " # min_delta=cfg.min_delta,\n", + " # patience=cfg.patience,\n", + " # verbose=False,\n", + " # mode=\"min\",\n", + " # )\n", + " # ]\n", + " # if self.cfg.early_stopping\n", + " # else None\n", + " # ),\n", + " )\n", + "\n", + " def train(self, train_data: AnnData, val_data: AnnData = None) -> None:\n", + " print(\"batch_size\", self.cfg.batch_size)\n", + " # data = train_data.X.toarray()\n", + " # train_dataloader = DataLoader(data, batch_size=self.cfg.batch_size, shuffle=True)\n", + " self.trainer.fit(\n", + " model=self.model,\n", + " train_dataloaders=get_dataloader_from_anndata(\n", + " train_data,\n", + " batch_size=self.cfg.batch_size,\n", + " shuffle=True,\n", + " first_modality_dim=self.cfg.first_modality_dim,\n", + " second_modality_dim=self.cfg.second_modality_dim,\n", + " include_class_labels=self.cfg.classification_head\n", + " or self.cfg.include_class_labels,\n", + " target_hierarchy_level=self.cfg.target_hierarchy_level,\n", + " ),\n", + " # train_dataloaders=train_dataloader,\n", + " val_dataloaders=(\n", + " None\n", + " # get_dataset_from_anndata(\n", + " # val_data,\n", + " # self.cfg.first_modality_dim,\n", + " # self.cfg.second_modality_dim,\n", + " # include_class_labels=self.cfg.classification_head,\n", + " # )\n", + " # if val_data is not None\n", + " # else None\n", + " ),\n", + " )\n", + "\n", + " def predict(self, data: AnnData):\n", + " pass\n", + "\n", + " def predict_proba(self, data: AnnData):\n", + " pass\n", + "\n", + " def save(self, file_path: str):\n", + " save_path = file_path + \".ckpt\"\n", + " torch.save(self.model.state_dict(), save_path)\n", + " return save_path\n", + "\n", + " def load(self, file_path: str):\n", + " load_path = file_path + \".ckpt\"\n", + " self.model.load_state_dict(torch.load(load_path))\n", + "\n", + " def assert_cfg(self, cfg: Namespace) -> None:\n", + " self.assert_cfg_general(cfg)\n", + "\n", + " assert hasattr(cfg, \"omivae_implementation\"), AttributeError(\n", + " 'cfg does not have the attribute \"omivae_implementation\"'\n", + " )\n", + " assert cfg.omivae_implementation in _OMIVAE_IMPLEMENTATIONS, ValueError(\n", + " f\"Invalid OmiVAE implementation: {cfg.omivae_implementation}\"\n", + " )\n", + " assert hasattr(cfg, \"output_modelling_type\"), AttributeError(\n", + " 'cfg does not have the attribute \"output_modelling_type\"'\n", + " )\n", + " assert cfg.output_modelling_type in [\n", + " \"mse_direct_reconstruction\",\n", + " \"ll_neg_binomial\",\n", + " ], ValueError(\n", + " f\"Invalid output modelling type: {cfg.output_modelling_type}. Must be one of ['mse_direct_reconstruction', 'll_neg_binomial']\"\n", + " )\n", + "\n", + " if not hasattr(cfg, \"early_stopping\"):\n", + " setattr(cfg, \"early_stopping\", True)\n", + " print(f\"early_stopping set as True\")\n", + " if cfg.early_stopping:\n", + " if not hasattr(cfg, \"min_delta\"):\n", + " setattr(cfg, \"min_delta\", 0.001)\n", + " print(f\"min_delta set as 0.001\")\n", + " if not hasattr(cfg, \"patience\"):\n", + " setattr(cfg, \"patience\", 5)\n", + " print(f\"patience set as 5\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from utils.paths import CONFIG_PATH\n", + "from types import SimpleNamespace\n", + "import yaml\n", + "import json\n", + "\n", + "\n", + "def load_config(args) -> SimpleNamespace:\n", + " def load_object(dct):\n", + " return SimpleNamespace(**dct)\n", + "\n", + " with open(CONFIG_PATH / args.method / f\"{args.config}.yaml\") as file:\n", + " config_dict = yaml.safe_load(file)\n", + " config_namespace = json.loads(json.dumps(config_dict), object_hook=load_object)\n", + " return config_namespace" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cfg = load_config(Namespace(method=\"omivae\", config=\"vanilla_omivae\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: False, used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n" + ] + } + ], + "source": [ + "from models.omivae import OmiModel\n", + "\n", + "omimodel2 = OmiModel(cfg)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "batch_size 128\n", + "There are no nan values in GEX data.\n", + "There are no nan values in ADT data.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\configuration_validator.py:74: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------------\n", + "0 | fstmod_in | ShortcutBlock | 2.1 M \n", + "1 | sndmod_in | ShortcutBlock | 2.8 K \n", + "2 | encoder | Sequential | 9.6 K \n", + "3 | decoder | Sequential | 2.6 K \n", + "4 | fstmod_out | ShortcutBlock | 2.1 M \n", + "5 | sndmod_out | ShortcutBlock | 3.1 K \n", + "6 | classification_head | Block | 5.3 K \n", + "------------------------------------------------------\n", + "4.2 M Trainable params\n", + "0 Non-trainable params\n", + "4.2 M Total params\n", + "16.992 Total estimated model params size (MB)\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=3` in the `DataLoader` to improve performance.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 0%| | 1/517 [00:01<11:22, 0.76it/s, v_num=20, Train loss_step=1.72e+4, Train recon_loss_step=1.72e+4, Train class_loss_step=3.890]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\pytorch_lightning\\loops\\optimization\\automatic.py:132: `training_step` returned `None`. If this was on purpose, ignore this warning...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|█████████▉| 515/517 [00:51<00:00, 9.95it/s, v_num=20, Train loss_step=1.25e+5, Train recon_loss_step=1.25e+5, Train class_loss_step=3.900]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\call.py:54: Detected KeyboardInterrupt, attempting graceful shutdown...\n" + ] + } + ], + "source": [ + "from torch.utils.data import DataLoader, random_split\n", + "\n", + "omimodel2.train(adata)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There are no nan values in GEX data.\n", + "There are no nan values in ADT data.\n" + ] + } + ], + "source": [ + "train_dataloaders = get_dataloader_from_anndata(\n", + " adata,\n", + " batch_size=cfg.batch_size,\n", + " shuffle=True,\n", + " first_modality_dim=cfg.first_modality_dim,\n", + " second_modality_dim=cfg.second_modality_dim,\n", + " include_class_labels=cfg.classification_head or cfg.include_class_labels,\n", + " target_hierarchy_level=cfg.target_hierarchy_level,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "batch = next(iter(train_dataloaders))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a, b, t = batch" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor(396178.2812), tensor(7.2461), tensor(44))" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a.max(), b.max(), t.max()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/old_code/old_notebooks/pp-check-new-preprocessing.ipynb b/old_code/old_notebooks/pp-check-new-preprocessing.ipynb new file mode 100644 index 0000000..7ed7c38 --- /dev/null +++ b/old_code/old_notebooks/pp-check-new-preprocessing.ipynb @@ -0,0 +1,706 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.chdir(\"../src\")\n", + "\n", + "from utils import data_utils\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import anndata as ad\n", + "\n", + "pd.set_option(\"display.max_columns\", None)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading preprocessed data...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + } + ], + "source": [ + "adata = data_utils.load_anndata(mode=\"train\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GEX_n_genes_by_countsGEX_pct_counts_mtGEX_size_factorsGEX_phaseADT_n_antibodies_by_countsADT_total_countsADT_iso_countcell_typebatchADT_pseudotime_orderGEX_pseudotime_orderSamplenameSiteDonorNumberModalityVendorLotDonorIDDonorAgeDonorBMIDonorBloodTypeDonorRaceEthnicityDonorGenderQCMedsDonorSmokeris_trainsecond_hierarchy
GCATTAGCATAAGCGG-1-s1d18936.7239790.356535G11152828.05.0Naive CD20+ B IGKC+s1d1NaNNaNsite1_donor1_citesite1donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrainB Cells
TACAGGTGTTAGAGTA-1-s1d126068.0088291.292643S1378819.021.0CD14+ Monos1d1NaNNaNsite1_donor1_citesite1donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrainMonocytes
AGGATCTAGGTCTACT-1-s1d118676.9597070.970558G2M1164088.012.0Naive CD20+ B IGKC+s1d1NaNNaNsite1_donor1_citesite1donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrainB Cells
GTAGAAAGTGACACAG-1-s1d123606.1092341.232604G2M1244447.09.0HSCs1d1NaN0.000000site1_donor1_citesite1donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrainProgenitors and Stem Cells
TCCGAAAAGGATCATA-1-s1d14550.2943940.044585S13212875.024.0Reticulocytes1d10.7352610.964631site1_donor1_citesite1donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrainErythroid Lineage
....................................................................................
GTGTAACCATTAAGCC-1-s3d718797.0532321.254860G2M109570.06.0CD14+ Monos3d7NaNNaNsite3_donor7_citesite3donor7cite3054734114662231.5A+AsianNOT HISPANIC OR LATINOFemaleTrueNonsmokertrainMonocytes
CAGCCAGCAACGCATT-1-s3d716406.5595141.068252G2M111574.05.0CD14+ Monos3d7NaNNaNsite3_donor7_citesite3donor7cite3054734114662231.5A+AsianNOT HISPANIC OR LATINOFemaleTrueNonsmokertrainMonocytes
TCAGCAAAGGTCGTAG-1-s3d71530.0856600.014308G1104431.06.0Reticulocytes3d70.9388540.942716site3_donor7_citesite3donor7cite3054734114662231.5A+AsianNOT HISPANIC OR LATINOFemaleTrueNonsmokertrainErythroid Lineage
ATCACAGTCGCCAACG-1-s3d78227.0608500.409965G1120915.09.0CD14+ Monos3d7NaNNaNsite3_donor7_citesite3donor7cite3054734114662231.5A+AsianNOT HISPANIC OR LATINOFemaleTrueNonsmokertrainMonocytes
TTATTGCAGGTAGCCA-1-s3d716767.3420481.075299G2M114593.04.0CD14+ Monos3d7NaNNaNsite3_donor7_citesite3donor7cite3054734114662231.5A+AsianNOT HISPANIC OR LATINOFemaleTrueNonsmokertrainMonocytes
\n", + "

66175 rows × 27 columns

\n", + "
" + ], + "text/plain": [ + " GEX_n_genes_by_counts GEX_pct_counts_mt \\\n", + "GCATTAGCATAAGCGG-1-s1d1 893 6.723979 \n", + "TACAGGTGTTAGAGTA-1-s1d1 2606 8.008829 \n", + "AGGATCTAGGTCTACT-1-s1d1 1867 6.959707 \n", + "GTAGAAAGTGACACAG-1-s1d1 2360 6.109234 \n", + "TCCGAAAAGGATCATA-1-s1d1 455 0.294394 \n", + "... ... ... \n", + "GTGTAACCATTAAGCC-1-s3d7 1879 7.053232 \n", + "CAGCCAGCAACGCATT-1-s3d7 1640 6.559514 \n", + "TCAGCAAAGGTCGTAG-1-s3d7 153 0.085660 \n", + "ATCACAGTCGCCAACG-1-s3d7 822 7.060850 \n", + "TTATTGCAGGTAGCCA-1-s3d7 1676 7.342048 \n", + "\n", + " GEX_size_factors GEX_phase \\\n", + "GCATTAGCATAAGCGG-1-s1d1 0.356535 G1 \n", + "TACAGGTGTTAGAGTA-1-s1d1 1.292643 S \n", + "AGGATCTAGGTCTACT-1-s1d1 0.970558 G2M \n", + "GTAGAAAGTGACACAG-1-s1d1 1.232604 G2M \n", + "TCCGAAAAGGATCATA-1-s1d1 0.044585 S \n", + "... ... ... \n", + "GTGTAACCATTAAGCC-1-s3d7 1.254860 G2M \n", + "CAGCCAGCAACGCATT-1-s3d7 1.068252 G2M \n", + "TCAGCAAAGGTCGTAG-1-s3d7 0.014308 G1 \n", + "ATCACAGTCGCCAACG-1-s3d7 0.409965 G1 \n", + "TTATTGCAGGTAGCCA-1-s3d7 1.075299 G2M \n", + "\n", + " ADT_n_antibodies_by_counts ADT_total_counts \\\n", + "GCATTAGCATAAGCGG-1-s1d1 115 2828.0 \n", + "TACAGGTGTTAGAGTA-1-s1d1 137 8819.0 \n", + "AGGATCTAGGTCTACT-1-s1d1 116 4088.0 \n", + "GTAGAAAGTGACACAG-1-s1d1 124 4447.0 \n", + "TCCGAAAAGGATCATA-1-s1d1 132 12875.0 \n", + "... ... ... \n", + "GTGTAACCATTAAGCC-1-s3d7 109 570.0 \n", + "CAGCCAGCAACGCATT-1-s3d7 111 574.0 \n", + "TCAGCAAAGGTCGTAG-1-s3d7 104 431.0 \n", + "ATCACAGTCGCCAACG-1-s3d7 120 915.0 \n", + "TTATTGCAGGTAGCCA-1-s3d7 114 593.0 \n", + "\n", + " ADT_iso_count cell_type batch \\\n", + "GCATTAGCATAAGCGG-1-s1d1 5.0 Naive CD20+ B IGKC+ s1d1 \n", + "TACAGGTGTTAGAGTA-1-s1d1 21.0 CD14+ Mono s1d1 \n", + "AGGATCTAGGTCTACT-1-s1d1 12.0 Naive CD20+ B IGKC+ s1d1 \n", + "GTAGAAAGTGACACAG-1-s1d1 9.0 HSC s1d1 \n", + "TCCGAAAAGGATCATA-1-s1d1 24.0 Reticulocyte s1d1 \n", + "... ... ... ... \n", + "GTGTAACCATTAAGCC-1-s3d7 6.0 CD14+ Mono s3d7 \n", + "CAGCCAGCAACGCATT-1-s3d7 5.0 CD14+ Mono s3d7 \n", + "TCAGCAAAGGTCGTAG-1-s3d7 6.0 Reticulocyte s3d7 \n", + "ATCACAGTCGCCAACG-1-s3d7 9.0 CD14+ Mono s3d7 \n", + "TTATTGCAGGTAGCCA-1-s3d7 4.0 CD14+ Mono s3d7 \n", + "\n", + " ADT_pseudotime_order GEX_pseudotime_order \\\n", + "GCATTAGCATAAGCGG-1-s1d1 NaN NaN \n", + "TACAGGTGTTAGAGTA-1-s1d1 NaN NaN \n", + "AGGATCTAGGTCTACT-1-s1d1 NaN NaN \n", + "GTAGAAAGTGACACAG-1-s1d1 NaN 0.000000 \n", + "TCCGAAAAGGATCATA-1-s1d1 0.735261 0.964631 \n", + "... ... ... \n", + "GTGTAACCATTAAGCC-1-s3d7 NaN NaN \n", + "CAGCCAGCAACGCATT-1-s3d7 NaN NaN \n", + "TCAGCAAAGGTCGTAG-1-s3d7 0.938854 0.942716 \n", + "ATCACAGTCGCCAACG-1-s3d7 NaN NaN \n", + "TTATTGCAGGTAGCCA-1-s3d7 NaN NaN \n", + "\n", + " Samplename Site DonorNumber Modality \\\n", + "GCATTAGCATAAGCGG-1-s1d1 site1_donor1_cite site1 donor1 cite \n", + "TACAGGTGTTAGAGTA-1-s1d1 site1_donor1_cite site1 donor1 cite \n", + "AGGATCTAGGTCTACT-1-s1d1 site1_donor1_cite site1 donor1 cite \n", + "GTAGAAAGTGACACAG-1-s1d1 site1_donor1_cite site1 donor1 cite \n", + "TCCGAAAAGGATCATA-1-s1d1 site1_donor1_cite site1 donor1 cite \n", + "... ... ... ... ... \n", + "GTGTAACCATTAAGCC-1-s3d7 site3_donor7_cite site3 donor7 cite \n", + "CAGCCAGCAACGCATT-1-s3d7 site3_donor7_cite site3 donor7 cite \n", + "TCAGCAAAGGTCGTAG-1-s3d7 site3_donor7_cite site3 donor7 cite \n", + "ATCACAGTCGCCAACG-1-s3d7 site3_donor7_cite site3 donor7 cite \n", + "TTATTGCAGGTAGCCA-1-s3d7 site3_donor7_cite site3 donor7 cite \n", + "\n", + " VendorLot DonorID DonorAge DonorBMI \\\n", + "GCATTAGCATAAGCGG-1-s1d1 3054455 15078 34 24.8 \n", + "TACAGGTGTTAGAGTA-1-s1d1 3054455 15078 34 24.8 \n", + "AGGATCTAGGTCTACT-1-s1d1 3054455 15078 34 24.8 \n", + "GTAGAAAGTGACACAG-1-s1d1 3054455 15078 34 24.8 \n", + "TCCGAAAAGGATCATA-1-s1d1 3054455 15078 34 24.8 \n", + "... ... ... ... ... \n", + "GTGTAACCATTAAGCC-1-s3d7 3054734 11466 22 31.5 \n", + "CAGCCAGCAACGCATT-1-s3d7 3054734 11466 22 31.5 \n", + "TCAGCAAAGGTCGTAG-1-s3d7 3054734 11466 22 31.5 \n", + "ATCACAGTCGCCAACG-1-s3d7 3054734 11466 22 31.5 \n", + "TTATTGCAGGTAGCCA-1-s3d7 3054734 11466 22 31.5 \n", + "\n", + " DonorBloodType DonorRace Ethnicity \\\n", + "GCATTAGCATAAGCGG-1-s1d1 B- White HISPANIC OR LATINO \n", + "TACAGGTGTTAGAGTA-1-s1d1 B- White HISPANIC OR LATINO \n", + "AGGATCTAGGTCTACT-1-s1d1 B- White HISPANIC OR LATINO \n", + "GTAGAAAGTGACACAG-1-s1d1 B- White HISPANIC OR LATINO \n", + "TCCGAAAAGGATCATA-1-s1d1 B- White HISPANIC OR LATINO \n", + "... ... ... ... \n", + "GTGTAACCATTAAGCC-1-s3d7 A+ Asian NOT HISPANIC OR LATINO \n", + "CAGCCAGCAACGCATT-1-s3d7 A+ Asian NOT HISPANIC OR LATINO \n", + "TCAGCAAAGGTCGTAG-1-s3d7 A+ Asian NOT HISPANIC OR LATINO \n", + "ATCACAGTCGCCAACG-1-s3d7 A+ Asian NOT HISPANIC OR LATINO \n", + "TTATTGCAGGTAGCCA-1-s3d7 A+ Asian NOT HISPANIC OR LATINO \n", + "\n", + " DonorGender QCMeds DonorSmoker is_train \\\n", + "GCATTAGCATAAGCGG-1-s1d1 Male False Nonsmoker train \n", + "TACAGGTGTTAGAGTA-1-s1d1 Male False Nonsmoker train \n", + "AGGATCTAGGTCTACT-1-s1d1 Male False Nonsmoker train \n", + "GTAGAAAGTGACACAG-1-s1d1 Male False Nonsmoker train \n", + "TCCGAAAAGGATCATA-1-s1d1 Male False Nonsmoker train \n", + "... ... ... ... ... \n", + "GTGTAACCATTAAGCC-1-s3d7 Female True Nonsmoker train \n", + "CAGCCAGCAACGCATT-1-s3d7 Female True Nonsmoker train \n", + "TCAGCAAAGGTCGTAG-1-s3d7 Female True Nonsmoker train \n", + "ATCACAGTCGCCAACG-1-s3d7 Female True Nonsmoker train \n", + "TTATTGCAGGTAGCCA-1-s3d7 Female True Nonsmoker train \n", + "\n", + " second_hierarchy \n", + "GCATTAGCATAAGCGG-1-s1d1 B Cells \n", + "TACAGGTGTTAGAGTA-1-s1d1 Monocytes \n", + "AGGATCTAGGTCTACT-1-s1d1 B Cells \n", + "GTAGAAAGTGACACAG-1-s1d1 Progenitors and Stem Cells \n", + "TCCGAAAAGGATCATA-1-s1d1 Erythroid Lineage \n", + "... ... \n", + "GTGTAACCATTAAGCC-1-s3d7 Monocytes \n", + "CAGCCAGCAACGCATT-1-s3d7 Monocytes \n", + "TCAGCAAAGGTCGTAG-1-s3d7 Erythroid Lineage \n", + "ATCACAGTCGCCAACG-1-s3d7 Monocytes \n", + "TTATTGCAGGTAGCCA-1-s3d7 Monocytes \n", + "\n", + "[66175 rows x 27 columns]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adata.obs" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0. , 0. , 0. , ..., 0.15437832, 0.91724646,\n", + " 0.6068599 ],\n", + " [0. , 0. , 0. , ..., 2.0187593 , 0.72912055,\n", + " 1.9254438 ],\n", + " [0. , 0. , 0. , ..., 0. , 0.7554061 ,\n", + " 0.4064944 ],\n", + " ...,\n", + " [0. , 0. , 0. , ..., 0.93592685, 1.3115053 ,\n", + " 0. ],\n", + " [0. , 0. , 0. , ..., 1.4505513 , 1.0849457 ,\n", + " 1.0085349 ],\n", + " [0. , 0. , 0. , ..., 1.9302828 , 0.2472863 ,\n", + " 1.2598553 ]], dtype=float32)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adata.X.toarray()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_utils.get_dataset_from_anndata(adata)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_utils.get_dataset_from_anndata(adata, target_hierarchy_level=-2)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_utils.get_dataloader_from_anndata(\n", + " adata, batch_size=2, include_class_labels=False, target_hierarchy_level=-1\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/old_code/old_notebooks/pp-debugging-babel.ipynb b/old_code/old_notebooks/pp-debugging-babel.ipynb new file mode 100644 index 0000000..1449019 --- /dev/null +++ b/old_code/old_notebooks/pp-debugging-babel.ipynb @@ -0,0 +1,227 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.chdir(\"../src\")\n", + "\n", + "from utils import data_utils\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import anndata as ad\n", + "import scanpy as sc\n", + "\n", + "\n", + "pd.set_option(\"display.max_columns\", None)\n", + "\n", + "import argparse" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Subsampling anndata with fraction 1.0...\n" + ] + } + ], + "source": [ + "adata = data_utils.load_anndata(\n", + " mode=\"train\",\n", + " normalize=True,\n", + " remove_batch_effect=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from utils.paths import CONFIG_PATH\n", + "from argparse import Namespace\n", + "from types import SimpleNamespace\n", + "import yaml\n", + "import json\n", + "\n", + "\n", + "def load_config(args) -> SimpleNamespace:\n", + " def load_object(dct):\n", + " return SimpleNamespace(**dct)\n", + "\n", + " with open(CONFIG_PATH / args.method / f\"{args.config}.yaml\") as file:\n", + " config_dict = yaml.safe_load(file)\n", + " config_namespace = json.loads(json.dumps(config_dict), object_hook=load_object)\n", + " return config_namespace" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "cfg = load_config(Namespace(method=\"babel\", config=\"babel_vae\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from utils import data_utils" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There are no nan values in GEX data.\n", + "There are no nan values in ADT data.\n" + ] + } + ], + "source": [ + "dataloader_dict = data_utils.get_dataloader_dict_from_anndata(adata, cfg, train=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.2.5\n" + ] + } + ], + "source": [ + "import pytorch_lightning as pl\n", + "\n", + "print(pl.__version__)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "from pytorch_lightning.utilities.combined_loader import CombinedLoader" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "cdl = CombinedLoader(dataloader_dict, mode=\"max_size_cycle\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "batches = next(iter(cdl))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "namespace(gex=namespace(modality_name='GEX',\n", + " dim=13953,\n", + " hidden_dim=128,\n", + " encoder_hidden_dim=50,\n", + " encoder_out_dim=20,\n", + " latent_dim=10,\n", + " decoder_hidden_dim=50,\n", + " batch_norm=True,\n", + " dropout_rate=0.0,\n", + " recon_loss_coef=1,\n", + " kld_loss_coef=1,\n", + " batch_size=128,\n", + " lr=0.001),\n", + " adt=namespace(modality_name='ADT',\n", + " dim=134,\n", + " hidden_dim=128,\n", + " encoder_hidden_dim=50,\n", + " encoder_out_dim=20,\n", + " latent_dim=10,\n", + " decoder_hidden_dim=50,\n", + " batch_norm=True,\n", + " dropout_rate=0.0,\n", + " recon_loss_coef=1,\n", + " kld_loss_coef=1,\n", + " batch_size=128,\n", + " lr=0.001))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cfg.modalities" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/old_code/old_notebooks/pp-debugging-normalization.ipynb b/old_code/old_notebooks/pp-debugging-normalization.ipynb new file mode 100644 index 0000000..377555f --- /dev/null +++ b/old_code/old_notebooks/pp-debugging-normalization.ipynb @@ -0,0 +1,269 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.chdir(\"../src\")\n", + "\n", + "from utils import data_utils\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import anndata as ad\n", + "import scanpy as sc\n", + "\n", + "\n", + "pd.set_option(\"display.max_columns\", None)\n", + "\n", + "import argparse" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Subsampling anndata with fraction 1.0...\n" + ] + } + ], + "source": [ + "adata = data_utils.load_anndata(\n", + " mode=\"train\",\n", + " normalize=False,\n", + " remove_batch_effect=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Subsampling anndata with fraction 1.0...\n" + ] + } + ], + "source": [ + "adata_norm = data_utils.load_anndata(\n", + " mode=\"train\",\n", + " normalize=True,\n", + " remove_batch_effect=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0.8530548 , 0. , 0. , 0. ],\n", + " [0. , 0.65803015, 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 2.1703465 , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 1.4799873 , 0. ],\n", + " [0. , 1.2060345 , 0.6030173 , 0. , 0. ,\n", + " 0.6030173 , 0. , 0. , 1.2060345 , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 1.7444105 , 0. ]],\n", + " dtype=float32)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adata.X[:10, 40:50].toarray()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0.61683553, 0. , 0. , 0. ],\n", + " [0. , 0.50563025, 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 1.1538409 , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0.90825343, 0. ],\n", + " [0. , 0.7911966 , 0.47188765, 0. , 0. ,\n", + " 0.47188765, 0. , 0. , 0.7911966 , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 1.0095663 , 0. ]],\n", + " dtype=float32)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adata_norm.X[:10, 40:50].toarray()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\preprocessing\\_simple.py:398: UserWarning: Received a view of an AnnData. Making a copy.\n", + " view_to_actual(adata)\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0.61683553, 0. , 0. , 0. ],\n", + " [0. , 0.50563025, 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 1.1538409 , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0.90825343, 0. ],\n", + " [0. , 0.7911966 , 0.47188765, 0. , 0. ,\n", + " 0.47188765, 0. , 0. , 0.7911966 , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 1.0095663 , 0. ]],\n", + " dtype=float32)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import scanpy as sc\n", + "\n", + "sc.pp.log1p(adata)\n", + "adata.X[:10, 40:50].toarray()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(16.863785, 16.863785)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adata.X.max(), adata_norm.X.max()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Normalization by log1p seems to be working as expected now" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/old_code/old_notebooks/pp-debugging-omivae.ipynb b/old_code/old_notebooks/pp-debugging-omivae.ipynb new file mode 100644 index 0000000..769d40c --- /dev/null +++ b/old_code/old_notebooks/pp-debugging-omivae.ipynb @@ -0,0 +1,873 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.chdir(\"../src\")\n", + "\n", + "from utils import data_utils\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import anndata as ad\n", + "import scanpy as sc\n", + "\n", + "\n", + "pd.set_option(\"display.max_columns\", None)\n", + "\n", + "import argparse" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from src.models.components.omivae import OmiModel\n", + "from argparse import Namespace\n", + "\n", + "from src.utils.paths import CONFIG_PATH\n", + "from types import SimpleNamespace\n", + "import yaml\n", + "import json" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GCATTAGCATAAGCGG-1-s1d1 Naive CD20+ B IGKC+\n", + "TACAGGTGTTAGAGTA-1-s1d1 CD14+ Mono\n", + "AGGATCTAGGTCTACT-1-s1d1 Naive CD20+ B IGKC+\n", + "GTAGAAAGTGACACAG-1-s1d1 HSC\n", + "TCCGAAAAGGATCATA-1-s1d1 Reticulocyte\n", + " ... \n", + "GAATCACCACGGAAGT-1-s4d9 Lymph prog\n", + "GCTGGGTGTACGGATG-1-s4d9 CD8+ T naive\n", + "TCGAAGTGTGACAGGT-1-s4d9 T reg\n", + "GCAGGCTGTTGCATAC-1-s4d9 CD4+ T naive\n", + "ACGTAACAGGTCTACT-1-s4d9 CD8+ T naive\n", + "Name: cell_type, Length: 90261, dtype: category\n", + "Categories (45, object): ['B1 B IGKC+', 'B1 B IGKC-', 'CD4+ T CD314+ CD45RA+', 'CD4+ T activated', ..., 'dnT', 'gdT CD158b+', 'gdT TCRVD2+', 'pDC']\n", + "Second hierarchy mapping: GCATTAGCATAAGCGG-1-s1d1 B Cells\n", + "TACAGGTGTTAGAGTA-1-s1d1 Monocytes\n", + "AGGATCTAGGTCTACT-1-s1d1 B Cells\n", + "GTAGAAAGTGACACAG-1-s1d1 Progenitors and Stem Cells\n", + "TCCGAAAAGGATCATA-1-s1d1 Erythroid Lineage\n", + "Name: second_hierarchy, dtype: object\n", + "Subsampling anndata with fraction 1.0...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + } + ], + "source": [ + "adata_norm = data_utils.load_anndata(\n", + " mode=\"train\", normalize=True, remove_batch_effect=False, target_hierarchy_level=-2\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GEX_n_genes_by_countsGEX_pct_counts_mtGEX_size_factorsGEX_phaseADT_n_antibodies_by_countsADT_total_countsADT_iso_countcell_typebatchADT_pseudotime_orderGEX_pseudotime_orderSamplenameSiteDonorNumberModalityVendorLotDonorIDDonorAgeDonorBMIDonorBloodTypeDonorRaceEthnicityDonorGenderQCMedsDonorSmokeris_trainsecond_hierarchy
TCAAGCACACCGGCTA-1-s1d121196.0173031.172258G2M1275362.09.0CD4+ T activated integrinB7+s1d1NaNNaNsite1_donor1_citesite1donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrainT Cells
ACGTACAGTGAGAGGG-1-s2d518465.9539921.519687G2M1181417.05.0CD14+ Monos2d5NaNNaNsite2_donor5_citesite2donor5cite3054457167104027.8O+WhiteHISPANIC OR LATINOFemaleFalseSmokertrainMonocytes
TACAACGCATAGCACT-1-s3d1152411.2204312.931581S1332966.032.0Proerythroblasts3d10.9734890.874869site3_donor1_citesite3donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrainErythroid Lineage
GTAATGCCACAGCATT-1-s3d69863.9544380.460756S1061087.08.0Erythroblasts3d60.9099340.809380site3_donor6_citesite3donor6cite3059371280453623.8A+Other RaceHISPANIC OR LATINOFemaleFalseNonsmokertrainErythroid Lineage
TCGATTTGTGTTGATC-1-s3d612334.2168670.675681G2M100415.04.0CD16+ Monos3d6NaNNaNsite3_donor6_citesite3donor6cite3059371280453623.8A+Other RaceHISPANIC OR LATINOFemaleFalseNonsmokertrainMonocytes
....................................................................................
GATTCTTTCATTGTTC-1-s3d67986.7374010.353780G2M100363.03.0CD8+ T naives3d6NaNNaNsite3_donor6_citesite3donor6cite3059371280453623.8A+Other RaceHISPANIC OR LATINOFemaleFalseNonsmokertrainT Cells
GTCGCGACAGTTCCAA-1-s3d13571.4051520.408550S1291590.025.0Erythroblasts3d10.9678750.929695site3_donor1_citesite3donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrainErythroid Lineage
TACGTCCTCCCTTGTG-1-s2d112977.5817001.040512G11151199.05.0CD14+ Monos2d1NaNNaNsite2_donor1_citesite2donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrainMonocytes
TCTCAGCAGGATGAGA-1-s3d18774.7743811.349673G2M1333342.022.0Plasma cell IGKC+s3d1NaNNaNsite3_donor1_citesite3donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrainPlasma Cells
TTTCAGTGTTCATCTT-1-s3d715114.2716320.938302G2M105638.03.0CD14+ Monos3d7NaNNaNsite3_donor7_citesite3donor7cite3054734114662231.5A+AsianNOT HISPANIC OR LATINOFemaleTrueNonsmokertrainMonocytes
\n", + "

66175 rows × 27 columns

\n", + "
" + ], + "text/plain": [ + " GEX_n_genes_by_counts GEX_pct_counts_mt \\\n", + "TCAAGCACACCGGCTA-1-s1d1 2119 6.017303 \n", + "ACGTACAGTGAGAGGG-1-s2d5 1846 5.953992 \n", + "TACAACGCATAGCACT-1-s3d1 1524 11.220431 \n", + "GTAATGCCACAGCATT-1-s3d6 986 3.954438 \n", + "TCGATTTGTGTTGATC-1-s3d6 1233 4.216867 \n", + "... ... ... \n", + "GATTCTTTCATTGTTC-1-s3d6 798 6.737401 \n", + "GTCGCGACAGTTCCAA-1-s3d1 357 1.405152 \n", + "TACGTCCTCCCTTGTG-1-s2d1 1297 7.581700 \n", + "TCTCAGCAGGATGAGA-1-s3d1 877 4.774381 \n", + "TTTCAGTGTTCATCTT-1-s3d7 1511 4.271632 \n", + "\n", + " GEX_size_factors GEX_phase \\\n", + "TCAAGCACACCGGCTA-1-s1d1 1.172258 G2M \n", + "ACGTACAGTGAGAGGG-1-s2d5 1.519687 G2M \n", + "TACAACGCATAGCACT-1-s3d1 2.931581 S \n", + "GTAATGCCACAGCATT-1-s3d6 0.460756 S \n", + "TCGATTTGTGTTGATC-1-s3d6 0.675681 G2M \n", + "... ... ... \n", + "GATTCTTTCATTGTTC-1-s3d6 0.353780 G2M \n", + "GTCGCGACAGTTCCAA-1-s3d1 0.408550 S \n", + "TACGTCCTCCCTTGTG-1-s2d1 1.040512 G1 \n", + "TCTCAGCAGGATGAGA-1-s3d1 1.349673 G2M \n", + "TTTCAGTGTTCATCTT-1-s3d7 0.938302 G2M \n", + "\n", + " ADT_n_antibodies_by_counts ADT_total_counts \\\n", + "TCAAGCACACCGGCTA-1-s1d1 127 5362.0 \n", + "ACGTACAGTGAGAGGG-1-s2d5 118 1417.0 \n", + "TACAACGCATAGCACT-1-s3d1 133 2966.0 \n", + "GTAATGCCACAGCATT-1-s3d6 106 1087.0 \n", + "TCGATTTGTGTTGATC-1-s3d6 100 415.0 \n", + "... ... ... \n", + "GATTCTTTCATTGTTC-1-s3d6 100 363.0 \n", + "GTCGCGACAGTTCCAA-1-s3d1 129 1590.0 \n", + "TACGTCCTCCCTTGTG-1-s2d1 115 1199.0 \n", + "TCTCAGCAGGATGAGA-1-s3d1 133 3342.0 \n", + "TTTCAGTGTTCATCTT-1-s3d7 105 638.0 \n", + "\n", + " ADT_iso_count cell_type batch \\\n", + "TCAAGCACACCGGCTA-1-s1d1 9.0 CD4+ T activated integrinB7+ s1d1 \n", + "ACGTACAGTGAGAGGG-1-s2d5 5.0 CD14+ Mono s2d5 \n", + "TACAACGCATAGCACT-1-s3d1 32.0 Proerythroblast s3d1 \n", + "GTAATGCCACAGCATT-1-s3d6 8.0 Erythroblast s3d6 \n", + "TCGATTTGTGTTGATC-1-s3d6 4.0 CD16+ Mono s3d6 \n", + "... ... ... ... \n", + "GATTCTTTCATTGTTC-1-s3d6 3.0 CD8+ T naive s3d6 \n", + "GTCGCGACAGTTCCAA-1-s3d1 25.0 Erythroblast s3d1 \n", + "TACGTCCTCCCTTGTG-1-s2d1 5.0 CD14+ Mono s2d1 \n", + "TCTCAGCAGGATGAGA-1-s3d1 22.0 Plasma cell IGKC+ s3d1 \n", + "TTTCAGTGTTCATCTT-1-s3d7 3.0 CD14+ Mono s3d7 \n", + "\n", + " ADT_pseudotime_order GEX_pseudotime_order \\\n", + "TCAAGCACACCGGCTA-1-s1d1 NaN NaN \n", + "ACGTACAGTGAGAGGG-1-s2d5 NaN NaN \n", + "TACAACGCATAGCACT-1-s3d1 0.973489 0.874869 \n", + "GTAATGCCACAGCATT-1-s3d6 0.909934 0.809380 \n", + "TCGATTTGTGTTGATC-1-s3d6 NaN NaN \n", + "... ... ... \n", + "GATTCTTTCATTGTTC-1-s3d6 NaN NaN \n", + "GTCGCGACAGTTCCAA-1-s3d1 0.967875 0.929695 \n", + "TACGTCCTCCCTTGTG-1-s2d1 NaN NaN \n", + "TCTCAGCAGGATGAGA-1-s3d1 NaN NaN \n", + "TTTCAGTGTTCATCTT-1-s3d7 NaN NaN \n", + "\n", + " Samplename Site DonorNumber Modality \\\n", + "TCAAGCACACCGGCTA-1-s1d1 site1_donor1_cite site1 donor1 cite \n", + "ACGTACAGTGAGAGGG-1-s2d5 site2_donor5_cite site2 donor5 cite \n", + "TACAACGCATAGCACT-1-s3d1 site3_donor1_cite site3 donor1 cite \n", + "GTAATGCCACAGCATT-1-s3d6 site3_donor6_cite site3 donor6 cite \n", + "TCGATTTGTGTTGATC-1-s3d6 site3_donor6_cite site3 donor6 cite \n", + "... ... ... ... ... \n", + "GATTCTTTCATTGTTC-1-s3d6 site3_donor6_cite site3 donor6 cite \n", + "GTCGCGACAGTTCCAA-1-s3d1 site3_donor1_cite site3 donor1 cite \n", + "TACGTCCTCCCTTGTG-1-s2d1 site2_donor1_cite site2 donor1 cite \n", + "TCTCAGCAGGATGAGA-1-s3d1 site3_donor1_cite site3 donor1 cite \n", + "TTTCAGTGTTCATCTT-1-s3d7 site3_donor7_cite site3 donor7 cite \n", + "\n", + " VendorLot DonorID DonorAge DonorBMI \\\n", + "TCAAGCACACCGGCTA-1-s1d1 3054455 15078 34 24.8 \n", + "ACGTACAGTGAGAGGG-1-s2d5 3054457 16710 40 27.8 \n", + "TACAACGCATAGCACT-1-s3d1 3054455 15078 34 24.8 \n", + "GTAATGCCACAGCATT-1-s3d6 3059371 28045 36 23.8 \n", + "TCGATTTGTGTTGATC-1-s3d6 3059371 28045 36 23.8 \n", + "... ... ... ... ... \n", + "GATTCTTTCATTGTTC-1-s3d6 3059371 28045 36 23.8 \n", + "GTCGCGACAGTTCCAA-1-s3d1 3054455 15078 34 24.8 \n", + "TACGTCCTCCCTTGTG-1-s2d1 3054455 15078 34 24.8 \n", + "TCTCAGCAGGATGAGA-1-s3d1 3054455 15078 34 24.8 \n", + "TTTCAGTGTTCATCTT-1-s3d7 3054734 11466 22 31.5 \n", + "\n", + " DonorBloodType DonorRace Ethnicity \\\n", + "TCAAGCACACCGGCTA-1-s1d1 B- White HISPANIC OR LATINO \n", + "ACGTACAGTGAGAGGG-1-s2d5 O+ White HISPANIC OR LATINO \n", + "TACAACGCATAGCACT-1-s3d1 B- White HISPANIC OR LATINO \n", + "GTAATGCCACAGCATT-1-s3d6 A+ Other Race HISPANIC OR LATINO \n", + "TCGATTTGTGTTGATC-1-s3d6 A+ Other Race HISPANIC OR LATINO \n", + "... ... ... ... \n", + "GATTCTTTCATTGTTC-1-s3d6 A+ Other Race HISPANIC OR LATINO \n", + "GTCGCGACAGTTCCAA-1-s3d1 B- White HISPANIC OR LATINO \n", + "TACGTCCTCCCTTGTG-1-s2d1 B- White HISPANIC OR LATINO \n", + "TCTCAGCAGGATGAGA-1-s3d1 B- White HISPANIC OR LATINO \n", + "TTTCAGTGTTCATCTT-1-s3d7 A+ Asian NOT HISPANIC OR LATINO \n", + "\n", + " DonorGender QCMeds DonorSmoker is_train \\\n", + "TCAAGCACACCGGCTA-1-s1d1 Male False Nonsmoker train \n", + "ACGTACAGTGAGAGGG-1-s2d5 Female False Smoker train \n", + "TACAACGCATAGCACT-1-s3d1 Male False Nonsmoker train \n", + "GTAATGCCACAGCATT-1-s3d6 Female False Nonsmoker train \n", + "TCGATTTGTGTTGATC-1-s3d6 Female False Nonsmoker train \n", + "... ... ... ... ... \n", + "GATTCTTTCATTGTTC-1-s3d6 Female False Nonsmoker train \n", + "GTCGCGACAGTTCCAA-1-s3d1 Male False Nonsmoker train \n", + "TACGTCCTCCCTTGTG-1-s2d1 Male False Nonsmoker train \n", + "TCTCAGCAGGATGAGA-1-s3d1 Male False Nonsmoker train \n", + "TTTCAGTGTTCATCTT-1-s3d7 Female True Nonsmoker train \n", + "\n", + " second_hierarchy \n", + "TCAAGCACACCGGCTA-1-s1d1 T Cells \n", + "ACGTACAGTGAGAGGG-1-s2d5 Monocytes \n", + "TACAACGCATAGCACT-1-s3d1 Erythroid Lineage \n", + "GTAATGCCACAGCATT-1-s3d6 Erythroid Lineage \n", + "TCGATTTGTGTTGATC-1-s3d6 Monocytes \n", + "... ... \n", + "GATTCTTTCATTGTTC-1-s3d6 T Cells \n", + "GTCGCGACAGTTCCAA-1-s3d1 Erythroid Lineage \n", + "TACGTCCTCCCTTGTG-1-s2d1 Monocytes \n", + "TCTCAGCAGGATGAGA-1-s3d1 Plasma Cells \n", + "TTTCAGTGTTCATCTT-1-s3d7 Monocytes \n", + "\n", + "[66175 rows x 27 columns]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adata_norm.obs" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "[enforce fail at alloc_cpu.cpp:114] data. DefaultCPUAllocator: not enough memory: you tried to allocate 3728828900 bytes.", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[5], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mdata_utils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_simple_dataloader_from_anndata\u001b[49m\u001b[43m(\u001b[49m\u001b[43madata_norm\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m32\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\dlls-hack\\D4L-Hackaton\\src\\utils\\data_utils.py:313\u001b[0m, in \u001b[0;36mget_simple_dataloader_from_anndata\u001b[1;34m(data, include_class_labels, batch_size, shuffle)\u001b[0m\n\u001b[0;32m 309\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m include_class_labels:\n\u001b[0;32m 310\u001b[0m targets \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mtensor(\n\u001b[0;32m 311\u001b[0m data\u001b[38;5;241m.\u001b[39mobs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msecond_hierarchy\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mcat\u001b[38;5;241m.\u001b[39mcodes\u001b[38;5;241m.\u001b[39mvalues, dtype\u001b[38;5;241m=\u001b[39mtorch\u001b[38;5;241m.\u001b[39mlong\n\u001b[0;32m 312\u001b[0m )\n\u001b[1;32m--> 313\u001b[0m X \u001b[38;5;241m=\u001b[39m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mX\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtoarray\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfloat32\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 314\u001b[0m dataset \u001b[38;5;241m=\u001b[39m TensorDataset(X, targets)\n\u001b[0;32m 315\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "\u001b[1;31mRuntimeError\u001b[0m: [enforce fail at alloc_cpu.cpp:114] data. DefaultCPUAllocator: not enough memory: you tried to allocate 3728828900 bytes." + ] + } + ], + "source": [ + "data_utils.get_simple_dataloader_from_anndata(\n", + " adata_norm,\n", + " True,\n", + " 32,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def load_config(args) -> SimpleNamespace:\n", + " def load_object(dct):\n", + " return SimpleNamespace(**dct)\n", + "\n", + " with open(CONFIG_PATH / args.method / f\"{args.config}.yaml\") as file:\n", + " config_dict = yaml.safe_load(file)\n", + " config_namespace = json.loads(json.dumps(config_dict), object_hook=load_object)\n", + " return config_namespace" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first_modality_dim set as 13953\n", + "first_modality_hidden_dim set as 50\n", + "second_modality_hidden_dim set as 10\n", + "first_modality_embedding_dim set as 50\n", + "second_modality_embedding_dim set as 10\n", + "decoder_in_dim set as 20\n", + "kld_loss_coef set as 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: False, used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n" + ] + } + ], + "source": [ + "cfg = load_config(Namespace(method=\"omivae\", config=\"omiae-simple\"))\n", + "omimodel = OmiModel(cfg)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "batch_size 128\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\configuration_validator.py:74: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n", + "\n", + " | Name | Type | Params\n", + "---------------------------------------\n", + "0 | encoder | Sequential | 710 K \n", + "1 | decoder | Sequential | 721 K \n", + "---------------------------------------\n", + "1.4 M Trainable params\n", + "0 Non-trainable params\n", + "1.4 M Total params\n", + "5.726 Total estimated model params size (MB)\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=3` in the `DataLoader` to improve performance.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 1%| | 3/517 [00:00<00:26, 19.09it/s, v_num=8, Train loss_step=0.174, Train recon_loss_step=0.174]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\pytorch_lightning\\loops\\optimization\\automatic.py:132: `training_step` returned `None`. If this was on purpose, ignore this warning...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 11: 98%|█████████▊| 508/517 [00:09<00:00, 51.80it/s, v_num=8, Train loss_step=0.173, Train recon_loss_step=0.173, Train loss_epoch=0.170, Train recon_loss_epoch=0.170]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\call.py:54: Detected KeyboardInterrupt, attempting graceful shutdown...\n" + ] + } + ], + "source": [ + "omimodel.train(adata_norm)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "\n", + "data = torch.tensor(adata_norm.X.toarray())" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "latent_embeddings = omimodel.model._encode(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([66175, 10])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "latent_embeddings.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\przem\\AppData\\Local\\Temp\\ipykernel_4440\\2128738621.py:1: ImplicitModificationWarning: Setting element `.obsm['latent_embeddings']` of view, initializing view as actual.\n", + " adata_norm.obsm['latent_embeddings'] = latent_embeddings.detach().numpy()\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "adata_norm.obsm[\"latent_embeddings\"] = latent_embeddings.detach().numpy()\n", + "\n", + "sc.pp.neighbors(adata_norm, n_neighbors=10, use_rep=\"latent_embeddings\")\n", + "sc.tl.umap(adata_norm)\n", + "sc.pl.umap(adata_norm, color=\"cell_type\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/old_code/old_notebooks/pp-eda.ipynb b/old_code/old_notebooks/pp-eda.ipynb new file mode 100644 index 0000000..9bafcc9 --- /dev/null +++ b/old_code/old_notebooks/pp-eda.ipynb @@ -0,0 +1,126585 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.chdir(\"../src\")\n", + "\n", + "from utils import data_utils\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import anndata as ad\n", + "\n", + "pd.set_option(\"display.max_columns\", None)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.distributions as td" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([5, 2, 1, 2])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "means = torch.tensor([[0.0, 0.0], [1.0, 1.0]])\n", + "normal_rv = td.Normal(means, torch.ones(2))\n", + "\n", + "z_sample = normal_rv.sample((5,)).unsqueeze(2) # K, BATCH, dummy, latent_dim\n", + "z_sample.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "gmm_means = torch.tensor([[0.0, 0.0], [1.0, 1.0], [2.0, 2.0]])\n", + "gmm_stds = torch.ones((3, 2))\n", + "logits = torch.tensor([0.0, 0.0, 0.0])\n", + "categorical = td.Categorical(logits=logits)\n", + "comp = td.Independent(td.Normal(gmm_means, gmm_stds), reinterpreted_batch_ndims=1)\n", + "gmm_rv = td.MixtureSameFamily(categorical, comp)" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.Size([1, 1, 3, 2]), torch.Size([1, 1, 3]))" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "comp_sample = comp.sample((1,))\n", + "comp_sample.shape, comp.log_prob(comp_sample).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Independent(Normal(loc: torch.Size([3, 2]), scale: torch.Size([3, 2])), 1)" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gmm_rv.component_distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([5, 2, 3])" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gmm_rv.component_distribution.log_prob(z_sample).shape # K, BASTCH, components" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch.distributions import MultivariateNormal\n", + "\n", + "# A batch of 3 multivariate normal distributions, each in 2D\n", + "mean = torch.zeros(3, 2)\n", + "covariance_matrix = torch.eye(2).repeat(3, 1, 1)\n", + "mvn = MultivariateNormal(mean, covariance_matrix)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "from torch.distributions import Independent\n", + "\n", + "# Reinterpret the last batch dimension as an event dimension\n", + "indep_mvn = Independent(mvn, reinterpreted_batch_ndims=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(Independent(MultivariateNormal(loc: torch.Size([3, 2]), covariance_matrix: torch.Size([3, 2, 2])), 1),\n", + " Independent(Normal(loc: torch.Size([3, 2]), scale: torch.Size([3, 2])), 1))" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "indep_mvn, gmm_rv.component_distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original log prob shape: torch.Size([2, 3]) Value: tensor([[-2.4213, -2.5484, -2.0087],\n", + " [-1.9075, -1.8429, -2.5523]])\n", + "Reinterpreted log prob shape: torch.Size([2]) Value: tensor([-6.9785, -6.3026])\n" + ] + } + ], + "source": [ + "import torch\n", + "from torch.distributions import MultivariateNormal, Independent\n", + "\n", + "# A batch of 3 multivariate normal distributions, each in 2D\n", + "mean = torch.zeros(3, 2)\n", + "covariance_matrix = torch.eye(2).repeat(3, 1, 1)\n", + "mvn = MultivariateNormal(mean, covariance_matrix)\n", + "\n", + "# Sample from the original distribution\n", + "sample = mvn.sample((2,)) # Shape: [3, 2]\n", + "\n", + "# Compute log probability for the sample\n", + "log_prob_mvn = mvn.log_prob(sample) # Shape: [3]\n", + "\n", + "# Use Independent to reinterpret the last batch dimension\n", + "indep_mvn = Independent(mvn, reinterpreted_batch_ndims=1)\n", + "\n", + "# Compute log probability for the same sample\n", + "log_prob_indep_mvn = indep_mvn.log_prob(sample) # Shape: []\n", + "\n", + "print(f\"Original log prob shape: {log_prob_mvn.shape} Value: {log_prob_mvn}\")\n", + "print(\n", + " f\"Reinterpreted log prob shape: {log_prob_indep_mvn.shape} Value: {log_prob_indep_mvn}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# -----" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + } + ], + "source": [ + "data = data_utils.load_anndata(mode=\"train\", plus_iid_holdout=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'dataset_id': 'openproblems_bmmc_cite',\n", + " 'genome': 'GRCh38',\n", + " 'organism': 'human'}" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.uns" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "GCATTAGCATAAGCGG-1-s1d1 Naive CD20+ B IGKC+\n", + "TACAGGTGTTAGAGTA-1-s1d1 CD14+ Mono\n", + "AGGATCTAGGTCTACT-1-s1d1 Naive CD20+ B IGKC+\n", + "GTAGAAAGTGACACAG-1-s1d1 HSC\n", + "TCCGAAAAGGATCATA-1-s1d1 Reticulocyte\n", + " ... \n", + "TCCACGTCATGGTGGA-1-s4d9 CD4+ T activated\n", + "ATCACAGAGATTACCC-1-s4d9 Naive CD20+ B IGKC+\n", + "ATCATTCGTGATCGTT-1-s4d9 CD4+ T naive\n", + "TTCCACGGTTGAGGAC-1-s4d9 NK\n", + "GAATCACCACGGAAGT-1-s4d9 Lymph prog\n", + "Name: cell_type, Length: 75195, dtype: category\n", + "Categories (45, object): ['B1 B IGKC+', 'B1 B IGKC-', 'CD4+ T CD314+ CD45RA+', 'CD4+ T activated', ..., 'dnT', 'gdT CD158b+', 'gdT TCRVD2+', 'pDC']" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.obs[\"cell_type\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(75195, 14087)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.X.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import statsmodels.api as sm\n", + "\n", + "\n", + "def fit_negative_binomial(counts):\n", + " \"\"\"\n", + " Fit a negative binomial model to each gene and estimate the dispersion parameter.\n", + "\n", + " Parameters:\n", + " counts (numpy.ndarray): The count matrix with genes as rows and cells as columns.\n", + "\n", + " Returns:\n", + " tuple: A tuple containing the mean counts and dispersion parameters for each gene.\n", + " \"\"\"\n", + " n_genes, n_cells = counts.shape\n", + " mean_counts = np.mean(counts, axis=1)\n", + " dispersions = np.zeros(n_genes)\n", + "\n", + " for i in range(n_genes):\n", + " y = counts[i, :]\n", + " X = np.ones((n_cells, 1)) # Design matrix with intercept only\n", + "\n", + " # Fit the negative binomial model\n", + " model = sm.GLM(y, X, family=sm.families.NegativeBinomial())\n", + " results = model.fit()\n", + "\n", + " # Extract the dispersion parameter\n", + " dispersions[i] = results.scale\n", + "\n", + " return mean_counts, dispersions" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\families\\family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[6], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m mean_counts, dispersions \u001b[38;5;241m=\u001b[39m \u001b[43mfit_negative_binomial\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mX\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtoarray\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[1;32mIn[4], line 23\u001b[0m, in \u001b[0;36mfit_negative_binomial\u001b[1;34m(counts)\u001b[0m\n\u001b[0;32m 21\u001b[0m \u001b[38;5;66;03m# Fit the negative binomial model\u001b[39;00m\n\u001b[0;32m 22\u001b[0m model \u001b[38;5;241m=\u001b[39m sm\u001b[38;5;241m.\u001b[39mGLM(y, X, family\u001b[38;5;241m=\u001b[39msm\u001b[38;5;241m.\u001b[39mfamilies\u001b[38;5;241m.\u001b[39mNegativeBinomial())\n\u001b[1;32m---> 23\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 25\u001b[0m \u001b[38;5;66;03m# Extract the dispersion parameter\u001b[39;00m\n\u001b[0;32m 26\u001b[0m dispersions[i] \u001b[38;5;241m=\u001b[39m results\u001b[38;5;241m.\u001b[39mscale\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\generalized_linear_model.py:1192\u001b[0m, in \u001b[0;36mGLM.fit\u001b[1;34m(self, start_params, maxiter, method, tol, scale, cov_type, cov_kwds, use_t, full_output, disp, max_start_irls, **kwargs)\u001b[0m\n\u001b[0;32m 1190\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cov_type\u001b[38;5;241m.\u001b[39mlower() \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124meim\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[0;32m 1191\u001b[0m cov_type \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnonrobust\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m-> 1192\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_fit_irls\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstart_params\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstart_params\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmaxiter\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmaxiter\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1193\u001b[0m \u001b[43m \u001b[49m\u001b[43mtol\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtol\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscale\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcov_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcov_type\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1194\u001b[0m \u001b[43m \u001b[49m\u001b[43mcov_kwds\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcov_kwds\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43muse_t\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_t\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1195\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 1196\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_optim_hessian \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124moptim_hessian\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\statsmodels\\genmod\\generalized_linear_model.py:1339\u001b[0m, in \u001b[0;36mGLM._fit_irls\u001b[1;34m(self, start_params, maxiter, tol, scale, cov_type, cov_kwds, use_t, **kwargs)\u001b[0m\n\u001b[0;32m 1337\u001b[0m history \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_update_history(wls_results, mu, history)\n\u001b[0;32m 1338\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mscale \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimate_scale(mu)\n\u001b[1;32m-> 1339\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m endog\u001b[38;5;241m.\u001b[39msqueeze()\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mallclose\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmu\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mendog\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m:\n\u001b[0;32m 1340\u001b[0m msg \u001b[38;5;241m=\u001b[39m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPerfect separation or prediction detected, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 1341\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mparameter may not be identified\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 1342\u001b[0m warnings\u001b[38;5;241m.\u001b[39mwarn(msg, category\u001b[38;5;241m=\u001b[39mPerfectSeparationWarning)\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\numpy\\core\\numeric.py:2241\u001b[0m, in \u001b[0;36mallclose\u001b[1;34m(a, b, rtol, atol, equal_nan)\u001b[0m\n\u001b[0;32m 2170\u001b[0m \u001b[38;5;129m@array_function_dispatch\u001b[39m(_allclose_dispatcher)\n\u001b[0;32m 2171\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mallclose\u001b[39m(a, b, rtol\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1.e-5\u001b[39m, atol\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1.e-8\u001b[39m, equal_nan\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m):\n\u001b[0;32m 2172\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 2173\u001b[0m \u001b[38;5;124;03m Returns True if two arrays are element-wise equal within a tolerance.\u001b[39;00m\n\u001b[0;32m 2174\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 2239\u001b[0m \n\u001b[0;32m 2240\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[1;32m-> 2241\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mall\u001b[39m(\u001b[43misclose\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mb\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrtol\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrtol\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43matol\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43matol\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mequal_nan\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mequal_nan\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[0;32m 2242\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mbool\u001b[39m(res)\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\numpy\\core\\numeric.py:2351\u001b[0m, in \u001b[0;36misclose\u001b[1;34m(a, b, rtol, atol, equal_nan)\u001b[0m\n\u001b[0;32m 2349\u001b[0m yfin \u001b[38;5;241m=\u001b[39m isfinite(y)\n\u001b[0;32m 2350\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mall\u001b[39m(xfin) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mall\u001b[39m(yfin):\n\u001b[1;32m-> 2351\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mwithin_tol\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43matol\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrtol\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 2352\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 2353\u001b[0m finite \u001b[38;5;241m=\u001b[39m xfin \u001b[38;5;241m&\u001b[39m yfin\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\numpy\\core\\numeric.py:2331\u001b[0m, in \u001b[0;36misclose..within_tol\u001b[1;34m(x, y, atol, rtol)\u001b[0m\n\u001b[0;32m 2330\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwithin_tol\u001b[39m(x, y, atol, rtol):\n\u001b[1;32m-> 2331\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mwith\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43merrstate\u001b[49m\u001b[43m(\u001b[49m\u001b[43minvalid\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mignore\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_no_nep50_warning\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\n\u001b[0;32m 2332\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mreturn\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mless_equal\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mabs\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43matol\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mrtol\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mabs\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\contextlib.py:137\u001b[0m, in \u001b[0;36m_GeneratorContextManager.__enter__\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 135\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39margs, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mkwds, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc\n\u001b[0;32m 136\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 137\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mnext\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgen\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 138\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mStopIteration\u001b[39;00m:\n\u001b[0;32m 139\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgenerator didn\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt yield\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\numpy\\core\\_ufunc_config.py:452\u001b[0m, in \u001b[0;36m_no_nep50_warning\u001b[1;34m()\u001b[0m\n\u001b[0;32m 447\u001b[0m _setdef()\n\u001b[0;32m 450\u001b[0m NO_NEP50_WARNING \u001b[38;5;241m=\u001b[39m contextvars\u001b[38;5;241m.\u001b[39mContextVar(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_no_nep50_warning\u001b[39m\u001b[38;5;124m\"\u001b[39m, default\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[1;32m--> 452\u001b[0m \u001b[38;5;129m@set_module\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnumpy\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m 453\u001b[0m \u001b[38;5;129m@contextlib\u001b[39m\u001b[38;5;241m.\u001b[39mcontextmanager\n\u001b[0;32m 454\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_no_nep50_warning\u001b[39m():\n\u001b[0;32m 455\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 456\u001b[0m \u001b[38;5;124;03m Context manager to disable NEP 50 warnings. This context manager is\u001b[39;00m\n\u001b[0;32m 457\u001b[0m \u001b[38;5;124;03m only relevant if the NEP 50 warnings are enabled globally (which is not\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 460\u001b[0m \u001b[38;5;124;03m This warning context manager itself is fully safe, however.\u001b[39;00m\n\u001b[0;32m 461\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m 462\u001b[0m token \u001b[38;5;241m=\u001b[39m NO_NEP50_WARNING\u001b[38;5;241m.\u001b[39mset(\u001b[38;5;28;01mTrue\u001b[39;00m)\n", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "mean_counts, dispersions = fit_negative_binomial(data.X.toarray())" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0. , 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. , 2.804775, 0. ,\n", + " 2.804775, 0. , 0. , 0. , 0. ]], dtype=float32)" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data[0, 7:30].X.toarray()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.special import gammaln\n", + "from scipy.optimize import minimize\n", + "from tqdm import tqdm\n", + "\n", + "\n", + "def estimate_initial_params(counts):\n", + " \"\"\"\n", + " Estimate the initial dispersion parameter (alpha) for each gene using a moment-based approach.\n", + "\n", + " Parameters:\n", + " counts (numpy.ndarray): The count matrix with genes as rows and cells as columns.\n", + "\n", + " Returns:\n", + " numpy.ndarray: An array of initial dispersion parameters (alpha) for each gene.\n", + " \"\"\"\n", + " mean_counts = np.mean(counts, axis=0)\n", + " var_counts = np.var(counts, axis=0)\n", + " dispersions = (var_counts - mean_counts) / (mean_counts**2)\n", + " dispersions = np.clip(dispersions, 1e-10, None) # Ensure non-negative dispersions\n", + " return mean_counts, dispersions\n", + "\n", + "\n", + "def negative_binomial_log_likelihood(params, y):\n", + " \"\"\"\n", + " Negative binomial log-likelihood function.\n", + "\n", + " Parameters:\n", + " params (numpy.ndarray): Parameters of the negative binomial (mean, dispersion).\n", + " y (numpy.ndarray): Observed counts.\n", + "\n", + " Returns:\n", + " float: Negative log-likelihood.\n", + " \"\"\"\n", + " mean, dispersion = params\n", + " likelihood = (\n", + " gammaln(y + dispersion)\n", + " - gammaln(dispersion)\n", + " - gammaln(y + 1)\n", + " + y * np.log(mean / (mean + dispersion))\n", + " + dispersion * np.log(dispersion / (mean + dispersion))\n", + " )\n", + " return -np.sum(likelihood)\n", + "\n", + "\n", + "def fit_negative_binomial_scipy(counts):\n", + " \"\"\"\n", + " Fit a negative binomial model to each gene using scipy optimization.\n", + "\n", + " Parameters:\n", + " counts (numpy.ndarray): The count matrix with genes as rows and cells as columns.\n", + "\n", + " Returns:\n", + " tuple: A tuple containing the mean counts and dispersion parameters for each gene.\n", + " \"\"\"\n", + " n_cells, n_genes = counts.shape\n", + " mean_counts, dispersions = estimate_initial_params(counts)\n", + "\n", + " progress_bar = tqdm(range(n_genes), desc=\"Fitting negative binomial\")\n", + " for i in progress_bar:\n", + " progress_bar.set_postfix_str(f\"Gene {i}\")\n", + " y = counts[i, :]\n", + " initial_params = np.array(\n", + " [mean_counts[i], 1.0]\n", + " ) # Initial guess for mean and dispersion\n", + "\n", + " # Minimize the negative log-likelihood\n", + " result = minimize(\n", + " negative_binomial_log_likelihood,\n", + " initial_params,\n", + " args=(y,),\n", + " bounds=[(1e-10, None), (1e-10, None)],\n", + " )\n", + "\n", + " if result.success:\n", + " mean_counts[i], dispersions[i] = result.x\n", + " else:\n", + " print(f\"Optimization failed for gene {i}\")\n", + " (\n", + " mean_counts[i],\n", + " dispersions[i],\n", + " ) = initial_params # Use initial values if optimization fails\n", + "\n", + " return mean_counts, dispersions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Tuple\n", + "from torch import Tensor\n", + "\n", + "def estimate_initial_params(counts: Tensor) -> Tuple[Tensor]:\n", + " \"\"\"\n", + " Estimate the initial dispersion parameter (alpha) for each gene using a moment-based approach.\n", + " \n", + " Parameters:\n", + " counts (Tensor): The count matrix with genes as rows and cells as columns.\n", + " \n", + " Returns:\n", + " Tuple[Tensor]: A tuple of initial mean counts and dispersions for each gene.\n", + " \"\"\"\n", + " mean_counts = counts.mean(dim=1)\n", + " var_counts = counts.var(dim=1)\n", + " dispersions = (var_counts - mean_counts) / (mean_counts ** 2)\n", + " dispersions = dispersions.clamp(min=1e-10) # Ensure non-negative dispersions\n", + " return mean_counts, dispersions\n", + "\n", + "def negative_binomial_log_likelihood(mean: Tensor, dispersion: Tensor, y: Tensor) -> Tensor:\n", + " \"\"\"\n", + " Negative binomial log-likelihood function.\n", + " \n", + " Parameters:\n", + " params (Tensor): Parameters of the negative binomial (mean, dispersion).\n", + " y (Tensor): Observed counts.\n", + " \n", + " Returns:\n", + " Tensor: Negative log-likelihood.\n", + " \"\"\"\n", + " log_likelihood = \n", + " return -likelihood.sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# mean_counts, dispersions = fit_negative_binomial_scipy(data.X.toarray())" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\experimental\\pp\\_normalization.py:132: UserWarning: Received a view of an AnnData. Making a copy.\n", + " view_to_actual(adata)\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\experimental\\pp\\_normalization.py:52: UserWarning: `normalize_pearson_residuals()` expects raw count data, but non-integers were found.\n", + " warn(\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\experimental\\pp\\_normalization.py:68: RuntimeWarning: invalid value encountered in divide\n", + " residuals = diff / np.sqrt(mu + mu**2 / theta)\n" + ] + } + ], + "source": [ + "import scanpy as sc\n", + "\n", + "sc.experimental.pp.normalize_pearson_residuals(data[0, 7:30])\n", + "# data[0, 7:30].X.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GEX_n_genes_by_countsGEX_pct_counts_mtGEX_size_factorsGEX_phaseADT_n_antibodies_by_countsADT_total_countsADT_iso_countcell_typebatchADT_pseudotime_orderGEX_pseudotime_orderSamplenameSiteDonorNumberModalityVendorLotDonorIDDonorAgeDonorBMIDonorBloodTypeDonorRaceEthnicityDonorGenderQCMedsDonorSmokeris_train
GCATTAGCATAAGCGG-1-s1d18936.7239790.356535G11152828.05.0Naive CD20+ B IGKC+s1d1NaNNaNsite1_donor1_citesite1donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrain
TACAGGTGTTAGAGTA-1-s1d126068.0088291.292643S1378819.021.0CD14+ Monos1d1NaNNaNsite1_donor1_citesite1donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrain
AGGATCTAGGTCTACT-1-s1d118676.9597070.970558G2M1164088.012.0Naive CD20+ B IGKC+s1d1NaNNaNsite1_donor1_citesite1donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrain
GTAGAAAGTGACACAG-1-s1d123606.1092341.232604G2M1244447.09.0HSCs1d1NaN0.000000site1_donor1_citesite1donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrain
TCCGAAAAGGATCATA-1-s1d14550.2943940.044585S13212875.024.0Reticulocytes1d10.7352610.964631site1_donor1_citesite1donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrain
.................................................................................
TCCACGTCATGGTGGA-1-s4d917534.0570520.642727G2M1283850.012.0CD4+ T activateds4d9NaNNaNsite4_donor9_citesite4donor9cite3061608132723531.0O+Other RaceHISPANIC OR LATINOMaleFalseNonsmokeriid_holdout
ATCACAGAGATTACCC-1-s4d914306.8422410.460635G2M1363456.019.0Naive CD20+ B IGKC+s4d9NaNNaNsite4_donor9_citesite4donor9cite3061608132723531.0O+Other RaceHISPANIC OR LATINOMaleFalseNonsmokeriid_holdout
ATCATTCGTGATCGTT-1-s4d912086.2116370.388865G2M1221984.010.0CD4+ T naives4d9NaNNaNsite4_donor9_citesite4donor9cite3061608132723531.0O+Other RaceHISPANIC OR LATINOMaleFalseNonsmokeriid_holdout
TTCCACGGTTGAGGAC-1-s4d943906.1541912.899356S1303242.013.0NKs4d9NaNNaNsite4_donor9_citesite4donor9cite3061608132723531.0O+Other RaceHISPANIC OR LATINOMaleFalseNonsmokeriid_holdout
GAATCACCACGGAAGT-1-s4d921154.3673010.916475G2M1233283.010.0Lymph progs4d9NaNNaNsite4_donor9_citesite4donor9cite3061608132723531.0O+Other RaceHISPANIC OR LATINOMaleFalseNonsmokeriid_holdout
\n", + "

75195 rows × 26 columns

\n", + "
" + ], + "text/plain": [ + " GEX_n_genes_by_counts GEX_pct_counts_mt \\\n", + "GCATTAGCATAAGCGG-1-s1d1 893 6.723979 \n", + "TACAGGTGTTAGAGTA-1-s1d1 2606 8.008829 \n", + "AGGATCTAGGTCTACT-1-s1d1 1867 6.959707 \n", + "GTAGAAAGTGACACAG-1-s1d1 2360 6.109234 \n", + "TCCGAAAAGGATCATA-1-s1d1 455 0.294394 \n", + "... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 1753 4.057052 \n", + "ATCACAGAGATTACCC-1-s4d9 1430 6.842241 \n", + "ATCATTCGTGATCGTT-1-s4d9 1208 6.211637 \n", + "TTCCACGGTTGAGGAC-1-s4d9 4390 6.154191 \n", + "GAATCACCACGGAAGT-1-s4d9 2115 4.367301 \n", + "\n", + " GEX_size_factors GEX_phase \\\n", + "GCATTAGCATAAGCGG-1-s1d1 0.356535 G1 \n", + "TACAGGTGTTAGAGTA-1-s1d1 1.292643 S \n", + "AGGATCTAGGTCTACT-1-s1d1 0.970558 G2M \n", + "GTAGAAAGTGACACAG-1-s1d1 1.232604 G2M \n", + "TCCGAAAAGGATCATA-1-s1d1 0.044585 S \n", + "... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 0.642727 G2M \n", + "ATCACAGAGATTACCC-1-s4d9 0.460635 G2M \n", + "ATCATTCGTGATCGTT-1-s4d9 0.388865 G2M \n", + "TTCCACGGTTGAGGAC-1-s4d9 2.899356 S \n", + "GAATCACCACGGAAGT-1-s4d9 0.916475 G2M \n", + "\n", + " ADT_n_antibodies_by_counts ADT_total_counts \\\n", + "GCATTAGCATAAGCGG-1-s1d1 115 2828.0 \n", + "TACAGGTGTTAGAGTA-1-s1d1 137 8819.0 \n", + "AGGATCTAGGTCTACT-1-s1d1 116 4088.0 \n", + "GTAGAAAGTGACACAG-1-s1d1 124 4447.0 \n", + "TCCGAAAAGGATCATA-1-s1d1 132 12875.0 \n", + "... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 128 3850.0 \n", + "ATCACAGAGATTACCC-1-s4d9 136 3456.0 \n", + "ATCATTCGTGATCGTT-1-s4d9 122 1984.0 \n", + "TTCCACGGTTGAGGAC-1-s4d9 130 3242.0 \n", + "GAATCACCACGGAAGT-1-s4d9 123 3283.0 \n", + "\n", + " ADT_iso_count cell_type batch \\\n", + "GCATTAGCATAAGCGG-1-s1d1 5.0 Naive CD20+ B IGKC+ s1d1 \n", + "TACAGGTGTTAGAGTA-1-s1d1 21.0 CD14+ Mono s1d1 \n", + "AGGATCTAGGTCTACT-1-s1d1 12.0 Naive CD20+ B IGKC+ s1d1 \n", + "GTAGAAAGTGACACAG-1-s1d1 9.0 HSC s1d1 \n", + "TCCGAAAAGGATCATA-1-s1d1 24.0 Reticulocyte s1d1 \n", + "... ... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 12.0 CD4+ T activated s4d9 \n", + "ATCACAGAGATTACCC-1-s4d9 19.0 Naive CD20+ B IGKC+ s4d9 \n", + "ATCATTCGTGATCGTT-1-s4d9 10.0 CD4+ T naive s4d9 \n", + "TTCCACGGTTGAGGAC-1-s4d9 13.0 NK s4d9 \n", + "GAATCACCACGGAAGT-1-s4d9 10.0 Lymph prog s4d9 \n", + "\n", + " ADT_pseudotime_order GEX_pseudotime_order \\\n", + "GCATTAGCATAAGCGG-1-s1d1 NaN NaN \n", + "TACAGGTGTTAGAGTA-1-s1d1 NaN NaN \n", + "AGGATCTAGGTCTACT-1-s1d1 NaN NaN \n", + "GTAGAAAGTGACACAG-1-s1d1 NaN 0.000000 \n", + "TCCGAAAAGGATCATA-1-s1d1 0.735261 0.964631 \n", + "... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 NaN NaN \n", + "ATCACAGAGATTACCC-1-s4d9 NaN NaN \n", + "ATCATTCGTGATCGTT-1-s4d9 NaN NaN \n", + "TTCCACGGTTGAGGAC-1-s4d9 NaN NaN \n", + "GAATCACCACGGAAGT-1-s4d9 NaN NaN \n", + "\n", + " Samplename Site DonorNumber Modality \\\n", + "GCATTAGCATAAGCGG-1-s1d1 site1_donor1_cite site1 donor1 cite \n", + "TACAGGTGTTAGAGTA-1-s1d1 site1_donor1_cite site1 donor1 cite \n", + "AGGATCTAGGTCTACT-1-s1d1 site1_donor1_cite site1 donor1 cite \n", + "GTAGAAAGTGACACAG-1-s1d1 site1_donor1_cite site1 donor1 cite \n", + "TCCGAAAAGGATCATA-1-s1d1 site1_donor1_cite site1 donor1 cite \n", + "... ... ... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 site4_donor9_cite site4 donor9 cite \n", + "ATCACAGAGATTACCC-1-s4d9 site4_donor9_cite site4 donor9 cite \n", + "ATCATTCGTGATCGTT-1-s4d9 site4_donor9_cite site4 donor9 cite \n", + "TTCCACGGTTGAGGAC-1-s4d9 site4_donor9_cite site4 donor9 cite \n", + "GAATCACCACGGAAGT-1-s4d9 site4_donor9_cite site4 donor9 cite \n", + "\n", + " VendorLot DonorID DonorAge DonorBMI \\\n", + "GCATTAGCATAAGCGG-1-s1d1 3054455 15078 34 24.8 \n", + "TACAGGTGTTAGAGTA-1-s1d1 3054455 15078 34 24.8 \n", + "AGGATCTAGGTCTACT-1-s1d1 3054455 15078 34 24.8 \n", + "GTAGAAAGTGACACAG-1-s1d1 3054455 15078 34 24.8 \n", + "TCCGAAAAGGATCATA-1-s1d1 3054455 15078 34 24.8 \n", + "... ... ... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 3061608 13272 35 31.0 \n", + "ATCACAGAGATTACCC-1-s4d9 3061608 13272 35 31.0 \n", + "ATCATTCGTGATCGTT-1-s4d9 3061608 13272 35 31.0 \n", + "TTCCACGGTTGAGGAC-1-s4d9 3061608 13272 35 31.0 \n", + "GAATCACCACGGAAGT-1-s4d9 3061608 13272 35 31.0 \n", + "\n", + " DonorBloodType DonorRace Ethnicity \\\n", + "GCATTAGCATAAGCGG-1-s1d1 B- White HISPANIC OR LATINO \n", + "TACAGGTGTTAGAGTA-1-s1d1 B- White HISPANIC OR LATINO \n", + "AGGATCTAGGTCTACT-1-s1d1 B- White HISPANIC OR LATINO \n", + "GTAGAAAGTGACACAG-1-s1d1 B- White HISPANIC OR LATINO \n", + "TCCGAAAAGGATCATA-1-s1d1 B- White HISPANIC OR LATINO \n", + "... ... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 O+ Other Race HISPANIC OR LATINO \n", + "ATCACAGAGATTACCC-1-s4d9 O+ Other Race HISPANIC OR LATINO \n", + "ATCATTCGTGATCGTT-1-s4d9 O+ Other Race HISPANIC OR LATINO \n", + "TTCCACGGTTGAGGAC-1-s4d9 O+ Other Race HISPANIC OR LATINO \n", + "GAATCACCACGGAAGT-1-s4d9 O+ Other Race HISPANIC OR LATINO \n", + "\n", + " DonorGender QCMeds DonorSmoker is_train \n", + "GCATTAGCATAAGCGG-1-s1d1 Male False Nonsmoker train \n", + "TACAGGTGTTAGAGTA-1-s1d1 Male False Nonsmoker train \n", + "AGGATCTAGGTCTACT-1-s1d1 Male False Nonsmoker train \n", + "GTAGAAAGTGACACAG-1-s1d1 Male False Nonsmoker train \n", + "TCCGAAAAGGATCATA-1-s1d1 Male False Nonsmoker train \n", + "... ... ... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 Male False Nonsmoker iid_holdout \n", + "ATCACAGAGATTACCC-1-s4d9 Male False Nonsmoker iid_holdout \n", + "ATCATTCGTGATCGTT-1-s4d9 Male False Nonsmoker iid_holdout \n", + "TTCCACGGTTGAGGAC-1-s4d9 Male False Nonsmoker iid_holdout \n", + "GAATCACCACGGAAGT-1-s4d9 Male False Nonsmoker iid_holdout \n", + "\n", + "[75195 rows x 26 columns]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.obs" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(feature_types\n", + " GEX 13953\n", + " ADT 134\n", + " Name: count, dtype: int64,\n", + " 14087)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.var[\"feature_types\"].value_counts(), len(data.var)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(75195, 75195)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(data.obs_names.values), len(np.unique(data.obs_names.values))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.obs_names.isin(data.obs_names.values[:10]).sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "View of AnnData object with n_obs × n_vars = 10 × 14087\n", + " obs: 'GEX_n_genes_by_counts', 'GEX_pct_counts_mt', 'GEX_size_factors', 'GEX_phase', 'ADT_n_antibodies_by_counts', 'ADT_total_counts', 'ADT_iso_count', 'cell_type', 'batch', 'ADT_pseudotime_order', 'GEX_pseudotime_order', 'Samplename', 'Site', 'DonorNumber', 'Modality', 'VendorLot', 'DonorID', 'DonorAge', 'DonorBMI', 'DonorBloodType', 'DonorRace', 'Ethnicity', 'DonorGender', 'QCMeds', 'DonorSmoker', 'is_train'\n", + " var: 'feature_types', 'gene_id'\n", + " uns: 'dataset_id', 'genome', 'organism'\n", + " obsm: 'ADT_X_pca', 'ADT_X_umap', 'ADT_isotype_controls', 'GEX_X_pca', 'GEX_X_umap'\n", + " layers: 'counts'" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data[data.obs_names[:10]]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GEX_n_genes_by_countsGEX_pct_counts_mtGEX_size_factorsGEX_phaseADT_n_antibodies_by_countsADT_total_countsADT_iso_countcell_typebatchADT_pseudotime_orderGEX_pseudotime_orderSamplenameSiteDonorNumberModalityVendorLotDonorIDDonorAgeDonorBMIDonorBloodTypeDonorRaceEthnicityDonorGenderQCMedsDonorSmokeris_train
GCATTAGCATAAGCGG-1-s1d18936.7239790.356535G11152828.05.0Naive CD20+ B IGKC+s1d1NaNNaNsite1_donor1_citesite1donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrain
TACAGGTGTTAGAGTA-1-s1d126068.0088291.292643S1378819.021.0CD14+ Monos1d1NaNNaNsite1_donor1_citesite1donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrain
AGGATCTAGGTCTACT-1-s1d118676.9597070.970558G2M1164088.012.0Naive CD20+ B IGKC+s1d1NaNNaNsite1_donor1_citesite1donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrain
GTAGAAAGTGACACAG-1-s1d123606.1092341.232604G2M1244447.09.0HSCs1d1NaN0.000000site1_donor1_citesite1donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrain
TCCGAAAAGGATCATA-1-s1d14550.2943940.044585S13212875.024.0Reticulocytes1d10.7352610.964631site1_donor1_citesite1donor1cite3054455150783424.8B-WhiteHISPANIC OR LATINOMaleFalseNonsmokertrain
.................................................................................
TCCACGTCATGGTGGA-1-s4d917534.0570520.642727G2M1283850.012.0CD4+ T activateds4d9NaNNaNsite4_donor9_citesite4donor9cite3061608132723531.0O+Other RaceHISPANIC OR LATINOMaleFalseNonsmokeriid_holdout
ATCACAGAGATTACCC-1-s4d914306.8422410.460635G2M1363456.019.0Naive CD20+ B IGKC+s4d9NaNNaNsite4_donor9_citesite4donor9cite3061608132723531.0O+Other RaceHISPANIC OR LATINOMaleFalseNonsmokeriid_holdout
ATCATTCGTGATCGTT-1-s4d912086.2116370.388865G2M1221984.010.0CD4+ T naives4d9NaNNaNsite4_donor9_citesite4donor9cite3061608132723531.0O+Other RaceHISPANIC OR LATINOMaleFalseNonsmokeriid_holdout
TTCCACGGTTGAGGAC-1-s4d943906.1541912.899356S1303242.013.0NKs4d9NaNNaNsite4_donor9_citesite4donor9cite3061608132723531.0O+Other RaceHISPANIC OR LATINOMaleFalseNonsmokeriid_holdout
GAATCACCACGGAAGT-1-s4d921154.3673010.916475G2M1233283.010.0Lymph progs4d9NaNNaNsite4_donor9_citesite4donor9cite3061608132723531.0O+Other RaceHISPANIC OR LATINOMaleFalseNonsmokeriid_holdout
\n", + "

75195 rows × 26 columns

\n", + "
" + ], + "text/plain": [ + " GEX_n_genes_by_counts GEX_pct_counts_mt \\\n", + "GCATTAGCATAAGCGG-1-s1d1 893 6.723979 \n", + "TACAGGTGTTAGAGTA-1-s1d1 2606 8.008829 \n", + "AGGATCTAGGTCTACT-1-s1d1 1867 6.959707 \n", + "GTAGAAAGTGACACAG-1-s1d1 2360 6.109234 \n", + "TCCGAAAAGGATCATA-1-s1d1 455 0.294394 \n", + "... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 1753 4.057052 \n", + "ATCACAGAGATTACCC-1-s4d9 1430 6.842241 \n", + "ATCATTCGTGATCGTT-1-s4d9 1208 6.211637 \n", + "TTCCACGGTTGAGGAC-1-s4d9 4390 6.154191 \n", + "GAATCACCACGGAAGT-1-s4d9 2115 4.367301 \n", + "\n", + " GEX_size_factors GEX_phase \\\n", + "GCATTAGCATAAGCGG-1-s1d1 0.356535 G1 \n", + "TACAGGTGTTAGAGTA-1-s1d1 1.292643 S \n", + "AGGATCTAGGTCTACT-1-s1d1 0.970558 G2M \n", + "GTAGAAAGTGACACAG-1-s1d1 1.232604 G2M \n", + "TCCGAAAAGGATCATA-1-s1d1 0.044585 S \n", + "... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 0.642727 G2M \n", + "ATCACAGAGATTACCC-1-s4d9 0.460635 G2M \n", + "ATCATTCGTGATCGTT-1-s4d9 0.388865 G2M \n", + "TTCCACGGTTGAGGAC-1-s4d9 2.899356 S \n", + "GAATCACCACGGAAGT-1-s4d9 0.916475 G2M \n", + "\n", + " ADT_n_antibodies_by_counts ADT_total_counts \\\n", + "GCATTAGCATAAGCGG-1-s1d1 115 2828.0 \n", + "TACAGGTGTTAGAGTA-1-s1d1 137 8819.0 \n", + "AGGATCTAGGTCTACT-1-s1d1 116 4088.0 \n", + "GTAGAAAGTGACACAG-1-s1d1 124 4447.0 \n", + "TCCGAAAAGGATCATA-1-s1d1 132 12875.0 \n", + "... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 128 3850.0 \n", + "ATCACAGAGATTACCC-1-s4d9 136 3456.0 \n", + "ATCATTCGTGATCGTT-1-s4d9 122 1984.0 \n", + "TTCCACGGTTGAGGAC-1-s4d9 130 3242.0 \n", + "GAATCACCACGGAAGT-1-s4d9 123 3283.0 \n", + "\n", + " ADT_iso_count cell_type batch \\\n", + "GCATTAGCATAAGCGG-1-s1d1 5.0 Naive CD20+ B IGKC+ s1d1 \n", + "TACAGGTGTTAGAGTA-1-s1d1 21.0 CD14+ Mono s1d1 \n", + "AGGATCTAGGTCTACT-1-s1d1 12.0 Naive CD20+ B IGKC+ s1d1 \n", + "GTAGAAAGTGACACAG-1-s1d1 9.0 HSC s1d1 \n", + "TCCGAAAAGGATCATA-1-s1d1 24.0 Reticulocyte s1d1 \n", + "... ... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 12.0 CD4+ T activated s4d9 \n", + "ATCACAGAGATTACCC-1-s4d9 19.0 Naive CD20+ B IGKC+ s4d9 \n", + "ATCATTCGTGATCGTT-1-s4d9 10.0 CD4+ T naive s4d9 \n", + "TTCCACGGTTGAGGAC-1-s4d9 13.0 NK s4d9 \n", + "GAATCACCACGGAAGT-1-s4d9 10.0 Lymph prog s4d9 \n", + "\n", + " ADT_pseudotime_order GEX_pseudotime_order \\\n", + "GCATTAGCATAAGCGG-1-s1d1 NaN NaN \n", + "TACAGGTGTTAGAGTA-1-s1d1 NaN NaN \n", + "AGGATCTAGGTCTACT-1-s1d1 NaN NaN \n", + "GTAGAAAGTGACACAG-1-s1d1 NaN 0.000000 \n", + "TCCGAAAAGGATCATA-1-s1d1 0.735261 0.964631 \n", + "... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 NaN NaN \n", + "ATCACAGAGATTACCC-1-s4d9 NaN NaN \n", + "ATCATTCGTGATCGTT-1-s4d9 NaN NaN \n", + "TTCCACGGTTGAGGAC-1-s4d9 NaN NaN \n", + "GAATCACCACGGAAGT-1-s4d9 NaN NaN \n", + "\n", + " Samplename Site DonorNumber Modality \\\n", + "GCATTAGCATAAGCGG-1-s1d1 site1_donor1_cite site1 donor1 cite \n", + "TACAGGTGTTAGAGTA-1-s1d1 site1_donor1_cite site1 donor1 cite \n", + "AGGATCTAGGTCTACT-1-s1d1 site1_donor1_cite site1 donor1 cite \n", + "GTAGAAAGTGACACAG-1-s1d1 site1_donor1_cite site1 donor1 cite \n", + "TCCGAAAAGGATCATA-1-s1d1 site1_donor1_cite site1 donor1 cite \n", + "... ... ... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 site4_donor9_cite site4 donor9 cite \n", + "ATCACAGAGATTACCC-1-s4d9 site4_donor9_cite site4 donor9 cite \n", + "ATCATTCGTGATCGTT-1-s4d9 site4_donor9_cite site4 donor9 cite \n", + "TTCCACGGTTGAGGAC-1-s4d9 site4_donor9_cite site4 donor9 cite \n", + "GAATCACCACGGAAGT-1-s4d9 site4_donor9_cite site4 donor9 cite \n", + "\n", + " VendorLot DonorID DonorAge DonorBMI \\\n", + "GCATTAGCATAAGCGG-1-s1d1 3054455 15078 34 24.8 \n", + "TACAGGTGTTAGAGTA-1-s1d1 3054455 15078 34 24.8 \n", + "AGGATCTAGGTCTACT-1-s1d1 3054455 15078 34 24.8 \n", + "GTAGAAAGTGACACAG-1-s1d1 3054455 15078 34 24.8 \n", + "TCCGAAAAGGATCATA-1-s1d1 3054455 15078 34 24.8 \n", + "... ... ... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 3061608 13272 35 31.0 \n", + "ATCACAGAGATTACCC-1-s4d9 3061608 13272 35 31.0 \n", + "ATCATTCGTGATCGTT-1-s4d9 3061608 13272 35 31.0 \n", + "TTCCACGGTTGAGGAC-1-s4d9 3061608 13272 35 31.0 \n", + "GAATCACCACGGAAGT-1-s4d9 3061608 13272 35 31.0 \n", + "\n", + " DonorBloodType DonorRace Ethnicity \\\n", + "GCATTAGCATAAGCGG-1-s1d1 B- White HISPANIC OR LATINO \n", + "TACAGGTGTTAGAGTA-1-s1d1 B- White HISPANIC OR LATINO \n", + "AGGATCTAGGTCTACT-1-s1d1 B- White HISPANIC OR LATINO \n", + "GTAGAAAGTGACACAG-1-s1d1 B- White HISPANIC OR LATINO \n", + "TCCGAAAAGGATCATA-1-s1d1 B- White HISPANIC OR LATINO \n", + "... ... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 O+ Other Race HISPANIC OR LATINO \n", + "ATCACAGAGATTACCC-1-s4d9 O+ Other Race HISPANIC OR LATINO \n", + "ATCATTCGTGATCGTT-1-s4d9 O+ Other Race HISPANIC OR LATINO \n", + "TTCCACGGTTGAGGAC-1-s4d9 O+ Other Race HISPANIC OR LATINO \n", + "GAATCACCACGGAAGT-1-s4d9 O+ Other Race HISPANIC OR LATINO \n", + "\n", + " DonorGender QCMeds DonorSmoker is_train \n", + "GCATTAGCATAAGCGG-1-s1d1 Male False Nonsmoker train \n", + "TACAGGTGTTAGAGTA-1-s1d1 Male False Nonsmoker train \n", + "AGGATCTAGGTCTACT-1-s1d1 Male False Nonsmoker train \n", + "GTAGAAAGTGACACAG-1-s1d1 Male False Nonsmoker train \n", + "TCCGAAAAGGATCATA-1-s1d1 Male False Nonsmoker train \n", + "... ... ... ... ... \n", + "TCCACGTCATGGTGGA-1-s4d9 Male False Nonsmoker iid_holdout \n", + "ATCACAGAGATTACCC-1-s4d9 Male False Nonsmoker iid_holdout \n", + "ATCATTCGTGATCGTT-1-s4d9 Male False Nonsmoker iid_holdout \n", + "TTCCACGGTTGAGGAC-1-s4d9 Male False Nonsmoker iid_holdout \n", + "GAATCACCACGGAAGT-1-s4d9 Male False Nonsmoker iid_holdout \n", + "\n", + "[75195 rows x 26 columns]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.obs" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "View of AnnData object with n_obs × n_vars = 75195 × 14087\n", + " obs: 'GEX_n_genes_by_counts', 'GEX_pct_counts_mt', 'GEX_size_factors', 'GEX_phase', 'ADT_n_antibodies_by_counts', 'ADT_total_counts', 'ADT_iso_count', 'cell_type', 'batch', 'ADT_pseudotime_order', 'GEX_pseudotime_order', 'Samplename', 'Site', 'DonorNumber', 'Modality', 'VendorLot', 'DonorID', 'DonorAge', 'DonorBMI', 'DonorBloodType', 'DonorRace', 'Ethnicity', 'DonorGender', 'QCMeds', 'DonorSmoker', 'is_train'\n", + " var: 'feature_types', 'gene_id'\n", + " uns: 'dataset_id', 'genome', 'organism'\n", + " obsm: 'ADT_X_pca', 'ADT_X_umap', 'ADT_isotype_controls', 'GEX_X_pca', 'GEX_X_umap'\n", + " layers: 'counts'" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['GEX_n_genes_by_counts', 'GEX_pct_counts_mt', 'GEX_size_factors',\n", + " 'GEX_phase', 'ADT_n_antibodies_by_counts', 'ADT_total_counts',\n", + " 'ADT_iso_count', 'cell_type', 'batch', 'ADT_pseudotime_order',\n", + " 'GEX_pseudotime_order', 'Samplename', 'Site', 'DonorNumber', 'Modality',\n", + " 'VendorLot', 'DonorID', 'DonorAge', 'DonorBMI', 'DonorBloodType',\n", + " 'DonorRace', 'Ethnicity', 'DonorGender', 'QCMeds', 'DonorSmoker',\n", + " 'is_train'],\n", + " dtype='object')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.obs.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Modality\n", + "cite 75195\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.obs[\"Modality\"].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "CategoricalIndex(['CD14+ Mono', 'CD4+ T activated', 'CD4+ T naive', 'NK',\n", + " 'Reticulocyte', 'Erythroblast', 'Naive CD20+ B IGKC+',\n", + " 'CD8+ T naive', 'CD16+ Mono', 'NK CD158e1+', 'pDC',\n", + " 'G/M prog', 'cDC2', 'Naive CD20+ B IGKC-', 'HSC',\n", + " 'Normoblast', 'Lymph prog', 'Transitional B',\n", + " 'CD8+ T TIGIT+ CD45RO+', 'CD8+ T CD57+ CD45RA+',\n", + " 'Proerythroblast', 'CD8+ T TIGIT+ CD45RA+',\n", + " 'CD4+ T activated integrinB7+', 'CD8+ T CD49f+',\n", + " 'B1 B IGKC+', 'CD8+ T CD69+ CD45RO+', 'CD8+ T CD57+ CD45RO+',\n", + " 'CD8+ T CD69+ CD45RA+', 'MAIT', 'MK/E prog', 'B1 B IGKC-',\n", + " 'T reg', 'ILC1', 'gdT CD158b+', 'Plasma cell IGKC+',\n", + " 'Plasma cell IGKC-', 'Plasmablast IGKC+', 'gdT TCRVD2+',\n", + " 'ILC', 'Plasmablast IGKC-', 'CD4+ T CD314+ CD45RA+', 'dnT',\n", + " 'CD8+ T naive CD127+ CD26- CD101-', 'T prog cycling',\n", + " 'cDC1'],\n", + " categories=['B1 B IGKC+', 'B1 B IGKC-', 'CD4+ T CD314+ CD45RA+', 'CD4+ T activated', ..., 'dnT', 'gdT CD158b+', 'gdT TCRVD2+', 'pDC'], ordered=False, dtype='category', name='cell_type')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.obs[\"cell_type\"].value_counts().keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "aggregation_mapping = {\n", + " \"CD14+ Mono\": \"Monocytes\",\n", + " \"CD16+ Mono\": \"Monocytes\",\n", + " \"CD4+ T activated\": \"T Cells\",\n", + " \"CD4+ T naive\": \"T Cells\",\n", + " \"CD8+ T naive\": \"T Cells\",\n", + " \"CD8+ T CD57+ CD45RO+\": \"T Cells\",\n", + " \"CD8+ T CD57+ CD45RA+\": \"T Cells\",\n", + " \"CD8+ T TIGIT+ CD45RO+\": \"T Cells\",\n", + " \"CD8+ T TIGIT+ CD45RA+\": \"T Cells\",\n", + " \"CD8+ T CD49f+\": \"T Cells\",\n", + " \"CD8+ T CD69+ CD45RO+\": \"T Cells\",\n", + " \"CD8+ T CD69+ CD45RA+\": \"T Cells\",\n", + " \"CD8+ T naive CD127+ CD26- CD101-\": \"T Cells\",\n", + " \"CD4+ T activated integrinB7+\": \"T Cells\",\n", + " \"CD4+ T CD314+ CD45RA+\": \"T Cells\",\n", + " \"MAIT\": \"T Cells\",\n", + " \"gdT CD158b+\": \"T Cells\",\n", + " \"gdT TCRVD2+\": \"T Cells\",\n", + " \"dnT\": \"T Cells\",\n", + " \"T reg\": \"T Cells\",\n", + " \"T prog cycling\": \"T Cells\",\n", + " \"Naive CD20+ B IGKC+\": \"B Cells\",\n", + " \"Naive CD20+ B IGKC-\": \"B Cells\",\n", + " \"Transitional B\": \"B Cells\",\n", + " \"B1 B IGKC+\": \"B Cells\",\n", + " \"B1 B IGKC-\": \"B Cells\",\n", + " \"Plasma cell IGKC+\": \"Plasma Cells\",\n", + " \"Plasma cell IGKC-\": \"Plasma Cells\",\n", + " \"Plasmablast IGKC+\": \"Plasma Cells\",\n", + " \"Plasmablast IGKC-\": \"Plasma Cells\",\n", + " \"NK\": \"NK Cells\",\n", + " \"NK CD158e1+\": \"NK Cells\",\n", + " \"cDC1\": \"Dendritic Cells\",\n", + " \"cDC2\": \"Dendritic Cells\",\n", + " \"pDC\": \"Dendritic Cells\",\n", + " \"HSC\": \"Progenitors and Stem Cells\",\n", + " \"Lymph prog\": \"Progenitors and Stem Cells\",\n", + " \"G/M prog\": \"Progenitors and Stem Cells\",\n", + " \"MK/E prog\": \"Progenitors and Stem Cells\",\n", + " \"Reticulocyte\": \"Erythroid Lineage\",\n", + " \"Erythroblast\": \"Erythroid Lineage\",\n", + " \"Proerythroblast\": \"Erythroid Lineage\",\n", + " \"Normoblast\": \"Erythroid Lineage\",\n", + " \"ILC\": \"Innate Lymphoid Cells\",\n", + " \"ILC1\": \"Innate Lymphoid Cells\",\n", + " # Add any other categories and mappings here\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "cell_type\n", + "Monocytes 23011\n", + "T Cells 20707\n", + "Erythroid Lineage 9921\n", + "B Cells 6397\n", + "NK Cells 6064\n", + "Progenitors and Stem Cells 4518\n", + "Dendritic Cells 3215\n", + "Plasma Cells 802\n", + "Innate Lymphoid Cells 560\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.obs[\"cell_type\"].map(aggregation_mapping).value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
feature_typesgene_id
AL627309.5GEXENSG00000241860
LINC01409GEXENSG00000237491
LINC01128GEXENSG00000228794
LINC00115GEXENSG00000225880
FAM41CGEXENSG00000230368
.........
HLA-EADTENSG00000204592
CD82ADTENSG00000085117
CD101ADTENSG00000134256
CD88ADTNaN
CD224ADTNaN
\n", + "

14087 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " feature_types gene_id\n", + "AL627309.5 GEX ENSG00000241860\n", + "LINC01409 GEX ENSG00000237491\n", + "LINC01128 GEX ENSG00000228794\n", + "LINC00115 GEX ENSG00000225880\n", + "FAM41C GEX ENSG00000230368\n", + "... ... ...\n", + "HLA-E ADT ENSG00000204592\n", + "CD82 ADT ENSG00000085117\n", + "CD101 ADT ENSG00000134256\n", + "CD88 ADT NaN\n", + "CD224 ADT NaN\n", + "\n", + "[14087 rows x 2 columns]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.var" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "dense_data = data.layers[\"counts\"].toarray()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ True, True, True, ..., False, False, False])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(data.var[\"feature_types\"] == \"GEX\").values" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(75195, 14087)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dense_data.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Layers" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "gex_indicator = (data.var[\"feature_types\"] == \"GEX\").values" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "expressions = data.layers[\"counts\"].toarray()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(75195, 64) (75195, 64)\n" + ] + } + ], + "source": [ + "gex_expressions = pd.DataFrame(\n", + " data=expressions[:, gex_indicator][:, :64],\n", + " columns=data.var.index[gex_indicator][:64],\n", + " index=data.obs.index,\n", + ")\n", + "adt_expressions = pd.DataFrame(\n", + " data=expressions[:, ~gex_indicator][:, :64],\n", + " columns=data.var.index[~gex_indicator][:64],\n", + " index=data.obs.index,\n", + ")\n", + "print(gex_expressions.shape, adt_expressions.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "from pandas import DataFrame\n", + "from typing import List, Optional, Tuple\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.ticker import FormatStrFormatter\n", + "\n", + "\n", + "def make_histograms(\n", + " df: DataFrame,\n", + " quant_vars: List[str],\n", + " title: str,\n", + " subplots_shape: Optional[Tuple] = None,\n", + " display_desc: bool = False,\n", + " title_shift: float = 1,\n", + " bins: int = 100,\n", + " y_label: str = \"PDF estimation\",\n", + ") -> None:\n", + " r\"\"\"\n", + " Plot histograms of the given quantitative variables in the dataframe.\n", + " \"\"\"\n", + "\n", + " if subplots_shape is not None:\n", + " num_rows, num_cols = subplots_shape\n", + " else:\n", + " num_plots = len(quant_vars)\n", + " num_rows = (num_plots + 1) // 2\n", + " num_cols = 2\n", + " fig, axes = plt.subplots(num_rows, num_cols, figsize=(5 * num_cols, 2 * num_rows))\n", + " axes = np.atleast_2d(axes)\n", + " plt.subplots_adjust(wspace=0.3, hspace=0.5)\n", + "\n", + " if display_desc:\n", + " fig.suptitle(title, fontsize=16, y=title_shift)\n", + "\n", + " for i, var in enumerate(quant_vars):\n", + " row = i // num_cols\n", + " col = i % num_cols\n", + " ax = axes[row, col]\n", + " ax.hist(df[var], bins=bins, color=\"grey\", edgecolor=\"black\", density=False)\n", + " ax.set_xlabel(var)\n", + " ax.set_ylabel(y_label, fontsize=7)\n", + " ax.yaxis.set_major_formatter(FormatStrFormatter(\"%.2f\"))\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AL627309.5LINC01409LINC01128LINC00115FAM41CNOC2LKLHL17HES4ISG15AGRNC1orf159TNFRSF18TNFRSF4SDF4B3GALT6C1QTNF12UBE2J2SCNN1DACAP3PUSL1INTS11CPTPDVL1AURKAIP1CCNL2MRPL20-AS1MRPL20ATAD3CATAD3BATAD3ASSU72AL645728.1FNDC10AL691432.2MIB2MMP23BCDK11BFO704657.1SLC35E2BCDK11ASLC35E2ANADKGNB1PRKCZAL590822.2FAAP20SKIMORN1RER1PEX10PLCH2PANK4AL139246.5TNFRSF14-AS1TNFRSF14AL139246.3PRXL2BTTC34MEGF6TPRG1LWRAP73SMIM1LRRC47CEP104
count75195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.000000
mean0.0105060.0385400.0617460.0078330.0106120.1158990.0055850.0413060.5409000.0039760.0145360.0297360.0393780.2281270.0543790.0024600.1775250.0029390.0500300.0420110.1193700.0316780.0222220.5949600.1586010.0372900.6679830.0052530.0323560.0461070.4380340.0383270.0179930.0151470.0998070.0159190.1138910.0027260.0437530.1562870.0276610.1682160.4803380.0153200.0035110.2544580.0688480.0083780.3814880.0264910.0064230.0225010.0521050.0148020.2776120.0041630.0242840.0053460.0142430.0662010.0592730.3280540.0788620.060257
std0.1040260.2053980.2784070.0905390.1042700.3703750.0755910.3487521.6627950.0650120.1242640.2120000.2674950.5282750.2447590.0506030.4650910.0548650.2355430.2127130.3695770.1809670.1535921.0967180.4301420.1990561.2163220.0764020.1896420.2534220.7910050.2080750.1430470.1264200.3453850.1356650.3645060.0555990.2177720.4283880.1739960.4680280.8862300.1267670.0598200.5712890.2789860.0947260.7667120.1689060.0844210.1539410.2578620.1265660.5909330.0670150.1653420.0747230.1281960.2681910.2520451.5749470.3024920.259100
min0.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.000000
25%0.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.000000
50%0.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.000000
75%0.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000001.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000001.0000000.0000000.0000001.0000000.0000000.0000000.0000001.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000001.0000000.0000000.0000000.0000000.0000000.0000001.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.000000
max3.0000003.0000004.0000003.0000002.0000007.0000003.00000019.000000110.0000002.0000003.0000008.0000008.0000006.0000004.0000002.0000009.0000002.0000005.0000003.0000006.0000003.0000003.00000020.0000005.0000003.00000023.0000003.0000005.0000007.00000011.0000004.0000004.0000003.0000006.0000003.0000006.0000005.0000004.0000007.0000006.0000007.00000013.0000003.0000002.0000008.0000004.0000003.00000012.0000004.0000003.0000003.00000012.0000003.0000007.0000003.0000004.0000002.0000006.0000005.0000004.00000039.0000005.0000003.000000
\n", + "
" + ], + "text/plain": [ + " AL627309.5 LINC01409 LINC01128 LINC00115 FAM41C \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 0.010506 0.038540 0.061746 0.007833 0.010612 \n", + "std 0.104026 0.205398 0.278407 0.090539 0.104270 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "75% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "max 3.000000 3.000000 4.000000 3.000000 2.000000 \n", + "\n", + " NOC2L KLHL17 HES4 ISG15 AGRN \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 0.115899 0.005585 0.041306 0.540900 0.003976 \n", + "std 0.370375 0.075591 0.348752 1.662795 0.065012 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "75% 0.000000 0.000000 0.000000 1.000000 0.000000 \n", + "max 7.000000 3.000000 19.000000 110.000000 2.000000 \n", + "\n", + " C1orf159 TNFRSF18 TNFRSF4 SDF4 B3GALT6 \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 0.014536 0.029736 0.039378 0.228127 0.054379 \n", + "std 0.124264 0.212000 0.267495 0.528275 0.244759 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "75% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "max 3.000000 8.000000 8.000000 6.000000 4.000000 \n", + "\n", + " C1QTNF12 UBE2J2 SCNN1D ACAP3 PUSL1 \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 0.002460 0.177525 0.002939 0.050030 0.042011 \n", + "std 0.050603 0.465091 0.054865 0.235543 0.212713 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "75% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "max 2.000000 9.000000 2.000000 5.000000 3.000000 \n", + "\n", + " INTS11 CPTP DVL1 AURKAIP1 CCNL2 \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 0.119370 0.031678 0.022222 0.594960 0.158601 \n", + "std 0.369577 0.180967 0.153592 1.096718 0.430142 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "75% 0.000000 0.000000 0.000000 1.000000 0.000000 \n", + "max 6.000000 3.000000 3.000000 20.000000 5.000000 \n", + "\n", + " MRPL20-AS1 MRPL20 ATAD3C ATAD3B ATAD3A \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 0.037290 0.667983 0.005253 0.032356 0.046107 \n", + "std 0.199056 1.216322 0.076402 0.189642 0.253422 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "75% 0.000000 1.000000 0.000000 0.000000 0.000000 \n", + "max 3.000000 23.000000 3.000000 5.000000 7.000000 \n", + "\n", + " SSU72 AL645728.1 FNDC10 AL691432.2 MIB2 \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 0.438034 0.038327 0.017993 0.015147 0.099807 \n", + "std 0.791005 0.208075 0.143047 0.126420 0.345385 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "75% 1.000000 0.000000 0.000000 0.000000 0.000000 \n", + "max 11.000000 4.000000 4.000000 3.000000 6.000000 \n", + "\n", + " MMP23B CDK11B FO704657.1 SLC35E2B CDK11A \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 0.015919 0.113891 0.002726 0.043753 0.156287 \n", + "std 0.135665 0.364506 0.055599 0.217772 0.428388 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "75% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "max 3.000000 6.000000 5.000000 4.000000 7.000000 \n", + "\n", + " SLC35E2A NADK GNB1 PRKCZ AL590822.2 \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 0.027661 0.168216 0.480338 0.015320 0.003511 \n", + "std 0.173996 0.468028 0.886230 0.126767 0.059820 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "75% 0.000000 0.000000 1.000000 0.000000 0.000000 \n", + "max 6.000000 7.000000 13.000000 3.000000 2.000000 \n", + "\n", + " FAAP20 SKI MORN1 RER1 PEX10 \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 0.254458 0.068848 0.008378 0.381488 0.026491 \n", + "std 0.571289 0.278986 0.094726 0.766712 0.168906 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "75% 0.000000 0.000000 0.000000 1.000000 0.000000 \n", + "max 8.000000 4.000000 3.000000 12.000000 4.000000 \n", + "\n", + " PLCH2 PANK4 AL139246.5 TNFRSF14-AS1 TNFRSF14 \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 0.006423 0.022501 0.052105 0.014802 0.277612 \n", + "std 0.084421 0.153941 0.257862 0.126566 0.590933 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "75% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "max 3.000000 3.000000 12.000000 3.000000 7.000000 \n", + "\n", + " AL139246.3 PRXL2B TTC34 MEGF6 TPRG1L \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 0.004163 0.024284 0.005346 0.014243 0.066201 \n", + "std 0.067015 0.165342 0.074723 0.128196 0.268191 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "75% 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "max 3.000000 4.000000 2.000000 6.000000 5.000000 \n", + "\n", + " WRAP73 SMIM1 LRRC47 CEP104 \n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 0.059273 0.328054 0.078862 0.060257 \n", + "std 0.252045 1.574947 0.302492 0.259100 \n", + "min 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 0.000000 0.000000 \n", + "75% 0.000000 0.000000 0.000000 0.000000 \n", + "max 4.000000 39.000000 5.000000 3.000000 " + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gex_expressions.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CD86CD274CD270CD155CD112CD47CD48CD40CD154CD52CD3CD8CD56CD19CD33CD11cHLA-A-B-CCD45RACD123CD7CD105CD49fCD194CD4CD44CD14CD16CD25CD45ROCD279TIGITCD20CD335CD31PodoplaninCD146IgMCD5CD195CD32CD196CD185CD103CD69CD62LCD161CD152CD223KLRG1CD27CD107aCD95CD134HLA-DRCD1cCD11bCD64CD141CD1dCD314CD35CD57CD272CD278
count75195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.00000075195.000000
mean3.1623514.72333311.6732232.6983316.34700450.35832248.9182405.97857614.75890721.43851322.29988712.7034518.1923008.5950668.56025012.47368840.57845785.1608206.67028429.1691478.91394324.5731111.70519316.15751155.1185846.0156137.8431281.34824123.26513711.0577306.8381418.7350885.22345920.1120826.0165041.59699529.53241540.5798006.77575622.0112385.0788225.4034182.4753241.8517597.9492656.1260328.5682954.80223410.5435877.5076278.83356631.3061774.17271116.7434542.5212717.0811492.78551820.76428013.72886511.78695429.4447109.6711224.0056927.122734
std11.3343886.23007211.08103910.5601439.13342477.90422886.50702716.53019112.65909253.25489062.40082959.75212135.34232738.03033138.78530944.50002383.632973210.89848349.67277988.6260919.56307544.7924849.31508550.669350104.13987020.52794845.8148353.62473459.75730113.0455819.43811134.10223413.08771460.4672168.1650227.476762193.960159124.68448616.72443275.32315113.53442612.11882420.4754419.38475827.53875916.2284207.8320984.67628943.39527922.87788015.44322147.5386124.26374158.19732716.59253324.4202868.41713828.52284420.51688623.66202491.60812445.7233898.87647117.606777
min0.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.000000
25%0.0000001.0000004.0000000.0000002.0000008.0000006.0000001.0000006.0000002.0000001.0000000.0000001.0000000.0000000.0000000.0000005.0000004.0000000.0000000.0000004.0000005.0000000.0000001.0000007.0000001.0000000.0000000.0000005.0000004.0000002.0000001.0000001.0000000.0000002.0000000.0000003.0000001.0000002.0000000.0000001.0000002.0000000.0000000.0000000.0000001.0000003.0000002.0000000.0000000.0000002.00000010.0000001.0000002.0000000.0000000.0000000.0000009.0000005.0000003.0000001.0000002.0000001.0000001.000000
50%1.0000003.0000008.0000001.0000004.00000016.00000016.0000003.00000011.0000006.0000002.0000000.0000003.0000001.0000001.0000001.00000011.00000011.0000001.0000001.0000006.00000010.0000000.0000002.00000016.0000002.0000001.0000001.0000009.0000007.0000004.0000003.0000003.0000004.0000004.0000001.0000007.0000003.0000004.0000002.0000002.0000003.0000001.0000001.0000001.0000003.0000006.0000003.0000001.0000001.0000005.00000017.0000003.0000004.0000000.0000001.0000001.00000014.0000008.0000006.0000003.0000004.0000002.0000003.000000
75%2.0000006.00000016.0000003.0000008.00000046.00000041.0000005.00000019.00000015.0000007.0000002.0000006.0000002.0000004.0000009.00000033.00000046.0000003.0000009.00000011.00000023.0000001.0000006.00000043.0000005.0000002.0000002.00000018.00000014.0000008.0000006.0000006.00000016.0000008.0000002.00000018.00000012.0000006.00000012.0000004.0000006.0000002.0000002.0000005.0000006.00000011.0000006.0000003.0000002.00000010.00000031.0000006.00000010.0000001.0000005.0000002.00000025.00000016.00000011.00000023.0000008.0000004.0000007.000000
max289.000000453.000000201.0000002610.000000253.0000001157.0000002326.000000510.000000381.0000005912.000000778.0000001497.0000002338.0000001216.0000001289.000000974.0000003123.0000003334.0000001799.0000001775.000000344.000000734.000000500.0000002446.0000001623.000000379.0000001368.000000243.0000001387.000000448.000000393.0000001384.000000566.0000002125.0000001461.000000615.00000018548.0000002493.000000584.0000001770.000000707.0000002291.0000001226.000000832.0000001527.000000656.000000166.000000174.0000001042.000000390.000000764.0000001308.000000100.0000004716.0000001214.000000618.000000213.0000002580.000000626.000000504.0000002303.0000003873.000000274.0000001621.000000
\n", + "
" + ], + "text/plain": [ + " CD86 CD274 CD270 CD155 CD112 \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 3.162351 4.723333 11.673223 2.698331 6.347004 \n", + "std 11.334388 6.230072 11.081039 10.560143 9.133424 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 1.000000 4.000000 0.000000 2.000000 \n", + "50% 1.000000 3.000000 8.000000 1.000000 4.000000 \n", + "75% 2.000000 6.000000 16.000000 3.000000 8.000000 \n", + "max 289.000000 453.000000 201.000000 2610.000000 253.000000 \n", + "\n", + " CD47 CD48 CD40 CD154 CD52 \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 50.358322 48.918240 5.978576 14.758907 21.438513 \n", + "std 77.904228 86.507027 16.530191 12.659092 53.254890 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 8.000000 6.000000 1.000000 6.000000 2.000000 \n", + "50% 16.000000 16.000000 3.000000 11.000000 6.000000 \n", + "75% 46.000000 41.000000 5.000000 19.000000 15.000000 \n", + "max 1157.000000 2326.000000 510.000000 381.000000 5912.000000 \n", + "\n", + " CD3 CD8 CD56 CD19 CD33 \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 22.299887 12.703451 8.192300 8.595066 8.560250 \n", + "std 62.400829 59.752121 35.342327 38.030331 38.785309 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 1.000000 0.000000 1.000000 0.000000 0.000000 \n", + "50% 2.000000 0.000000 3.000000 1.000000 1.000000 \n", + "75% 7.000000 2.000000 6.000000 2.000000 4.000000 \n", + "max 778.000000 1497.000000 2338.000000 1216.000000 1289.000000 \n", + "\n", + " CD11c HLA-A-B-C CD45RA CD123 CD7 \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 12.473688 40.578457 85.160820 6.670284 29.169147 \n", + "std 44.500023 83.632973 210.898483 49.672779 88.626091 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 5.000000 4.000000 0.000000 0.000000 \n", + "50% 1.000000 11.000000 11.000000 1.000000 1.000000 \n", + "75% 9.000000 33.000000 46.000000 3.000000 9.000000 \n", + "max 974.000000 3123.000000 3334.000000 1799.000000 1775.000000 \n", + "\n", + " CD105 CD49f CD194 CD4 CD44 \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 8.913943 24.573111 1.705193 16.157511 55.118584 \n", + "std 9.563075 44.792484 9.315085 50.669350 104.139870 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 4.000000 5.000000 0.000000 1.000000 7.000000 \n", + "50% 6.000000 10.000000 0.000000 2.000000 16.000000 \n", + "75% 11.000000 23.000000 1.000000 6.000000 43.000000 \n", + "max 344.000000 734.000000 500.000000 2446.000000 1623.000000 \n", + "\n", + " CD14 CD16 CD25 CD45RO CD279 \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 6.015613 7.843128 1.348241 23.265137 11.057730 \n", + "std 20.527948 45.814835 3.624734 59.757301 13.045581 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 1.000000 0.000000 0.000000 5.000000 4.000000 \n", + "50% 2.000000 1.000000 1.000000 9.000000 7.000000 \n", + "75% 5.000000 2.000000 2.000000 18.000000 14.000000 \n", + "max 379.000000 1368.000000 243.000000 1387.000000 448.000000 \n", + "\n", + " TIGIT CD20 CD335 CD31 Podoplanin \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 6.838141 8.735088 5.223459 20.112082 6.016504 \n", + "std 9.438111 34.102234 13.087714 60.467216 8.165022 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 2.000000 1.000000 1.000000 0.000000 2.000000 \n", + "50% 4.000000 3.000000 3.000000 4.000000 4.000000 \n", + "75% 8.000000 6.000000 6.000000 16.000000 8.000000 \n", + "max 393.000000 1384.000000 566.000000 2125.000000 1461.000000 \n", + "\n", + " CD146 IgM CD5 CD195 CD32 \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 1.596995 29.532415 40.579800 6.775756 22.011238 \n", + "std 7.476762 193.960159 124.684486 16.724432 75.323151 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 3.000000 1.000000 2.000000 0.000000 \n", + "50% 1.000000 7.000000 3.000000 4.000000 2.000000 \n", + "75% 2.000000 18.000000 12.000000 6.000000 12.000000 \n", + "max 615.000000 18548.000000 2493.000000 584.000000 1770.000000 \n", + "\n", + " CD196 CD185 CD103 CD69 CD62L \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 5.078822 5.403418 2.475324 1.851759 7.949265 \n", + "std 13.534426 12.118824 20.475441 9.384758 27.538759 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 1.000000 2.000000 0.000000 0.000000 0.000000 \n", + "50% 2.000000 3.000000 1.000000 1.000000 1.000000 \n", + "75% 4.000000 6.000000 2.000000 2.000000 5.000000 \n", + "max 707.000000 2291.000000 1226.000000 832.000000 1527.000000 \n", + "\n", + " CD161 CD152 CD223 KLRG1 CD27 \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 6.126032 8.568295 4.802234 10.543587 7.507627 \n", + "std 16.228420 7.832098 4.676289 43.395279 22.877880 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 1.000000 3.000000 2.000000 0.000000 0.000000 \n", + "50% 3.000000 6.000000 3.000000 1.000000 1.000000 \n", + "75% 6.000000 11.000000 6.000000 3.000000 2.000000 \n", + "max 656.000000 166.000000 174.000000 1042.000000 390.000000 \n", + "\n", + " CD107a CD95 CD134 HLA-DR CD1c \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 8.833566 31.306177 4.172711 16.743454 2.521271 \n", + "std 15.443221 47.538612 4.263741 58.197327 16.592533 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 2.000000 10.000000 1.000000 2.000000 0.000000 \n", + "50% 5.000000 17.000000 3.000000 4.000000 0.000000 \n", + "75% 10.000000 31.000000 6.000000 10.000000 1.000000 \n", + "max 764.000000 1308.000000 100.000000 4716.000000 1214.000000 \n", + "\n", + " CD11b CD64 CD141 CD1d CD314 \\\n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 7.081149 2.785518 20.764280 13.728865 11.786954 \n", + "std 24.420286 8.417138 28.522844 20.516886 23.662024 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 9.000000 5.000000 3.000000 \n", + "50% 1.000000 1.000000 14.000000 8.000000 6.000000 \n", + "75% 5.000000 2.000000 25.000000 16.000000 11.000000 \n", + "max 618.000000 213.000000 2580.000000 626.000000 504.000000 \n", + "\n", + " CD35 CD57 CD272 CD278 \n", + "count 75195.000000 75195.000000 75195.000000 75195.000000 \n", + "mean 29.444710 9.671122 4.005692 7.122734 \n", + "std 91.608124 45.723389 8.876471 17.606777 \n", + "min 0.000000 0.000000 0.000000 0.000000 \n", + "25% 1.000000 2.000000 1.000000 1.000000 \n", + "50% 3.000000 4.000000 2.000000 3.000000 \n", + "75% 23.000000 8.000000 4.000000 7.000000 \n", + "max 2303.000000 3873.000000 274.000000 1621.000000 " + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adt_expressions.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "35451.0 28229.0\n" + ] + } + ], + "source": [ + "print(np.max(expressions[:, gex_indicator]), np.max(expressions[:, ~gex_indicator]))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "make_histograms(\n", + " gex_expressions,\n", + " gex_expressions.columns,\n", + " \"GEX expressions\",\n", + " subplots_shape=(8, 8),\n", + " display_desc=True,\n", + " title_shift=1.05,\n", + " bins=100,\n", + " y_label=\"PMF estimation\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAADJYAAAYfCAYAAABsdJMPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeZSU5YE+7LvZUVmiyKaoOGoAF4yoSIzGhdgqmhCIowYFcRsJGIFEIxkXoiYkGrcoymhUcJRByLhF/KGI4oZLBIkLQlwwmEFEotguLIr9/eHXFVoWKdm067rOqaP9vk+99VTlHO+83XU/T1llZWVlAAAAAAAAAAAAAAAAKDm1NvYEAAAAAAAAAAAAAAAA2DgUSwAAAAAAAAAAAAAAAEqUYgkAAAAAAAAAAAAAAECJUiwBAAAAAAAAAAAAAAAoUYolAAAAAAAAAAAAAAAAJUqxBAAAAAAAAAAAAAAAoEQplgAAAAAAAAAAAAAAAJQoxRIAAAAAAAAAAAAAAIASpVgCAAAAAAAAAAAAAABQohRLAAAAAABgI+vYsWPKyspSv379/POf/1zt2BNOOCFlZWXVHg0bNkyLFi2y11575dRTT83dd9+dTz75ZI2euyaP119/fT29c77I0KFDU1ZWlqFDh27sqQAAAAAAADVUnY09AQAAAAAAKGV/+ctf8txzzyVJli5dmltuuSVnnHHGFz7v3/7t3/Kd73wnSfLJJ5/k3XffzQsvvJDrr78+119/fbbddtvccMMNOfjggwvPqRr/eX/605/y4YcfZt99980OO+ywwvnNNtvsy7w1AAAAAAAAvgbKKisrKzf2JAAAAAAAoFSddtpp+a//+q9stdVW+b//+7/suuuuhaLJypxwwgkZNWpU+vTpk5EjR65w/q9//WvOPvvsTJgwIbVr184dd9yRI488crVz2G677fL3v/89N910U0444YS1fEesSwsWLMiCBQvSrFmzNGvWbGNPBwAAAAAAqIFqbewJAAAAAABAqfroo4/yP//zP0mS//7v/85mm22W559/Pn/5y1++9DU7duyYe++9N0cffXSWLVuWPn36pKKiYl1NmQ2sWbNmadeunVIJAAAAAACw3iiWAAAAAADARjJu3LhUVFRkl112yYEHHpijjz46SXLDDTes1XXLysoyfPjwNGzYMO+++26uv/76dTHdNfKnP/0phx56aLbccsvUq1cvW221VY477rjMmDGj2rjXXnstTZs2Ta1atfL//t//W+E6c+fOTfPmzVNWVpbbbrutcHzkyJEpKyvLCSeckH/+85/p379/ttlmm9SvXz/bbrttBg0alHfffXeF602ePDllZWU54IAD8tFHH+W8885L+/bts8kmm2S77barNnbq1Knp1atX4bqbb755ysvLc++99670Pb/55ps544wzstNOO6VBgwbZZJNN0qZNmxx88MH5/e9/v8L4Bx54IEceeWRatGiRunXr5hvf+EZ23HHHHHfccXnkkUeqjR06dGjKysoydOjQlb72fffdlyOOOCLNmzdPvXr10rp16xx99NF55plnVjr+gAMOSFlZWSZPnpzp06enR48eadasWerXr58OHTrk0ksvzco2u1+yZEkuueSSdOrUKY0aNUq9evXSsmXL7LXXXjnrrLPyzjvvrPT1AAAAAACArz7FEgAAAAAA2EiqCiQnnnhitX+OGTMmixYtWqtrb7HFFjn00EOTJBMnTlyra62JTz75JEcffXSOOuqoTJ48OTvttFO6d++eLbfcMrfeemv23HPPTJgwoTB+++23z4033pjKysr07t07//jHPwrnli1blmOOOSZvv/12fvKTnxQKN8t7991307lz54wePTqdOnVKt27d8v777+eKK65Ily5d8vbbb690nosXL84BBxyQyy67LG3bts33v//97LjjjoXzV155Zfbee++MHj06W2yxRb7//e9n5513zuTJk9OtW7dccMEF1a43b9687LnnnvnDH/6QJUuW5NBDD833v//9tG3bNtOnT89FF11UbfyoUaNyyCGHZPz48Wnbtm169uyZ/fffP40bN86YMWNy++23r/Fnfu655+bQQw/Nvffem5122ik/+tGP0qJFi4wdOzb77LNPbrzxxlU+97777kvnzp0zc+bMfO9730uXLl3yt7/9LT//+c8zaNCgamM//fTTdOvWLWeddVZeeeWV7LfffvnRj36UXXfdNW+//XYuueSSzJkzZ43nDQAAAAAAfLXU2dgTAAAAAACAUvS3v/0tjz76aOrWrZvjjjsuSfLtb3877dq1y8yZM/OnP/0pxx9//Fq9RqdOnXLHHXfkxRdfXBdTXq3zzz8/Y8eOTefOnfM///M/adu2beHcn/70pxxzzDH58Y9/XNipJEl69OiRM844I1deeWWOOeaYTJ48OXXq1Ml//ud/5tFHH80ee+yRyy67bKWvd/fdd2efffbJ008/nc033zxJsnDhwnTr1i1TpkzJT3/60/zP//zPCs976qmnsttuu+WVV15Jy5Ytq5277777MmjQoGyxxRb53//93+y///6Fc88//3wOP/zwnH/++fnud7+b7373u0mS6667LnPnzs2pp56aESNGpKysrPCcjz/+eIUdSH71q1+lsrIyjz76aL7zne9UOzd//vz83//93xd91EmSCRMm5KKLLkqDBg1y991353vf+17h3A033JCTTz45p512Wjp37pydd955hef/9re/zYgRI/If//EfhWMPPvhgunbtmquvvjo///nPs/XWWydJHnvssUyaNCnf+ta38vDDD6dRo0bVrvXMM8+kTZs2azRvAAAAAADgq8eOJQAAAAAAsBFU7Sbx/e9/P1tuuWXheNWuJVW7mayNZs2aJUn++c9/rvW1Vuedd97J5ZdfngYNGuR///d/q5VKkuRHP/pR/uM//iPvvvtubrnllmrnLrnkknTu3DmPP/54/vM//zP33ntvLr744jRp0iTjxo1L/fr1V/m61157baFUkiRNmzYtlDvGjh1bbReU5V199dUrlEqSz8oxlZWVGTFiRLVSSZLsuuuuhZLLVVddVTj+1ltvJUkOPfTQaqWSJKlbt24OPvjgasfeeuutNGnSZIVSSZI0b9483/rWt1b5fpf3+9//Pknyk5/8pFqpJElOOumkHHHEEfn4449z5ZVXrvT5PXr0qFYqSZKDDjoo5eXlWbZsWR566KEV3uN+++23QqkkSfbcc89sscUWazRvAAAAAADgq0exBAAAAAAANrBPPvkko0aNSvKvIkmV3r17p06dOnnkkUfy6quvrtXrfPrpp0myQuFhXXvooYeyaNGi7Lvvvtlqq61WOuaAAw5IkkyZMqXa8bp16+a2227L5ptvnksuuSTHHntsKisrc8MNN2T77bdf5Wt27Ngxu++++wrHd91113zrW9/Kp59+usJuIcln5Y399ttvheMLFizI008/nYYNG+bII49c4/ew9957J0nOPvvs3H777fnggw9WOeeq8e+991569+6dqVOnFv43KsYnn3ySxx9/PElywgknrHTMSSedlCTVCiLLW9V7bN++fZJU2zlljz32SO3atXPjjTdm+PDhefPNN4ueMwAAAAAA8NWlWAIAAAAAABvY+PHjM2/evGy11VYpLy+vdq5FixY5/PDDU1lZWdjV5MtasGBBklTb1WN9eO2115IkkyZNSllZ2Uof//7v/54kefvtt1d4/rbbbpurrroqlZWVqaioSL9+/dKzZ8/Vvubnd0VZ2bmV7Viy3XbbrfQ5s2fPTmVlZRYtWpT69euv9D00b958hfdw/PHHp1evXvnb3/6Wnj17pmnTptltt93yk5/8JA8++OAKr3PNNddk++23z3//939nzz33TNOmTXPwwQfn17/+debMmbPa91zln//8ZxYvXrzaz+Hf/u3fklQviCxvm222Wenxxo0bJ0nh+lXXuvzyy/Pxxx9nwIABad26dbbbbrsce+yxufXWW7N06dI1mjcAAAAAAPDVVGdjTwAAAAAAAErNDTfckOSzL+9/97vfXeF8VRlg5MiRueCCC1K7du0v9TrTpk1L8tkuHutT1a4bO+ywQ/bdd9/Vjm3Xrt0KxyorK3PrrbcWfp42bVo+/vjj1K1bd63mVVlZucKxhg0brnRs1XvYbLPNvrDUsrxatWrllltuyS9/+cuMHz8+jz/+eB5//PFce+21ufbaa3PkkUfmjjvuKPxv2L59+8yaNSv3339/HnzwwUyZMiWPPvpoHnzwwVxwwQW54YYbctxxx32Jd1ucWrWKW3vs9NNPz7//+7/n7rvvzmOPPZbHHnssY8aMyZgxY3L++efn0UcfTatWrdbTbAEAAAAAgPVJsQQAAAAAADagN998M/fee2+Sz3aeePzxx1c5du7cuZkwYUK6detW9OssWLAg9913X5LkkEMO+XKTXUNt2rRJknzzm9/MyJEji37+7373u9x7771p3759mjZtmieeeCK/+MUvctlll63yObNnz17luddffz1JsvXWW6/xHKreQ1lZWW688caiixcdOnRIhw4dcuaZZ6aysjIPPvhgfvzjH+fPf/5zbr755vTt27cwtk6dOjn88MNz+OGHJ0kqKipy2WWX5Ve/+lX+4z/+Iz/84Q+z6aabrvK1tthii9SvXz9LlizJa6+9lt12222FMVW7yGy11VZFvY/VadGiRU455ZSccsopSZKZM2fmxBNPzBNPPJGzzz47o0aNWmevBQAAAAAAbDjF/VUEAAAAAABYKyNHjsyyZcvSuXPnVFZWrvJx1llnJfnX7ibFqKyszIABA7Jo0aJsvvnmOemkk9b126jm4IMPTr169TJ58uTMnz+/qOc++uijOeecc7LJJptk3Lhxue2227L55pvn8ssvz1133bXK5z333HN57rnnVjj+4osvZtq0aalVq1b233//NZ5H69ats9tuu+X999/PhAkTinoPn1dWVpaDDz44P/7xj5Mk06dPX+34xo0bZ+jQoWnatGk++uij/O1vf1vt+Dp16uQ73/lOkqyyyHPjjTcmSQ488MDiJl+Edu3a5Re/+EWSL36PAAAAAADAV5diCQAAAAAAbEBVX/jv06fPasf17t07SXLPPffk7bffXuPrP/fcczn88MNz2223pXbt2rnlllvSqFGjLz/hNdCiRYucfvrp+fDDD3PkkUfm+eefX2HMkiVLcvfdd2fmzJmFY2+//XaOPfbYLFu2LMOHD8/OO++cNm3aZNSoUSkrK0vfvn0Lu498XmVlZfr165d33323cOy9995Lv379UllZmZ49exZ2IVlTF110UZKkb9+++fOf/7zS13zqqady//33F47dfPPNmTp16gpj33///UyePDlJsu222yZJPvroo1x22WUr/d/z0UcfzcKFC1O7du012mnlZz/7WZLk2muvzaRJk6qdGzlyZO6+++7UrVs3Z5xxxhde64s8+OCDuffee/Pxxx9XO15ZWZl77rknyb/eIwAAAAAA8PVTZ2NPAAAAAAAASsXDDz+cV155JfXr188xxxyz2rE777xz9thjj0ybNi0333xzoUhQ5bHHHssJJ5yQJPnkk0+ycOHCvPDCC/n73/+eJGnbtm1uuOGG9bpjxfJ++9vf5s0338zo0aOz++67p2PHjtl+++1Tp06d/OMf/8j06dPz4Ycf5v/9v/+Xdu3a5dNPP81xxx2X//u//0ufPn0K7yVJjjjiiAwePDiXXnppjj766Dz22GOpW7dutdf7/ve/nxdeeCHbb799DjzwwJSVlWXy5Ml55513suOOO+bqq68u+j0ceeSRufLKK/Ozn/0s3//+97PDDjvkm9/8Zpo0aZK33347f/3rXzN//vz84he/yCGHHJIkuf3229OnT5+0bt06u+++e77xjW/k3XffzeOPP5733nsvu+yyS0455ZQkydKlS/Ozn/0sZ555ZnbdddfsuOOOqVu3bl5//fU8+eSTSZL//M//zJZbbvmFcz3ssMNyzjnn5KKLLsr3vve97Lvvvtlmm20yc+bMTJs2LbVr186IESOy8847F/05fN5zzz2XQYMGpXHjxtljjz3SunXrLFq0KNOmTcvf//73NGnSJBdccMFavw4AAAAAALBxKJYAAAAAAMAGcsMNNyT5rMDwjW984wvH9+7dO9OmTcsNN9ywQrHk1VdfzauvvpokqV+/fpo0aZI2bdrkkEMOyRFHHJHDDz88depsuD8D1KlTJ7feemuOO+64/PGPf8xTTz2VF154IZtuumlatWqVI488Mt///vez//77J0l+85vf5P7770+HDh1yzTXXrHC9YcOG5fHHH8+TTz6Zs846K5dffnm189/4xjfy5JNP5txzz8348eMzf/78tGjRIscdd1zOP//8bL755l/qffz0pz/NQQcdlKuuuioPPfRQJk2alFq1aqVly5b51re+lW7duqVnz56F8T/72c/Stm3bTJkyJdOmTcs777yTzTffPB06dMiPf/zj9O3bN5tuummSZLPNNsuIESPy8MMP59lnn83EiROzdOnStG7dOj169MhPfvKTHHTQQWs81wsvvDD77rtvrrrqqjz11FN58skn06xZsxx11FH5+c9/nr333vtLfQafd+SRR+a9997Lo48+mpdffjlPPvlkGjZsmDZt2uTss89O//7912iXFQAAAAAA4KuprLKysnJjTwIAAAAAAGBNjBw5Mn379k2fPn0ycuTIjT0dAAAAAACAr71aG3sCAAAAAAAAAAAAAAAAbByKJQAAAAAAAAAAAAAAACVKsQQAAAAAAAAAAAAAAKBElVVWVlZu7EkAAAAAAAAAAAAAAACw4dmxBAAAAAAAAAAAAAAAoEQplgAAAAAAAAAAAAAAAJQoxRIAAAAAAAAAAAAAAIASpVgCAAAAAAAAAAAAAABQohRLAAAAAAAAAAAAAAAASpRiCQAAAAAAAAAAAAAAQIlSLAEAAAAAAAAAAAAAAChRiiUAAAAAAAAAAAAAAAAlSrEEAAAAAAAAAAAAAACgRCmWAAAAAAAAAAAAAAAAlCjFEgAAAAAAAAAAAAAAgBKlWAIAAAAAAAAAAAAAAFCiFEsAAAAAAAAAAAAAAABKlGIJAAAAAAAAAAAAAABAiVIsAQAAAAAAAAAAAAAAKFGKJQAAAAAAAAAAAAAAACVKsQQAAAAAAAAAAAAAAKBEKZYAAAAAAAAAAAAAAACUKMUSAAAAAAAAAAAAAACAEqVYAgAAAAAAAAAAAAAAUKIUSwAAAAAAAAAAAAAAAEqUYgkAAAAAAAAAAAAAAECJUiwBAAAAAAAAAAAAAAAoUYolAAAAAAAAAAAAAAAAJUqxBAAAAAAAAAAAAAAAoEQplgAAAAAAAAAAAAAAAJQoxRIAAAAAAAAAAAAAAIASpVgCAAAAAAAAAAAAAABQohRLAAAAAAAAAAAAAAAASpRiCQAAAAAAAAAAAAAAQIlSLAEAAAAAAAAAAAAAAChRiiUAAAAAAAAAAAAAAAAlSrEEAAAAAAAAAAAAAACgRCmWAAAAAAAAAAAAAAAAlCjFEgAAAAAAAAAAAAAAgBKlWAIAAAAAAAAAAAAAAFCiFEsAAAAAAAAAAAAAAABKlGIJAAAAAAAAAAAAAABAiVIsAQAAAAAAAAAAAAAAKFGKJQAAAAAAAAAAAAAAACVKsQQAAAAAAAAAAAAAAKBEKZYAAAAAAAAAAAAAAACUKMUSAAAAAAAAAAAAAACAEqVYAgAAAAAAAAAAAAAAUKIUSwAAAAAAAAAAAAAAAEqUYgkAAAAAAAAAAAAAAECJUiwBAAAAAAAAAAAAAAAoUYolAAAAAAAAAAAAAAAAJUqxBAAAAAAAAAAAAAAAoEQplgAAAAAAAAAAAAAAAJQoxRIAAAAAAAAAAAAAAIASpVgCAAAAAAAAAAAAAABQohRLAAAAAAAAAAAAAAAASpRiCQAAAAAAAAAAAAAAQIlSLAEAAAAAAAAAAAAAAChRiiUAAAAAAAAAAAAAAAAlSrEEAAAAAAAAAAAAAACgRCmWAAAAAAAAAAAAAAAAlCjFEgAAAAAAAAAAAAAAgBKlWAIAAAAAAAAAAAAAAFCiFEsAAAAAAAAAAAAAAABKlGIJAAAAAAAAAAAAAABAiVIsAQAAAAAAAAAAAAAAKFGKJQAAAAAAAAAAAAAAACVKsQQAAAAAAAAAAAAAAKBEKZYAAAAAAAAAAAAAAACUKMUSAAAAAAAAAAAAAACAEqVYAgAAAAAAAAAAAAAAUKIUSwAAAAAAAAAAAAAAAEqUYgkAAAAAAAAAAAAAAECJUiwBAAAAAAAAAAAAAAAoUYolAAAAAAAAAAAAAAAAJUqxBAAAAAAAAAAAAAAAoEQplgAAAAAAAAAAAAAAAJQoxRIAAAAAAAAAAAAAAIASpVgCAAAAAAAAAAAAAABQohRLAAAAAAAAAAAAAAAASpRiCQAAAAAAAAAAAAAAQIlSLAEAAAAAAAAAAAAAAChRiiUAAAAAAAAAAAAAAAAlSrEEAAAAAAAAAAAAAACgRCmWAAAAAAAAAAAAAAAAlCjFEgAAAAAAAAAAAAAAgBKlWAIAAAAAAAAAAAAAAFCiFEsAAAAAAAAAAAAAAABKlGIJAAAAAAAAAAAAAABAiVIsAQAAAAAAAAAAAAAAKFGKJQAAAAAAAAAAAAAAACVKsQQAAAAAAAAAAAAAAKBEKZYAAAAAAAAAAAAAAACUKMUSAAAAAAAAAAAAAACAEqVYAgAAAAAAAAAAAAAAUKIUSwAAAAAAAAAAAAAAAEqUYgkAAAAAAAAAAAAAAECJUiwBAAAAAAAAAAAAAAAoUYolAAAAAAAAAAAAAAAAJUqxBAAAAAAAAAAAAAAAoEQplgAAAAAAAAAAAAAAAJQoxRIAAAAAAAAAAAAAAIASpVgCAAAAAAAAAAAAAABQohRLAAAAAAAAAAAAAAAASpRiCQAAAAAAAAAAAAAAQIlSLAEAAAAAAAAAAAAAAChRiiUAAAAAAAAAAAAAAAAlSrEEAAAAAAAAAAAAAACgRCmWAAAAAAAAAAAAAAAAlCjFEgAAAAAAAAAAAAAAgBKlWAIAAAAAAAAAAAAAAFCiFEsAAAAAAAAAAAAAAABKlGIJAAAAAAAAAAAAAABAiVIsAQAAAAAAAAAAAAAAKFGKJQAAAAAAAAAAAAAAACVKsQQAAAAAAAAAAAAAAKBEKZYAAAAAAAAAAAAAAACUKMUSAAAAAAAAAAAAAACAEqVYAgAAAAAAAAAAAAAAUKIUSwAAAAAAAAAAAAAAAEqUYgkAAAAAAAAAAAAAAECJUiwBAAAAAAAAAAAAAAAoUYolAAAAAAAAAAAAAAAAJUqxBAAAAAAAAAAAAAAAoEQplgAAAAAAAAAAAAAAAJQoxRIAAAAAAAAAAAAAAIASpVgCAAAAAAAAAAAAAABQohRLAAAAAAAAAAAAAAAASpRiCQAAAAAAAAAAAAAAQIlSLAEAAAAAAAAAAAAAAChRiiUAAAAAAAAAAAAAAAAlSrEEAAAAAAAAAAAAAACgRCmWAAAAAAAAAAAAAAAAlCjFEgAAAAAAAAAAAAAAgBKlWAIAAAAAAAAAAAAAAFCiFEsAAAAAAAAAAAAAAABKlGIJAAAAAAAAAAAAAABAiVIsAQAAAAAAAAAAAAAAKFGKJQAAAAAAAAAAAAAAACVKsQQAAAAAAAAAAAAAAKBEKZYAAAAAAAAAAAAAAACUKMUSAAAAAAAAAAAAAACAEqVYAgAAAAAAAAAAAAAAUKIUSwAAAAAAAAAAAAAAAEqUYgkAAAAAAAAAAAAAAECJUiwBAAAAAAAAAAAAAAAoUYolAAAAAAAAAAAAAAAAJUqxBAAAAAAAAAAAAAAAoEQplgAAAAAAAAAAAAAAAJQoxRIAAAAAAAAAAAAAAIASpVgCAAAAAAAAAAAAAABQohRLAAAAAAAAAAAAAAAASpRiCQAAAAAAAAAAAAAAQIlSLAEAAAAAAAAAAAAAAChRiiUAAAAAAAAAAAAAAAAlSrEEAAAAAAAAAAAAAACgRCmWAAAAAAAAAAAAAAAAlCjFEgAAAAAAAAAAAAAAgBKlWAIAAAAAAAAAAAAAAFCiFEsAAAAAAAAAAAAAAABKlGIJAAAAAAAAAAAAAABAiVIsAQAAAAAAAAAAAAAAKFGKJQAAAAAAAAAAAAAAACVKsQQAAAAAAAAAAAAAAKBEKZYAAAAAAAAAAAAAAACUKMUSAAAAAAAAAAAAAACAEqVYAgAAAAAAAAAAAAAAUKIUSwAAAAAAAAAAAAAAAEqUYgkAAAAAAAAAAAAAAECJUiwBAAAAAAAAAAAAAAAoUYolAAAAAAAAAAAAAAAAJUqxBAAAAAAAAAAAAAAAoEQplgAAAAAAAAAAAAAAAJQoxRIAAAAAAAAAAAAAAIASpVgCAAAAAAAAAAAAAABQohRLAAAAAAAAAAAAAAAASpRiCQAAAAAAAAAAAAAAQIlSLAEAAAAAAAAAAAAAAChRiiUAAAAAAAAAAAAAAAAlSrEEAAAAAAAAAAAAAACgRCmWAAAAAAAAAAAAAAAAlCjFEgAAAAAAAAAAAAAAgBKlWAIAAAAAAAAAAAAAAFCiFEsAAAAAAAAAAAAAAABKlGIJAAAAAAAAAAAAAABAiVIsAQAAAAAAAAAAAAAAKFGKJQAAAAAAAAAAAAAAACVKsQQAAAAAAAAAAAAAAKBEKZYAAAAAAAAAAAAAAACUKMUSAAAAAAAAAAAAAACAEqVYAgAAAAAAAAAAAAAAUKIUSwAAAAAAAAAAAAAAAEqUYgkAAAAAAAAAAAAAAECJUiwBAAAAAAAAAAAAAAAoUYolAAAAAAAAAAAAAAAAJUqxBAAAAAAAAAAAAAAAoEQplgAAAAAAAAAAAAAAAJQoxRIAAAAAAAAAAAAAAIASpVgCAAAAAAAAAAAAAABQohRLAAAAAAAAAAAAAAAASpRiCQAAAAAAAAAAAAAAQIlSLAEAAAAAAAAAAAAAAChRiiUAAAAAAAAAAAAAAAAlSrEEAAAAAAAAAAAAAACgRCmWAAAAAAAAAAAAAAAAlCjFEgAAAAAAAAAAAAAAgBKlWAIAAAAAAAAAAAAAAFCiFEsAAAAAAAAAAAAAAABKlGIJAAAAAAAAAAAAAABAiVIsAQAAAAAAAAAAAAAAKFGKJQAAAAAAAAAAAAAAACVKsQQAAAAAAAAAAAAAAKBEKZYAAAAAAAAAAAAAAACUKMUSAAAAAAAAAAAAAACAEqVYAgAAAAAAAAAAAAAAUKIUSwAAAAAAAAAAAAAAAEqUYgkAAAAAAAAAAAAAAECJUiwBAAAAAAAAAAAAAAAoUYolAAAAAAAAAAAAAAAAJUqxBAAAAAAAAAAAAAAAoEQplgAAAAAAAAAAAAAAAJQoxRIAAAAAAAAAAAAAAIASpVgCAAAAAAAAAAAAAABQohRLAAAAAAAAAAAAAAAASpRiCQAAAAAAAAAAAAAAQIlSLAEAAAAAAAAAAAAAAChRiiUAAAAAAAAAAAAAAAAlSrEEAAAAAAAAAAAAAACgRCmWAAAAAAAAAAAAAAAAlCjFEgAAAAAAAAAAAAAAgBKlWAIAAAAAAAAAAAAAAFCiFEsAAAAAAAAAAAAAAABKlGIJAAAAAAAAAAAAAABAiVIsAQAAAAAAAAAAAAAAKFGKJQAAAAAAAAAAAAAAACVKsQQAAAAAAAAAAAAAAKBEKZYAAAAAAAAAAAAAAACUKMUSAAAAAAAAAAAAAACAEqVYAgAAAAAAAAAAAAAAUKIUSwAAAAAAAAAAAAAAAEqUYgkAAAAAAAAAAAAAAECJUiwBAAAAAAAAAAAAAAAoUYolAAAAAAAAAAAAAAAAJUqxBAAAAAAAAAAAAAAAoEQplgAAAAAAAAAAAAAAAJQoxRIAAAAAAAAAAAAAAIASpVgCAAAAAAAAAAAAAABQohRLAAAAAAAAAAAAAAAASpRiCQAAAAAAAAAAAAAAQIlSLAEAAAAAAAAAAAAAAChRiiUAAAAAAAAAAAAAAAAlSrEEAAAAAAAAAAAAAACgRCmWAAAAAAAAAAAAAAAAlKg6G3sCVPfpp59m7ty5adSoUcrKyjb2dAC+lMrKyrz//vtp3bp1atXSYVzfZAdQE8iODUt2ADWB7NiwZAdQE8iODUt2ADWB7NiwZAdQE8iODUt2ADWB7NiwZAdQE6yv7FAs+YqZO3du2rRps7GnAbBOvPHGG9l666039jRqPNkB1CSyY8OQHUBNIjs2DNkB1CSyY8OQHUBNIjs2DNkB1CSyY8OQHUBNIjs2DNkB1CTrOjsUS75iGjVqlOSz/6EbN268kWcD8OVUVFSkTZs2hf+msX7JDqAmkB0bluwAagLZsWHJDqAmkB0bluwAagLZsWHJDqAmkB0bluwAagLZsWHJDqAmWF/ZoVjyFVO1tVbjxo2FFvC1Z7vADUN2ADWJ7NgwZAdQk8iODUN2ADWJ7NgwZAdQk8iODUN2ADWJ7NgwZAdQk8iODUN2ADXJus6OWuv0agAAAAAAAAAAAAAAAHxt2LGkBpkzZ04WLFiQJGnWrFm22WabjTwjAL7qZAcA60pVpsgTAD7PfQcAa0OOALAm5AUAxZIdABRLdgA1nWJJDTFnzpy0a9cuixYtSpI0bNgwM2fOFFwArJLsAGBdWT5T5AkAy3PfAcDakCMArAl5AUCxZAcAxZIdQCmotbEnwLqxYMGCLFq0KD169EiPHj2yaNGiQjMSAFZGdgCwrlRlyv777y9PAKjGfQcAa0OOALAm5AUAxZIdABRLdgClwI4lNUyzZs029hQA+JqRHQCsK02aNNnYUwDgK8p9BwBrQ44AsCbkBQDFkh0AFEt2ADWZHUsAAAAAAAAAAAAAAABKlB1LAAAA+FLmzJmTBQsW5KWXXtrYUwEAAAAAAAAAAL4kxRIAAACKNmfOnLRr1y6LFi3a2FMBAAAAAAAAAADWQq2NPQEAAAC+fhYsWJBFixalR48eOfDAAzf2dAAAAAAAAAAAgC/JjiUAAAB8ac2aNdvYUwAAAAAAAAAAANaCHUsAAAAAAAD4ypgzZ06mTZuWl156aWNPBQAAvhJ++9vfpqysLAMHDiwcW7x4cfr3758tttgim222WXr27Jm33nqr2vPmzJmTbt26ZZNNNknz5s1z5pln5pNPPqk2ZvLkydljjz1Sv3797LDDDhk5cuQKrz98+PBst912adCgQTp37pynn376C+c8bty4tGvXLg0aNMiuu+6ae++9t9r5ysrKnHfeeWnVqlUaNmyYrl275uWXX17zDwUAAFinFEsAAAAAAAD4SpgzZ07atWuXTp065bjjjtvY0wEAgI3uL3/5S/7rv/4ru+22W7XjgwYNyp///OeMGzcuDz/8cObOnZsePXoUzi9btizdunXL0qVLM2XKlIwaNSojR47MeeedVxgze/bsdOvWLQceeGCmT5+egQMH5uSTT859991XGHPbbbdl8ODBOf/88zNt2rR07Ngx5eXlmT9//irnPGXKlBx77LE56aST8uyzz6Z79+7p3r17XnjhhcKYiy++OH/4wx8yYsSIPPXUU9l0001TXl6exYsXr4uPDaAkDR06NGVlZdUe7dq1K5xXSgRgdRRLAAAAAAAA+EpYsGBBFi1alB49euTAAw/c2NMBAICN6oMPPkivXr1y/fXX5xvf+Ebh+HvvvZcbbrghl112WQ466KB06tQpN910U6ZMmZInn3wySXL//fdnxowZueWWW7L77rvnsMMOy4UXXpjhw4dn6dKlSZIRI0akbdu2ufTSS9O+ffsMGDAgP/rRj3L55ZcXXuuyyy7LKaeckr59+6ZDhw4ZMWJENtlkk9x4442rnPeVV16ZQw89NGeeeWbat2+fCy+8MHvssUeuvvrqJJ99MfiKK67IOeeckx/84AfZbbfdcvPNN2fu3Lm5884718MnCVA6dt5557z55puFx2OPPVY4p5QIwOps0GKJNiQAAAAAAABfpFmzZtW+OAcAAKWof//+6datW7p27Vrt+NSpU/Pxxx9XO96uXbtss802eeKJJ5IkTzzxRHbddde0aNGiMKa8vDwVFRV58cUXC2M+f+3y8vLCNZYuXZqpU6dWG1OrVq107dq1MGZlvui6s2fPzrx586qNadKkSTp37rza6y5ZsiQVFRXVHgBUV6dOnbRs2bLwaNasWRKlRAC+WNHFkscffzy33nprbr755sKjGNqQAKVnbbOjym9/+9uUlZVl4MCBhWNKiQA107rKDgBKh+wAoFiyA4BiyQ4AirU22TFmzJhMmzYtw4YNW+HcvHnzUq9evTRt2rTa8RYtWmTevHmFMcuXSqrOV51b3ZiKioosWrQoCxYsyLJly1Y6puoaK7Oq6y7/usvPZ02vO2zYsDRp0qTwaNOmzSrHAnxdre19x8svv5zWrVtn++23T69evTJnzpwkSolKiQBfrE4xg4899tjMmzcv3/rWt1K7du0kSVlZWXEv+P+3IT+vqg05evToHHTQQUmSm266Ke3bt8+TTz6ZffbZp9CGfOCBB9KiRYvsvvvuufDCC/OLX/wiQ4cOTb169aq1IZOkffv2eeyxx3L55ZenvLw8SfU2ZPJZg3L8+PG58cYbc/bZZ6903su3IZPkwgsvzMSJE3P11VdnxIgRK7Qhk+Tmm29OixYtcuedd+aYY44p6nMCqCnWRXYkyV/+8pf813/9V3bbbbdqxwcNGpTx48dn3LhxadKkSQYMGJAePXrk8ccfT/KvUmLLli0zZcqUvPnmm+ndu3fq1q2b3/zmN0n+VUo87bTTcuutt2bSpEk5+eST06pVq0J2VJUSR4wYkc6dO+eKK65IeXl5Zs2alebNm690zlWlxGHDhuWII47I6NGj071790ybNi277LJLkn+VEkeNGpW2bdvm3HPPTXl5eWbMmJEGDRoU/TkB1ATrKjsAKB2yA4BiyQ4AiiU7ACjW2mTHG2+8kTPOOCMTJ070d+PlDBkyJIMHDy78XFFRoVwC1Chre9/RuXPnjBw5Mt/85jfz5ptv5le/+lX222+/vPDCCxuslPjuu++uspQ4c+bMVc59fZYSf/WrX63yPAD/UlSx5K9//WtmzJixVi9Y1YZs0KBBunTpkmHDhmWbbbb5wjbkPvvss8o2ZL9+/fLiiy/mW9/61ipbi1Wr21e1IYcMGVI4v6ZtyOVvTKquW7WF1he1IVdVLFmyZEmWLFlS+FkbEqhp1kV2fPDBB+nVq1euv/76XHTRRYXjSokANdO6yA4ASovsAKBYa5sdw4YNy+23356ZM2emYcOG+fa3v53f/e53+eY3v1kYs3jx4vzsZz/LmDFjsmTJkpSXl+eaa66p9jeOOXPmpF+/fnnooYey2WabpU+fPhk2bFjq1PnXn28mT56cwYMH58UXX0ybNm1yzjnn5IQTTqg2n+HDh+eSSy7JvHnz0rFjx1x11VXZe++9V/sexo0bl3PPPTevv/56dtxxx/zud7/L4YcfXjhfWVmZ888/P9dff30WLlyYfffdN9dee2123HHHL/25AXydue8AoFhrkx1Tp07N/Pnzs8ceexSOLVu2LI888kiuvvrq3HfffVm6dGkWLlxY7QvCb731VmHB35YtW+bpp5+udt233nqrcK7qn1XHlh/TuHHjNGzYMLVr107t2rVXOmZlCwtXWdV1l3/dqmOtWrWqNmb33Xdf5XXr16+f+vXrr/I8wNfd2t53HHbYYYV/32233dK5c+dsu+22GTt2bBo2bLgupvi1o5QIsOZqFTN47733zqxZs770i1W1ISdMmJBrr702s2fPzn777Zf333/fFo22aARqqLXNjiTp379/unXrtkJxsFS3aASo6dZFdgBQWmQHAMVa2+x4+OGH079//zz55JOZOHFiPv744xxyyCH58MMPC2MGDRqUP//5zxk3blwefvjhzJ07Nz169Cicr9ppd+nSpZkyZUpGjRqVkSNH5rzzziuMqdpp98ADD8z06dMzcODAnHzyybnvvvsKY6p22j3//PMzbdq0dOzYMeXl5Zk/f/4q51+10+5JJ52UZ599Nt27d0/37t3zwgsvFMZU7bQ7YsSIPPXUU9l0001TXl6exYsXf+nPDeDrzH0HAMVam+w4+OCD8/zzz2f69OmFx5577plevXoV/r1u3bqZNGlS4TmzZs3KnDlz0qVLlyRJly5d8vzzz1e7N5g4cWIaN26cDh06FMYsf42qMVXXqFevXjp16lRtzKeffppJkyYVxqzMF123bdu2admyZbUxFRUVeeqpp1Z7XYCabl3fdzRt2jQ77bRTXnnllbRs2bJQSlze54t/KysGVp1b3ZiqUmKzZs3WeymxmOvWr18/jRs3rvYAYOWKKpZMnz49HTt2TMeOHbP33ntnr732+sIVr5Z32GGH5aijjspuu+2W8vLy3HvvvVm4cGHGjh1b9MRriiFDhuS9994rPN54442NPSWAdWpts2PMmDGZNm1ahg0btsK5Ui0lLlmyJBUVFdUeADXJ2mbHI488kiOPPDKtW7dOWVlZYZfBKpWVlTnvvPPSqlWrNGzYMF27ds3LL79cbcw777yTXr16pXHjxmnatGlOOumkfPDBB9XGPPfcc9lvv/3SoEGDtGnTJhdffPEKcxk3blzatWuXBg0aZNddd8299977hfOfPHly9thjj9SvXz877LBDRo4cucKY4cOHZ7vttkuDBg3SuXPnFVYcAyg1a5sdAJSetc2OCRMm5IQTTsjOO++cjh07ZuTIkZkzZ06mTp2a5F877V522WU56KCD0qlTp9x0002ZMmVKnnzyySQp7LR7yy23ZPfdd89hhx2WCy+8MMOHD8/SpUuTpNpOu+3bt8+AAQPyox/9KJdffnlhLsvvtNuhQ4eMGDEim2yySW688cZVzn/5nXbbt2+fCy+8MHvssUeuvvrqJFlhp93ddtstN998c+bOnbvCPRZAqXDfAUCx1iY7GjVqlF122aXaY9NNN80WW2yRXXbZJU2aNMlJJ52UwYMH56GHHsrUqVPTt2/fdOnSJfvss0+S5JBDDkmHDh1y/PHH569//Wvuu+++nHPOOenfv39h14/TTjstr732Ws4666zMnDkz11xzTcaOHZtBgwYV5jJ48OBcf/31GTVqVF566aX069cvH374Yfr27VsY07t37wwZMqTw8xlnnJEJEybk0ksvzcyZMzN06NA888wzGTBgQJKkrKwsAwcOzEUXXZS77747zz//fHr37p3WrVune/fua/vRA3xtrev7jg8++CCvvvpqWrVqlU6dOiklArBadb54yL/cdddd6/TFl29Dfu9737NFI0ANtDbZ8cYbb+SMM87IxIkT06BBg3U4q6+3YcOG5Ve/+tXGngbAerO29x0ffvhhOnbsmBNPPLHaasBVqlbdHTVqVNq2bZtzzz035eXlmTFjRiFvevXqlTfffLOw8nDfvn1z6qmnZvTo0Uk++wXVIYcckq5du2bEiBF5/vnnc+KJJ6Zp06Y59dRTk/xrBeBhw4bliCOOyOjRo9O9e/dMmzYtu+yyy0rnXrUa8WmnnZZbb701kyZNysknn5xWrVqlvLw8yb9WIx4xYkQ6d+6cK664IuXl5Zk1a1aaN2++Vp8dwNfVuv6dFQA137rOjvfeey9Jsvnmmyf54p1299lnn1XutNuvX7+8+OKL+da3vrXKHXEHDhyY5F877S7/Ba413Wl38ODBK1y3qjTyRTvtHnPMMStcc8mSJVmyZEnhZ4uhADWN+w4AirW+s+Pyyy9PrVq10rNnzyxZsiTl5eW55pprCudr166de+65J/369UuXLl2y6aabpk+fPrngggsKY9q2bZvx48dn0KBBufLKK7P11lvnj3/8Y+FvEkly9NFH5+233855552XefPmZffdd8+ECROq3cvMmTMntWr9a33jb3/72xk9enTOOeec/PKXv8yOO+6YO++8s9rfR84666x8+OGHOfXUU7Nw4cJ85zvfyYQJE3w3AChpa5sdP//5z3PkkUdm2223zdy5c3P++eendu3aOfbYY6uVEjfffPM0btw4p59++ipLiRdffHHmzZu30lLi1VdfnbPOOisnnnhiHnzwwYwdOzbjx48vzGPw4MHp06dP9txzz+y999654oorVlpK3GqrrQqLDZ9xxhn57ne/m0svvTTdunXLmDFj8swzz+S6665LUr2UuOOOOxb+1q+UCLDuFFUs2XbbbfPss8/mscceS5Lst99+qy1NfJGqNuTxxx9frQ3Zs2fPJCtvQ/7617/O/PnzC1+YWlkb8vOrAK+qDVkVJlVtyKpW/MpUtSGr/ljz+esu34as+kyq2pD9+vX70p8RwNfd2mTH1KlTM3/+/Oyxxx6FY8uWLcsjjzySq6++Ovfdd19JlhKHDBlS7Q//FRUVadOmzSrHA3zdrO19x2GHHZbDDjtspec+v+puktx8881p0aJF7rzzzhxzzDF56aWXMmHChPzlL3/JnnvumSS56qqrcvjhh+f3v/99WrdunVtvvTVLly7NjTfemHr16mXnnXfO9OnTc9lllxWKJcuvAJwkF154YSZOnJirr746I0aMWOn8ll+NOEnat2+fxx57LJdffnnhjzjLr0Zc9Zzx48fnxhtvzNlnn73GnxNATbKuf2cFQM23LrPj008/zcCBA7PvvvsWviS1oXbafffdd1e50+7MmTNXOef1sdOuxVCAms59BwDFWtfZMXny5Go/N2jQIMOHD8/w4cNXO4cv2k39gAMOyLPPPrvaMQMGDFjt96o+P7ckOeqoo3LUUUet8jllZWW54IILqhVdAErd2mbHP/7xjxx77LH55z//mS233DLf+c538uSTT2bLLbdMopQIwOrV+uIh//L73/8+J598cj744IN88MEHOeWUU3LZZZet8fN//vOf5+GHH87rr7+eKVOm5Ic//OFK25C2aASoOdYmOw4++OA8//zzmT59euGx5557plevXoV/L8UtGuvXr5/GjRtXewDUJGt737E6X7TqbvLZyr1NmzYtlEqSpGvXrqlVq1aeeuqpwpj9998/9erVK4yp2jXk3XffLYxZ2crCX7Rq8OqeU7Ua8fJj1mQ14iVLlqSioqLaA6AmWZ/ZAUDNtC6zo3///nnhhRcyZsyYdTzLr5chQ4bkvffeKzzeeOONjT0lgHXKfQcAxZIdABRrbbNjzJgxmTt3bpYsWZJ//OMfGTNmTP7t3/6tcL6qlPjOO+/kww8/zO23377CorpVpcSPPvoob7/9dn7/+9+nTp3qa9hXlRKXLFmSV199NSeccMIKcxkwYED+/ve/Z8mSJXnqqafSuXPnaucnT56ckSNHVjt21FFHZdasWVmyZEleeOGFHH744dXOV5US582bl8WLF+eBBx7ITjvttMafDwCrV9SOJTfffHP+8pe/FEocgwcPzl577bXCdumrog0JUHrWJjsaNWpU7b+zSbLppptmiy22KBy3RSNAzbO29x2rsyar7s6bN6+wQ2KVOnXqZPPNN682pm3btitco+rcN77xjS9cAXhV81sfqxFbORio6dZndgBQM62r7BgwYEDuueeePPLII9l6660Lx1u2bFlyO+3Wr1+/8HkC1ETuOwAoluwAoFiyA4CNqahiSZIsXry4EFqLFy8u6rlftFqXLRoBaqa1yY4vopQIUDOtz+woRUOGDKn2y8aKioq0adNmI84IYN2THQAUa22yo7KyMqeffnruuOOOTJ48eYXieadOnQo77fbs2TPJynfa/fWvf5358+cXyu0r22n3838TWdVOu1ULlVTttLu6v4FU7bQ7cODAlV53+Z12q4okVTvt9uvXr6jPCqAmcd8BQLFkBwDFkh0AbCxFFUvOPPPMdOrUKV27dk1lZWUefPDBnH/++etrbgDUAOs6Oz5f/FNKBKh51ud9x5qsutuyZcvMnz+/2vM++eSTvPPOO1+4avDyr/FFKwCvan7rYzViKwcDNZ3fWQFQrLXNjv79+2f06NG566670qhRo8LOhE2aNEnDhg3TpEkTO+0C1DDuOwAoluwAoFiyA4CNqahiyfHHH5+DDz44f/nLX5IkQ4cOrfZlLAD4PNkBQLHWZ3asyaq7Xbp0ycKFCzN16tR06tQpSfLggw/m008/TefOnQtj/vM//zMff/xx6tatm+Sz1X2/+c1v5hvf+EZhzOpWAF6Z9bUaMUBN574DgGKtbXZce+21ST5brGR5N910U0444YQkdtoFqGncdwBQLNkBQLFkBwAbU60vHpLMnj07STJjxowsXLgwO+64Y3bccce8++67mTFjxnqdIABfb7IDgGKtbXZ88MEHmT59eqZPn57ks/uZ6dOnZ86cOdVW3b377rvz/PPPp3fv3tVW3W3fvn0OPfTQnHLKKXn66afz+OOPZ8CAATnmmGPSunXrJMmPf/zj1KtXLyeddFJefPHF3HbbbbnyyiszePDgwjzOOOOMTJgwIZdeemlmzpyZoUOH5plnnqlWABkyZEh69+5d+Pm0007La6+9lrPOOiszZ87MNddck7Fjx2bQoEGFMYMHD87111+fUaNG5aWXXkq/fv1WWI0YoNS47wCgWGubHZWVlSt9VJVKkn/ttPvOO+/kww8/zO23377CToNVO+1+9NFHefvtt/P73/8+depUXxOsaqfdJUuW5NVXX632GlUGDBiQv//971myZEmeeuqpQim+yuTJkzNy5Mhqx4466qjMmjUrS5YsyQsvvJDDDz+82vmqnXbnzZuXxYsX54EHHshOO+20xp8RQE2zttkxbNiw7LXXXmnUqFGaN2+e7t27Z9asWdXGLF68OP37988WW2yRzTbbLD179lxh59o5c+akW7du2WSTTdK8efOceeaZ+eSTT6qNmTx5cvbYY4/Ur18/O+ywwwoZkCTDhw/PdtttlwYNGqRz5855+umnv/A9jBs3Lu3atUuDBg2y6667rrBASmVlZc4777y0atUqDRs2TNeuXfPyyy+v4ScEUPP4nRUAxZIdAGxMa7RjybBhw3Ldddelf//+K5wrKyvLgw8+uM4nBkDNIDsAKNbaZsczzzyTAw88sPBzVdmjT58+GTly5BqtunvrrbdmwIABOfjggwsrDP/hD38onG/SpEnuv//+9O/fP506dUqzZs1y3nnn5dRTTy2MWZMVgN98883MmTOn8PO6Wo0YoNS47wCgWLIDgGKtbXY8/PDD6d+/f/baa6988skn+eUvf5lDDjkkM2bMyKabbpokGTRoUMaPH59x48alSZMmGTBgQHr06JHHH388SbJs2bJ069YtLVu2zJQpU/Lmm2+md+/eqVu3bn7zm98k+WyRlW7duuW0007LrbfemkmTJuXkk09Oq1atCr9juu222zJ48OCMGDEinTt3zhVXXJHy8vLMmjUrzZs3X+n8p0yZkmOPPTbDhg3LEUcckdGjR6d79+6ZNm1a4fddF198cf7whz9k1KhRadu2bc4999yUl5dnxowZdrwCSpL7DgCKJTsA2JjWqFhy3XXXJUnGjh2bLbfcstq5t99+e93PCoAaQ3YAUKy1zY4DDjgglZWVqzxfteruBRdcsMoxm2++eUaPHr3a19ltt93y6KOPrnbMUUcdlaOOOmqV51e2WmTVasSrM2DAgGo7n3zVvPTSS0mSZs2aZZttttnIswFKgfsOAIolOwAo1tpmx4QJE6r9PHLkyDRv3jxTp07N/vvvn/feey833HBDRo8enYMOOihJctNNN6V9+/Z58skns88+++T+++/PjBkz8sADD6RFixbZfffdc+GFF+YXv/hFhg4dmnr16mXEiBFp27ZtLr300iSf7c772GOP5fLLLy8USy677LKccsophR1wR4wYkfHjx+fGG2/M2WefvdL5X3nllTn00ENz5plnJkkuvPDCTJw4MVdffXVGjBiRysrKXHHFFTnnnHPygx/8IEly8803p0WLFrnzzjtzzDHHrPFnBVBTuO8AoFiyA4CNqVYxg5dfJXd1xwCgiuwAoFiy4+vro48+SllZWY477rh06tQp7dq1q7YjC8D6IjsAKJbsAKBY6zo73nvvvSSfLXCSJFOnTs3HH3+crl27Fsa0a9cu22yzTZ544okkyRNPPJFdd9212s615eXlqaioyIsvvlgYs/w1qsZUXWPp0qWZOnVqtTG1atVK165dC2NW5ouuO3v27MybN6/amCZNmqRz586rvS5ATea+A4BiyQ4ANqY12rHklVdeyaxZs1JRUZF77723cLyioiJLlixZb5MD4Ovtvvvukx0AFEV2fL0tXbo0lZWV6dGjR5Lk9ttvz4IFC+xaAqxXsgOAYskOAIq1rrPj008/zcCBA7Pvvvtml112SZLMmzcv9erVS9OmTauNbdGiRebNm1cYs3yppOp81bnVjamoqMiiRYvy7rvvZtmyZSsdM3PmzFXOeVXXXf51l5/PysZ83pIlS6p9hhUVFat8fYCvG/cdABRLdgCwsa1RseTFF1/MnXfemXfffTfjxo0rHG/UqFGuv/769TY5AL7e7rrrLtkBQFFkR83QrFmzjT0FoISsi+wYOnRofvWrX1U79s1vfrPwparFixfnZz/7WcaMGZMlS5akvLw811xzTbUvTM2ZMyf9+vXLQw89lM022yx9+vTJsGHDUqfOv379Nnny5AwePDgvvvhi2rRpk3POOScnnHBCtdcdPnx4LrnkksybNy8dO3bMVVddlb333nu18x83blzOPffcvP7669lxxx3zu9/9LocffnjhfGVlZc4///xcf/31WbhwYfbdd99ce+212XHHHdf4MwKoSdx3AFCsdZ0d/fv3zwsvvJDHHntsXU3xa2nYsGEr3IsB1BTuOwAoluwAYGNbo2LJD37wg/zgBz/I008//YV/yAaAKtdcc01mzpwpOwBYY7IDgGKtq+zYeeed88ADDxR+Xr4QMmjQoIwfPz7jxo1LkyZNMmDAgPTo0SOPP/54kmTZsmXp1q1bWrZsmSlTpuTNN99M7969U7du3fzmN79JksyePTvdunXLaaedlltvvTWTJk3KySefnFatWhW2sb/tttsyePDgjBgxIp07d84VV1yR8vLyzJo1K82bN1/pvKdMmZJjjz02w4YNyxFHHJHRo0ene/fumTZtWmHl44svvjh/+MMfMmrUqLRt2zbnnntuysvLM2PGjDRo0GCtPjeAryP3HQAUa11mx4ABA3LPPffkkUceydZbb1043rJlyyxdujQLFy6stmvJW2+9lZYtWxbGPP3009Wu99ZbbxXOVf2z6tjyYxo3bpyGDRumdu3aqV279krHVF1jZVZ13eVft+pYq1atqo3ZfffdV3rNIUOGZPDgwYWfKyoq0qZNm1XOoRgvvfRSks8WQLGbLrAxuO8AoFiyA4CNbY2KJVXatWuXYcOGZcaMGdW21xo7duw6nxgANYPsAKBYsgOAYq2L7KhTp85Kv0T13nvv5YYbbsjo0aNz0EEHJUluuummtG/fPk8++WT22Wef3H///ZkxY0YeeOCBtGjRIrvvvnsuvPDC/OIXv8jQoUNTr169jBgxIm3bts2ll16aJGnfvn0ee+yxXH755YViyWWXXZZTTjklffv2TZKMGDEi48ePz4033pizzz57pfO+8sorc+ihh+bMM89Mklx44YWZOHFirr766owYMSKVlZW54oorcs455+QHP/hBkuTmm29OixYtcuedd+aYY45Z488IoCZx3wFAsdY2OyorK3P66afnjjvuyOTJk9O2bdtq5zt16pS6detm0qRJ6dmzZ5Jk1qxZmTNnTrp06ZIk6dKlS379619n/vz5hfL5xIkT07hx43To0KEw5t5776127YkTJxauUa9evXTq1CmTJk1K9+7dkySffvppJk2alAEDBqxy/l26dMmkSZMycODAlV63bdu2admyZSZNmlQoklRUVOSpp55Kv379VnrN+vXrp379+l/00RXlgw8+SFlZWY477rgkScOGDTNz5kzlEmCjcN8BQLFkBwAbU61iBvfq1SubbbZZnnrqqfTp0ydlZWXZdttt19fcAKgBZAcAxZIdABRrXWTHyy+/nNatW2f77bdPr169MmfOnCTJ1KlT8/HHH6dr166Fse3atcs222yTJ554IknyxBNPZNddd02LFi0KY8rLy1NRUZEXX3yxMGb5a1SNqbrG0qVLM3Xq1GpjatWqla5duxbGrMwXXXf27NmZN29etTFNmjRJ586dV3vdJUuWpKKiotoDoCZx3wFAsdY2O/r3759bbrklo0ePTqNGjTJv3rzMmzcvixYtSvLZ/08/6aSTMnjw4Dz00EOZOnVq+vbtmy5dumSfffZJkhxyyCHp0KFDjj/++Pz1r3/Nfffdl3POOSf9+/cvFDROO+20vPbaaznrrLMyc+bMXHPNNRk7dmwGDRpUmMvgwYNz/fXXZ9SoUXnppZfSr1+/fPjhh4WSe5L07t07Q4YMKfx8xhlnZMKECbn00kszc+bMDB06NM8880yhjFJWVpaBAwfmoosuyt13353nn38+vXv3TuvWrQsFlg1h8eLFqaysTI8ePdKjR48sWrQoCxYs2GCvD7A89x0AFEt2ALAxFVUsmTt3bk4//fQ0aNAg3bp1y5gxY/Lwww+vr7kBUAPIDgCKJTsAKNbaZkfnzp0zcuTITJgwIddee21mz56d/fbbL++//37mzZuXevXqpWnTptWe06JFi8ybNy9JMm/evGqlkqrzVedWN6aioqLwRadly5atdEzVNVZmVddd/nWXn8+aXnfYsGFp0qRJ4dGmTZtVjgX4OnLfAUCx1jY7rr322rz33ns54IAD0qpVq8LjtttuK4y5/PLLc8QRR6Rnz57Zf//907Jly9x+++2F87Vr184999yT2rVrp0uXLjnuuOPSu3fvXHDBBYUxbdu2zfjx4zNx4sR07Ngxl156af74xz8WdkpMkqOPPjq///3vc95552X33XfP9OnTM2HChGr3DXPmzMmbb75Z+Pnb3/52Ro8eneuuuy4dO3bMn/70p9x5553ZZZddCmPOOuusnH766Tn11FOz11575YMPPsiECRPSoEGDNf+g15FmzZqlWbNmG/x1AZbnvgOAYskOADamOkUNrvPZ8BYtWmTSpElp3bp1/vnPf66XiQFQM8gOAIolOwAo1tpmx2GHHVb499122y2dO3fOtttum7Fjx6Zhw4brfL5fB0OGDMngwYMLP1dUVCiXADWK+w4AirW22VFZWfmFYxo0aJDhw4dn+PDhqxyz7bbb5t57713tdQ444IA8++yzqx0zYMCAwm4jKzN58uQVjh111FE56qijVvmcsrKyXHDBBdWKLgClzH0HAMWSHQBsTEUVS375y1/mvffey6WXXpqf/vSnef/993PZZZetr7kBUAPIDgCKJTsAKNa6zo6mTZtmp512yiuvvJLvfe97Wbp0aRYuXFht15K33norLVu2TJK0bNkyTz/9dLVrvPXWW4VzVf+sOrb8mMaNG6dhw4apXbt2ateuvdIxVddYmVVdd/nXrTrWqlWramN23333VV63fv36qV+//irPA3zdue8AoFiyA4BiyQ4AiiU7ANiYiiqW/OAHP0jy2cqNK1uhBAA+T3YAUCzZAUCx1nV2fPDBB3n11Vdz/PHHp1OnTqlbt24mTZqUnj17JklmzZqVOXPmpEuXLkmSLl265Ne//nXmz5+f5s2bJ0kmTpyYxo0bp0OHDoUxn19VeOLEiYVr1KtXL506dcqkSZPSvXv3JMmnn36aSZMmrXYV4S5dumTSpEkZOHDgSq/btm3btGzZMpMmTSoUSSoqKvLUU0+lX79+a/dBAXyNue8AoFiyA4BiyQ4AiiU7ANiYiiqWvPrqq7n66qvz+uuvZ9myZYXjd9999zqfGAA1g+wAoFiyA4BirW12/PznP8+RRx6ZbbfdNnPnzs3555+f2rVr59hjj02TJk1y0kknZfDgwdl8883TuHHjnH766enSpUv22WefJMkhhxySDh065Pjjj8/FF1+cefPm5Zxzzkn//v0Lu36cdtppufrqq3PWWWflxBNPzIMPPpixY8dm/PjxhXkMHjw4ffr0yZ577pm99947V1xxRT788MP07du3MKZ3797ZaqutMmzYsCTJGWecke9+97u59NJL061bt4wZMybPPPNMrrvuuiRJWVlZBg4cmIsuuig77rhj2rZtm3PPPTetW7cuFFgASpH7DgCKJTsAKJbsAKBYsgOAjamoYskPf/jDDBgwIP/+7/+eWrVqra85AVCDyA4AiiU7ACjW2mbHP/7xjxx77LH55z//mS233DLf+c538uSTT2bLLbdMklx++eWpVatWevbsmSVLlqS8vDzXXHNN4fm1a9fOPffck379+qVLly7ZdNNN06dPn1xwwQWFMW3bts348eMzaNCgXHnlldl6663zxz/+MeXl5YUxRx99dN5+++2cd955mTdvXnbfffdMmDAhLVq0KIyZM2dOtff47W9/O6NHj84555yTX/7yl9lxxx1z5513ZpdddimMOeuss/Lhhx/m1FNPzcKFC/Od73wnEyZMSIMGDYr+rABqCvcdABRLdgBQLNkBQLFkBwAbU1HFkk022SSnnnrq+poLADWQ7ACgWLIDgGKtbXaMGTNmtecbNGiQ4cOHZ/jw4ascs+222+bee+9d7XUOOOCAPPvss6sdM2DAgAwYMGCV5ydPnrzCsaOOOipHHXXUKp9TVlaWCy64oFrRBaDUue8AoFiyA4BiyQ4AiiU7ANiYiiqWDBkyJL/4xS/StWvX1K9fv3B8//33X+cTA6BmkB0AFEt2AFAs2QFAsWQHAMWSHQAUS3YAUCzZAcDGVFSx5L777svkyZPzyiuvFLbZKisrE1oArJLsAKBYsuOrbc6cOVmwYEFeeumljT0VgALZAUCxZAcAxZIdABRLdgBQLNkBwMZUVLHkgQceyKxZs1JWVra+5gNADSM7ACiW7PjqmjNnTtq1a5dFixZt7KkAVCM7ACiW7ACgWLIDgGLJDgCKJTsA2JhqFTN47733zquvvrq+5gJADSQ7ACiW7PjqWrBgQRYtWpQePXrkwAMP3NjTASiQHQAUS3YAUCzZAUCxZAcAxZIdAGxMRe1Y8sILL2SXXXbJN7/5zdSvXz+VlZUpKyvL008/vb7mB8DXnOwAoFiy46uvWbNmG3sKANXIDgCKJTsAKJbsAKBYsgOAYskOADamooold9111/qaBwA1lOwAoFiyA4BiyQ4AiiU7ACiW7ACgWLIDgGLJDgA2pjUqlixZsiT169fPlltuub7nA0ANIzsAKJbsAKBYsgOAYskOAIolOwAoluwAoFiyA4CNaY2KJT179sw999yTnXfeOWVlZYXttar++dprr63veQLwNSU7ACiW7ACgWLIDgGLJDgCKJTsAKJbsAKBYsgOAjWmNiiX33HNPkmT27NnrdTIA1DyyA4BiyQ4AiiU7ACiW7ACgWLIDgGLJDgCKJTsA2JhqFTN47733XqNjAFBFdgBQLNkBQLFkBwDFkh0AFEt2AFAs2QFAsWQHABvTGu1YsmDBgrz11lv54IMP8tJLL6WysjJJUlFRkYqKivU6QQC+vl566SXZAUBRZAcAxZIdABRLdgBQLNkBQLFkBwDFkh0AbGxrVCwZP358Ro4cmTfeeCP9+/cvhFajRo3ym9/8Zr1OEICvrzPPPFN2AFAU2QFAsWQHAMWSHQAUS3YAUCzZAUCxZAcAG9saFUv69OmTPn365M4770z37t3X85QAqCnuueeePPjgg7IDgDUmOwAoluwAoFiyA4BiyQ4AiiU7ACiW7ABgY6tVzOAZM2bk/fffz7Jly3LUUUdlp512yp133rmepgZATSA7ACiW7KhZXnrppUybNi1z5szZ2FMBajDZAUCxZAcAxZIdABRrbbNj2LBh2WuvvdKoUaM0b9483bt3z6xZs6qNWbx4cfr3758tttgim222WXr27Jm33nqr2pg5c+akW7du2WSTTdK8efOceeaZ+eSTT6qNmTx5cvbYY4/Ur18/O+ywQ0aOHLnCfIYPH57tttsuDRo0SOfOnfP0009/4XsYN25c2rVrlwYNGmTXXXfNvffeW+18ZWVlzjvvvLRq1SoNGzZM165d8/LLL6/hJwRQ82yI7DjggANSVlZW7XHaaadVGyM7AEpTUcWScePGpVGjRrnnnnvSoEGDPPbYY/nVr361xs8XWgClZ22zA4DSIztqhg8++CBlZWU57rjj0qlTp7Rr1065BFhvZAcAxZIdABRLdgBQrLXNjocffjj9+/fPk08+mYkTJ+bjjz/OIYcckg8//LAwZtCgQfnzn/+ccePG5eGHH87cuXPTo0ePwvlly5alW7duWbp0aaZMmZJRo0Zl5MiROe+88wpjZs+enW7duuXAAw/M9OnTM3DgwJx88sm57777CmNuu+22DB48OOeff36mTZuWjh07pry8PPPnz1/l/KdMmZJjjz02J510Up599tl079493bt3zwsvvFAYc/HFF+cPf/hDRowYkaeeeiqbbrppysvLs3jx4jX+nABqkg2RHUlyyimn5M033yw8Lr744sI52QFQuooqlixatChJctddd+WYY45J8+bNU1lZucbPF1oApWdts8MqLAClZ22zg6+GxYsXp7KyMj169EiPHj2yaNGiLFiwYGNPC6ihZAcAxZIdABRLdgBQrLXNjgkTJuSEE07IzjvvnI4dO2bkyJGZM2dOpk6dmiR57733csMNN+Syyy7LQQcdlE6dOuWmm27KlClT8uSTTyZJ7r///syYMSO33HJLdt999xx22GG58MILM3z48CxdujRJMmLEiLRt2zaXXnpp2rdvnwEDBuRHP/pRLr/88sJcLrvsspxyyinp27dvOnTokBEjRmSTTTbJjTfeuMr5X3nllTn00ENz5plnpn379rnwwguzxx575Oqrr07y2d/Jr7jiipxzzjn5wQ9+kN122y0333xz5s6da1cwoGSt7+yosskmm6Rly5aFR+PGjQvnZAdA6SqqWHLkkUdm2223zdSpU3PIIYfk7bffTv369df4+UILoPSsbXZYhQWg9KxtdvDV0qxZszRr1mxjTwOo4WQHAMVa2+x45JFHcuSRR6Z169YpKytb4W8Aa7KQyDvvvJNevXqlcePGadq0aU466aR88MEH1cY899xz2W+//dKgQYO0adOm2kJcVb5oUZOVWV8LrADUZO47ACjWus6O9957L0my+eabJ0mmTp2ajz/+OF27di2MadeuXbbZZps88cQTSZInnngiu+66a1q0aFEYU15enoqKirz44ouFMctfo2pM1TWWLl2aqVOnVhtTq1atdO3atTBmZb7ourNnz868efOqjWnSpEk6d+68yusuWbIkFRUV1R4ANcn6zo4qt956a5o1a5ZddtklQ4YMyUcffVQ4JzsASldRxZJLLrkkzz77bKZNm5a6detmk002yV133fWlX1xoCS2g5lvb7LAKC0DpWdf3HSszdOjQlJWVVXu0a9eucH5D7ob1eevri2MANdmGyA4Aapa1zY4PP/wwHTt2zPDhw1d6fk0WEunVq1defPHFTJw4Mffcc08eeeSRnHrqqYXzFRUVOeSQQwpfJrjkkksydOjQXHfddYUxa7KoyeetrwVWAGo69x0AFGtdZsenn36agQMHZt99980uu+ySJJk3b17q1auXpk2bVhvbokWLzJs3rzBm+e9YVZ2vOre6MRUVFYXdyJctW7bSMVXXWJlVXXf5111+Pmty3WHDhqVJkyaFR5s2bVb5+gBfR+s7O5Lkxz/+cW655ZY89NBDGTJkSP77v/87xx13XOG87AAoXUUVSxYuXJjf/va3Of7445Mk//jHP/Loo49+qRcWWp8RWkBNty6zI7EKS6KUCNR86zo7VmXnnXfOm2++WXg89thjhXMbajesz1tfXxwDqOk2VHYAUHOsbXYcdthhueiii/LDH/5whXNrspDISy+9lAkTJuSPf/xjOnfunO985zu56qqrMmbMmMydOzfJZ4twLV26NDfeeGN23nnnHHPMMfnpT3+ayy67rPBaX7SoycqsrwVWAGo69x0AFGtdZkf//v3zwgsvZMyYMetyil87Q4YMyXvvvVd4vPHGGxt7SgDr1IbIjlNPPTXl5eXZdddd06tXr9x8882544478uqrr671/L+KZAfAmiuqWNKnT5+0b9++8IWltm3b5sILL/xSLyy0PiO0gJpuXWaHVVg+o5QI1HTrMjtWp06dOmnZsmXh0axZsyQbdjesz1tfXxwDqOk2VHYAUHOsz+xYk4VEnnjiiTRt2jR77rlnYUzXrl1Tq1atPPXUU4Ux+++/f+rVq1cYU15enlmzZuXdd98tjFndoiYrs74WWLEYClDTue8AoFjrKjsGDBiQe+65Jw899FC23nrrwvGWLVtm6dKlWbhwYbXxb731Vlq2bFkY8/kd2at+/qIxjRs3TsOGDdOsWbPUrl17pWOqrrEyq7ru8q+7/HzW5Lr169dP48aNqz0AapL1nR0r07lz5yTJK6+8kkR2AJSyooolc+fOTd++fVO7du0kSb169VKrVlGXSCK0lie0gJpuXWVHYhWWKuuzlPjSSy9l2rRpmTNnzjq7JkCx1mV2rM7LL7+c1q1bZ/vtt0+vXr0K/+3bULthrcz6+uKYL3gBNd2Gyg4Aao71mR1rspDIvHnz0rx582rn69Spk80333ydLJbyZRZCWdsFViyGAtR07jsAKNbaZkdlZWUGDBiQO+64Iw8++GDatm1b7XynTp1St27dTJo0qXBs1qxZmTNnTrp06ZIk6dKlS55//vnMnz+/MGbixIlp3LhxOnToUBiz/DWqxlRdo169eunUqVO1MZ9++mkmTZpUGLMyX3Tdtm3bpmXLltXGVFRU5KmnnlrtdQFqsvWdHSszffr0JEmrVq2SyA6AUlbUb7o23XTTLFy4MGVlZUmSadOmpVGjRmv8fKEFUHrWNjuqWIXlX9ZHKfGDDz5IWVlZjjvuuHTq1Cnt2rVTLgE2mnWVHavTuXPnjBw5MhMmTMi1116b2bNnZ7/99sv777+/wXbDWpn19cUxX/ACaroNkR0A1CyyY92zQztQ061tdjzyyCM58sgj07p165SVleXOO++sdr6ysjLnnXdeWrVqlYYNG6Zr1655+eWXq41555130qtXrzRu3DhNmzbNSSedlA8++KDamOeeey777bdfGjRokDZt2uTiiy9eYS7jxo1Lu3bt0qBBg+y666659957v3D+kydPzh577JH69etnhx12yMiRI1cYM3z48Gy33XZp0KBBOnfunKeffvqLPxiAGmxts6N///655ZZbMnr06DRq1Cjz5s3LvHnzCn9jaNKkSU466aQMHjw4Dz30UKZOnZq+ffumS5cu2WeffZIkhxxySDp06JDjjz8+f/3rX3PfffflnHPOSf/+/VO/fv0kyWmnnZbXXnstZ511VmbOnJlrrrkmY8eOzaBBgwpzGTx4cK6//vqMGjUqL730Uvr165cPP/wwffv2LYzp3bt3hgwZUvj5jDPOyIQJE3LppZdm5syZGTp0aJ555pkMGDAgSVJWVpaBAwfmoosuyt13353nn38+vXv3TuvWrdO9e/cv96EDfM2t7+x49dVXc+GFF2bq1Kl5/fXXc/fdd6d3797Zf//9s9tuuyWRHQClrE4xgy+99NJ07949s2fPzsEHH5w33ngjt9122xo/v3///hk9enTuuuuuQmgln93oNGzYMK+++mpGjx6dww8/PFtssUWee+65DBo0aJWhdfHFF2fevHkrDa2rr746Z511Vk488cQ8+OCDGTt2bMaPH1+Yy+DBg9OnT5/sueee2XvvvXPFFVesNLS22mqrDBs2LMlnofXd7343l156abp165YxY8bkmWeeyXXXXZekemjtuOOOadu2bc4991yhBZS0tc2OysrKnH766bnjjjsyefLk1a7C0rNnzyQrX4Xl17/+debPn19YCXJlpcTP/+FkVaXEqv+mV5USq25eVqaqlDhw4MCVXnf5UuLuu++e5F+lxH79+q3x57S2Fi9enMrKyvTo0SNJcvvtt2fBggXZZpttNtgcAKqsbXasicMOO6zw77vttls6d+6cbbfdNmPHjk3Dhg3X6Wt9FQwZMiSDBw8u/FxRUaFcAtQoGyI7AKhZ1md2LL+QSNWiWVU/V/3+p2XLltUW0EqSTz75JO+88846WSzlyyyEUrXASu3atb/UAiv169cv/J0GoCZa2+z48MMP07Fjx5x44omF38Uv7+KLL84f/vCHjBo1qvB35vLy8syYMSMNGjRIkvTq1StvvvlmJk6cmI8//jh9+/bNqaeemtGjRyf57Hc+hxxySLp27ZoRI0bk+eefz4knnpimTZvm1FNPTZJMmTIlxx57bIYNG5Yjjjgio0ePTvfu3TNt2rTssssuK5377Nmz061bt5x22mm59dZbM2nSpJx88slp1apVysvLkyS33XZbBg8enBEjRqRz58654oorCjvx/n/s3XtcVHX+x/H3gHLxAl5QwFKjzQTviUmYlSaFRW0urpuuJZmXhy60KpuWrXlt17YytVVjuxj6M9d0t6zUxRAv1YqaqOUFXTWKWsVbImEIKuf3hw/OMgnIEYZhhtfz8TiPYM53zny+E573fM+Z7zk/v0sXANQVVc2O119/XZLUp08fu8ffeecdPfHEE5KkuXPnysPDQwMHDlRhYaGio6O1aNEis62np6fWrFmjsWPHKjIyUg0bNlRcXJxmzpxptgkJCdHatWs1YcIEzZ8/XzfeeKPeeustcx8vSY8++qhOnTqlqVOnKicnR926dVNKSordhbCys7Ptrqrfq1cvLV++XFOmTNFzzz2ndu3aafXq1XZ5M2nSJJ0/f16jR49Wbm6uevfurZSUFDP7AKCucXR2eHl5acOGDeb3ZVu3bq2BAwdqypQpZluyAwDqLksTS8LDw7VhwwYdOnRIxcXFCg0NVf369Sv9fEILAOqeqmbHtSYllr4KS7NmzeTn56ennnqq3KuwMCmxYgEBATX+mgDwc1XNjuvRpEkT3XrrrTpy5Ijuu+8+825Ype9a8vM7Tv38iotW74ZVFkd9cYwveAFwd87IDgCAa3NkdlTmQiKRkZHKzc1VRkaGwsPDJUkbN25UcXGxIiIizDZ//OMfdfHiRbO21NRUtW/fXk2bNjXbVHRRk7I46gIrAODuqpodDzzwgN3FTkozDEPz5s3TlClT9Mgjj0iSli5dqsDAQK1evVqDBw9WZmamUlJS9MUXX6hHjx6SpL/+9a968MEH9corr6hVq1Z69913VVRUpMWLF8vLy0sdO3bUnj179Oqrr5oTS+bPn6/+/ftr4sSJkqRZs2YpNTVVCxYsUFJSUpn1JSUlKSQkRHPmzJEkhYWF6fPPP9fcuXPNc/CvvvqqRo0aZZ4zSUpK0tq1a7V48WI9++yzlX6fAMCdVDU7DMO4ZhsfHx8tXLhQCxcuLLdN27Ztr3l3qj59+mj37t0VtklISKhwTLB58+arHhs0aJAGDRpU7nNsNptmzpxp970vAKjLHJ0drVu31pYtW665HbIDAOomSxNLJKlevXrq2LHjdb0YoQUAdVNVsoOrsABA3VSV7Lge+fn5Onr0qB5//PEauxtWWRz1xTEAqAtqOjsAAK6vKtmRn5+vI0eOmL9nZWVpz549atasmdq0aXPNC4mEhYWpf//+GjVqlJKSknTx4kUlJCRo8ODBatWqlSTpt7/9rWbMmKERI0bomWee0b59+zR//nzNnTvXfN1rXdREunIHw//+979aunSppOq7wIqzZGZmKiAggDvtAnAKR407srKylJOTo6ioKPMxf39/RUREKD09XYMHD1Z6erqaNGliTiqRpKioKHl4eGj79u361a9+pfT0dN19993y8vIy20RHR+svf/mLzp49q6ZNmyo9Pd3uzrYlbVavXl1ufenp6Xa1lTyn5PhUUVGRMjIyNHnyZHO9h4eHoqKilJ6eXu52CwsLVVhYaP6el5dXblsAcFUcswIAWEV2AACcxfLEEgAAahJXYQEAOMLTTz+thx9+WG3bttWxY8c0bdo0eXp6asiQITV6N6wFCxbogw8+UFpamqTq++IYAAAAAMfauXOn+vbta/5e8gXduLg4JScnV+pCIu+++64SEhLUr18/86Ipr732mrne399fn3zyieLj4xUeHq6AgABNnTrVvOK8VLmLmhw/flzZ2dnm79V1gZWalp+fL5vNpscee0y+vr46ePAgk0sAuI2Su7X/fD8bGBhorsvJyTEvcFKiXr16atasmV2bkJCQq7ZRsq5p06bKycmp8HXKq6+s5+Tl5amgoEBnz57V5cuXy2xz8ODBcrc7e/ZszZgxo9z1AAAAAAAAqDlMLAEAAABQ53z//fcaMmSIzpw5oxYtWqh3797atm2bWrRoIanm7oZ1+vRpHT161Py9ur44BgAAAMCx+vTpU+EFUSpzIZFmzZpp+fLlFb5Oly5d9Nlnn1XY5loXNUlOTr7qseq4wEpNu3DhggzD0N13361PP/1Up0+fZmIJALi4yZMn2909JS8vT61bt3ZiRQAAAAAAAHVXpSaWzJ8/X+PGjZMk7dq1S927d3doUQAA90J2AACscnR2rFixosL1NXU3rOnTp2v69Ol2j1XHF8dqq8zMTElSQEAAXwADUO0YdwAArCI7XJO/v7+zSwBQhzkqO4KCgiRJJ06cUHBwsPn4iRMn1K1bN7PNyZMn7Z536dIl/fDDD+bzg4KCdOLECbs2Jb9fq03J+vLqK+s5fn5+8vX1laenpzw9PS1v19vb27z7LwC4K8YdAACryA4AgLN4VKbRkiVLzJ9HjhzpsGIAAO6J7AAAWEV2uJf8/HzZbDY99thjCg8PV2hoqLKzs51dFgA3Q3YAAKwiOwAAVjkqO0JCQhQUFKS0tDTzsby8PG3fvl2RkZGSpMjISOXm5iojI8Nss3HjRhUXFysiIsJs8+mnn+rixYtmm9TUVLVv315NmzY125R+nZI2Ja9Tlms9x8vLS+Hh4XZtiouLlZaWVuF2AaAuYNwBALCK7AAAOEulJpYAAAAAAHC9Lly4IMMwFBsbq9jYWBUUFOj06dPOLgsAAACAC8vMzNSuXbuYtA7AZeTn52vPnj3as2ePJCkrK0t79uxRdna2bDabxo8frxdeeEEfffSR9u7dq2HDhqlVq1YaMGCAJCksLEz9+/fXqFGjtGPHDv373/9WQkKCBg8erFatWkmSfvvb38rLy0sjRozQ/v379d5772n+/PlKTEw06xg3bpxSUlI0Z84cHTx4UNOnT9fOnTuVkJBgtpk8ebKGDRtm/j5mzBh9/fXXmjRpkg4ePKhFixZp5cqVmjBhgtkmMTFRb775ppYsWaLMzEyNHTtW58+f1/Dhwx34rgIAAAAAAKC61KtMo1OnTmnRokUyDMP8ubTf/e53DikOAODa3nzzTfn4+JAdAIBKIzvcW0BAgLNLAOCGyA4AgFVkh2v76aefzDsiSpKvr68OHjyoNm3aOLkyAO6sOrJj586d6tu3r/l7yWSPuLg4JScna9KkSTp//rxGjx6t3Nxc9e7dWykpKfLx8TGf8+677yohIUH9+vWTh4eHBg4cqNdee81c7+/vr08++UTx8fEKDw9XQECApk6dqtGjR5ttevXqpeXLl2vKlCl67rnn1K5dO61evVqdOnUy2xw/ftxu4l5ISIjWrl2rCRMmaP78+brxxhv11ltvKTo62mzz6KOP6tSpU5o6dapycnLUrVs3paSkKDAwsFLvDwC4G8YdAACryA4AgLNVamLJyJEjderUqat+BgCgImfOnJG3tzfZAQCoNLIDAGAV2QEAsIrscG1FRUXmHREl6f3339fp06eZWALAoaojO/r06SPDMMpdb7PZNHPmTM2cObPcNs2aNdPy5csrfJ0uXbros88+q7DNoEGDNGjQoHLXJycnX/VYnz59tHv37gq3m5CQYHfnEwCoyxh3AACsIjsAAM5WqYkl06ZNc3QdAAA39Oyzz8rPz8/ZZQAAXAjZAQCwiuwAAFhFdrgH7ogIoCaRHQAAq8gO15OZmSnpyliDiesAnIHsAAA4W6UmllR0VRRJmjp1arUUAwBwL3/5y1/k7e1d5jqyAwBQFrIDAGAV2QEAsIrsAABYRXYAAKwiO1xHfn6+bDabHnvsMUmSr6+vDh48yOQSADWO7AAAOJtHZRrNnDlT77//vqQrs7KbN29utwAAUJaPP/5YEtkBAKg8sqPuyMzM1K5du5Sdne3sUgC4OLIDAGAV2QEAsIrsAABYRXa4jgsXLsgwDMXGxio2NlYFBQU6ffq0s8sCUAeRHQAAZ6vUHUu+//57/eMf/9AHH3wgLy8vDRo0SL/61a/UtGlTR9cHAHBhw4YN07/+9S+yAwBQaWSH++PKXwCqG9kBALCK7AAAWEV2AACsIjtcT0BAgLNLAFDHkR0AAGer1B1LgoKClJCQoLS0NC1evFjnzp1TWFiYlixZ4uj6AAAubPTo0WQHAMASssP9lXXlr88++0zp6enatWsXdzEBYBnZAQCwiuwAAFhFdri2zMxMjjcBqHFkBwDAKrIDAOBslbpjiSQZhqEtW7bovffe044dOzRkyBDdeeedjqwNAODiDMPQ5s2byQ4AQKWRHXVHQECA3d1LbDabDMOQxF1MAFhDdgAArCI7AABWkR2uqfSxJ443AahpZAcAwCqyAwDgbJWaWJKQkKBt27bprrvu0rBhw/T66687ui4AgBvo06eP+vTpQ3YAACqN7KhbSu5ectttt2n37t2KjY2VJL3//vs6ffo0J/oBVArZAQCwiuwAAFhFdrimkmNPd999tz799FOONwGoUWQHAMAqsgMA4GyVmliyaNEiNWvWTN9++62WLVsmm80m6coMSZvNppMnTzq0SACAa8rOztayZcvIDgBApZEddVOjRo0kXbmLSYnMzEzzMU74A6gI2QEAsIrsAABYRXa4Nn9/f2eXAKAOIjsAAFaRHQAAZ6vUxJLi4mJH1wEAcENZWVny8/NzdhkAABdCdiA/P182m02PPfaYJMnX11cHDx5kcgmAcpEdAACryA4AgFVkBwDAKrIDAGAV2eF6uFgiAHdTqYklFy5cUFJSko4cOaIuXbroySefVL16lXoqAKAOW7Rokb7//nuyAwBQaWQHLly4IMMwFBsbK0l6//33dfr0aQ7EASgX2QEAsIrsAABYRXYAAKwiOwAAVpEdroOLJQJwVx6VaRQXF6edO3eqc+fOWrdunZ5++mlH1wUAcAO7d+8mOwAAlpAdKBEQEKCAgABJV670smvXLmVnZzu5KgC1EdkBALCK7AAAWEV2AACsIjsAAFaRHa6j9MUSY2NjVVBQoNOnTzu7LACoskpNaTxw4ID27t0rSRoxYoR69uzp0KIAAO7hzTfflJ+fH9kBAKg0sgOlcaUXAJVBdgAArCI7AABWkR0AAKvIDgCAVWSH6ym5UCIAuItK3bGkfv365s/cXgsAYBXZAQCwiuyAxJVeAFhDdgAArCI7AABWkR0AAKvIDgCAVWQHAMBZKpVAX331lVq2bClJMgxDubm5atmypQzDkM1m08mTJx1aJK5PZmampCuzIrmiLwBn+MUvfiGbzUZ2AAAqjexAWUpf6SUzM5MxDgA7ZAcAwCqyAwBgFdkBALCK7AAAWEV2AACcrVITSy5duuToOlCN8vPzZbPZ9Nhjj0mSfH19dfDgQb54BaDGHT16VH5+fs4uAwDgQsgOlKf0OIcxDoDSyA4AgFVkh/spudBWYWGhvL29JXHRLQDVi+wAAFhFdgAArCI7AADOxj2z3NCFCxdkGIZiY2MlSe+//75Onz7NCRQAAAAALqtknHP33Xfr008/ZYwDAAAA4KoLbZVc1VPiolsAAAAAAAAAAFjh4ewC4DgBAQEKCAhwdhkAAAAAUG38/f2dXQIAAACAWqL0hbb69u1r/hwbG6uCggKdPn3a2SUCAAAAAAAAAOASuGMJAAAAAAAAAAAAXFbpi2xxwS0AAAAAAAAAAKxjYgkAAAAAwOVkZmZKuvKlsTZt2ji5GgAAAAAAAAAAAAAAAMB1MbEEAACUKTMzky/rAgBqnZ9++kk2m02PPfaYJMnb21v//Oc/FRwcTG4BAAAAAAAAAAAAAAAA14GJJQAAwE5+fr75hV1fX18dPHiQL+kCAGqNoqIiGYah2NhY/fTTT1q/fr0eeughSSK3AAAAAAAAUC7ugAsAAAAAAFA+D2cXAAAAapcLFy7IMAzdfffdKigo0OnTp51dEgAAVwkICFCDBg3MSSaxsbEqKCjQZ599pl27dik7O9vZJQIAAAAAAKAWKH0H3PDwcIWGhnLsCABQoczMTLICAAAAdQ53LAEAAGXy9/d3dgkAAFRKQECA3R23JO5eAgAAAAAAgCtK3wFXkt5//32dPn2a40YAgKuUPtfAeQYAAADUNUwsqSMyMzO5pS8AAAAAt1Vyx63SXxD47LPPFBYWxlgIAAAAqKMyMzMlSYWFhfL29mZsAAB1XEBAgLNLAADUciXnGu6++259+umnTEQEAABAncLEEjfHTHoAAAAAdUlZdy/x9vbWP//5T3Xu3JnxEAAAAFAH/HxMYLPZZBgG50kAAJZlZ2fr9OnTkv43UfHnPzNxEQDcj7+/v7NLAAC4GC7+DsAdMLHEzTGTHgBQVSVXdmTwAwBwFaXvXvLTTz9p/fr1euihh8wJJsHBwZz8BwAAANxY6THB2bNntWnTJs6TAADs/PyuVpL9MaLs7Gzt3btXv/71r3XhwgVJ/5uo+POfyzrmxCQUAHAP18oLAAC4+DsAd+Lh7AKcbeHChbrpppvk4+OjiIgI7dixo8L2q1atUmhoqHx8fNS5c2etW7fObr1hGJo6daqCg4Pl6+urqKgoHT582JFdqBRm0gNA9akr2fHTTz+ZA5/w8HCFhoYqOzvb2WUBgEuqK9lR2wQEBKhBgwYyDEM9e/ZUUVGRHnroIYWHh+vOO+9UeHi4wsPDdeutt2rt2rXatWuX0tPTtWvXLu3atYvcA+BUZAcAwCqy42oBAQFq2rSpJM6TAEBZ6mJ2lP7SV3nHiNauXav27dvroYce0oULFxQbG6u+ffuakxZL/9y/f/8yjzmV3u61jkNxPAqAK6kr2fHzc+WVOadQ8jP7cgCw5+7ZUfri7wUFBeYdDwHAFdXpiSXvvfeeEhMTNW3aNO3atUtdu3ZVdHS0Tp48WWb7rVu3asiQIRoxYoR2796tAQMGaMCAAdq3b5/Z5qWXXtJrr72mpKQkbd++XQ0bNlR0dLR5FRNny8zMZBADAFVQl7KjqKjIPDESGxurgoICffbZZ+QIAFhUl7KjNvP29rZ08r/0yaGyTgxx0h+AI5EdAACryI7KKzlPwud5AHVdXc2O0ne1Ku8YUcmEkttuu02S/UTFn/9cclGT0tu77bbbrnsSyrW+rMyEFADOVJeyo/S58sqeUyj52cq+nH04AHdXl7Kj5KImfEcXgCur5+wCnOnVV1/VqFGjNHz4cElSUlKS1q5dq8WLF+vZZ5+9qv38+fPVv39/TZw4UZI0a9YspaamasGCBUpKSpJhGJo3b56mTJmiRx55RJK0dOlSBQYGavXq1Ro8eHDNde5nSs+kl8q+Ha/E7RoB4FrqUnaUCAgIsLuCl0SOAIAVdTE7arOAgAC7n0+fPm2eEDp79qw2bdqk2NhY/fTTT1q/fr0eeugh2Ww2GYYhSeX+XFY2ls7Ia/1c3nqyFaib3D07MjMzJbGPA4Dq5O7ZUR1+fp7kWp/npbI/r5fOr+zsbPMqlOQaAFdT17OjMseIGjVqdF3bK3leZV7jtttu0+7du686HiWVfxyq5GcrWVb658ocsyLXAJSlLmZHZc8plPzcs2dPffHFF5Xel0v/24c3a9bsus4psM8GUJvVpeyo6Du67KsBuIo6O7GkqKhIGRkZmjx5svmYh4eHoqKilJ6eXuZz0tPTlZiYaPdYdHS0Vq9eLUnKyspSTk6OoqKizPX+/v6KiIhQenp6maFVWFiowsJC8/dz585JkvLy8iz1Jz8/X5J0/Phx5ebmXvXzqVOnZBiGevXqpcLCQmVkZJiDmNK8vb31f//3fwoMDJSHh4eKi4vN/0q65s9W2rrK82pzbfSJ96ImXiMoKEhBQUGyomQfVnIgxF3Utewo2W7JY1ZyJDg4uFb9u6jp59Xm2ngv6BPZUbPqenZU9mcrz3PUa1y8eFGXLl0yfz5//rwMw9DNN9+sr7/+Wr169VJ+fr6++uqrq36uKBurqqwxmuQa+5brfV5tro0+kR01wZ2zo6CgQJLsTqpYHT+U/rm2/btwlefV5trok2vUVlveC7Ljf9w5O6pzTFD6PElVPs+X5JckPf7442afazLXavp5tbk2+uQatdWW94Ls+B+yo3LHiGriONTly5fNx0qOR1V0HKrk59LHrBxxbIrvDbhWbbwXZEdNIDsqPqdQ8nPJnbEqsy+vrn34tc4jlP7ZFf8d1sXn1eba6BPZYUVdy46KvqNbG8751uZ/T/SJ98LVaqvuPtWq7DDqqP/+97+GJGPr1q12j0+cONHo2bNnmc+pX7++sXz5crvHFi5caLRs2dIwDMP497//bUgyjh07Ztdm0KBBxm9+85sytzlt2jRDEgsLC4tbLt9999317qZrJbKDhYWFxfEL2UF2sLCwsFhdyA6yg4WFhcXqQnaQHSwsLCxWF7KD7GBhYWGxupAdZAcLCwuL1YXsIDtYWFhYrC7VnR119o4ltcXkyZPtZlgWFxfrhx9+UPPmzWWz2Sq9nby8PLVu3Vrfffed/Pz8HFGqQ7l6/ZLr94H6ncvV65fs+9C4cWP9+OOPatWqlbPLcktkR9XUxX7XxT5LdbPfrtxnwzDIDgciOxyH96RsvC9X4z0pW1XeF7LDsciO8rljnyT37Jc79klyz37VVJ/IDsciO66Nvrkmd+6b5N79q46+kR2ORXZcQf3O5+p9oH7n+nn9ZIdjkR3Xh/66N/rr+sgOxyI7rs1d++au/ZLom6uqzr45Kjvq7MSSgIAAeXp66sSJE3aPnzhxotzbyQQFBVXYvuS/J06cUHBwsF2bbt26lblNb29veXt72z3WpEkTK12x4+fn59L/kFy9fsn1+0D9zuXq9Uv/64O/v7+zS6l2ZId7qYv9rot9lupmv121z2THFWSHa+I9KRvvy9V4T8p2ve8L2XEF2eEc7tgnyT375Y59ktyzXzXRJ7LjCrLDueiba3Lnvknu3b+q9o3suILscDzqdz5X7wP1O1fp+smOK8iO2of+ujf669rIjivIDudy1765a78k+uaqqqtvjsgOj2rfoovw8vJSeHi40tLSzMeKi4uVlpamyMjIMp8TGRlp116SUlNTzfYhISEKCgqya5OXl6ft27eXu00AgOsgOwAAVpEdAACryA4AgFVkBwDAKrIDAGAV2QEAsIrsAADXU2fvWCJJiYmJiouLU48ePdSzZ0/NmzdP58+f1/DhwyVJw4YN0w033KDZs2dLksaNG6d77rlHc+bMUUxMjFasWKGdO3fqjTfekCTZbDaNHz9eL7zwgtq1a6eQkBA9//zzatWqlQYMGOCsbgIAqhHZAQCwiuwAAFhFdgAArCI7AABWkR0AAKvIDgCAVWQHALiWOj2x5NFHH9WpU6c0depU5eTkqFu3bkpJSVFgYKAkKTs7Wx4e/7upS69evbR8+XJNmTJFzz33nNq1a6fVq1erU6dOZptJkybp/PnzGj16tHJzc9W7d2+lpKTIx8fHoX3x9vbWtGnTrrpll6tw9fol1+8D9TuXq9cvuUcfKoPscH11sd91sc9S3ex3XeyzKyA73BvvSdl4X67Ge1I23peykR21mzv2SXLPfrljnyT37Jc79qmmkR2ugb65Jnfum+Te/XPnvlUHsqP2oH7nc/U+UL9zuXr9VpAdrov+ujf6i9qM7HAN7to3d+2XRN9clSv0zWYYhuHsIgAAAAAAAAAAAAAAAAAAAAAAAFDzPK7dBAAAAAAAAAAAAAAAAAAAAAAAAO6IiSUAAAAAAAAAAAAAAAAAAAAAAAB1FBNLAAAAAAAAAAAAAAAAAAAAAAAA6igmlgAAAAAAAAAAAAAAAAAAAAAAANRRTCxxAwsXLtRNN90kHx8fRUREaMeOHc4uqVzTp0+XzWazW0JDQ831Fy5cUHx8vJo3b65GjRpp4MCBOnHihNPq/fTTT/Xwww+rVatWstlsWr16td16wzA0depUBQcHy9fXV1FRUTp8+LBdmx9++EFDhw6Vn5+fmjRpohEjRig/P79W1P/EE09c9f+jf//+tab+2bNn6/bbb1fjxo3VsmVLDRgwQIcOHbJrU5m/mezsbMXExKhBgwZq2bKlJk6cqEuXLtWK+vv06XPV/4MxY8bUivol6fXXX1eXLl3k5+cnPz8/RUZG6l//+pe5vja//6iYK2VHZbj6/vp6uPo+8nqxX5JefPFF2Ww2jR8/3nysLvQbzudu2WGVq41lHKEu5m1luPq4yxHq6ucUlM1V8qM69vO14W+2pvbVX331le666y75+PiodevWeumll5zWp+raz9Zkn2pyP7l582Z1795d3t7euuWWW5ScnOzUflXXsbCa7BdqnqtkR3ncbezgzuMAd/0s7+6fx93h3AuqX23MDnf7t+iqx6X/+9//6rHHHlPz5s3l6+urzp07a+fOneb62pxjly9f1vPPP6+QkBD5+vrqF7/4hWbNmiXDMGpl/a4+Hq2o/osXL+qZZ55R586d1bBhQ7Vq1UrDhg3TsWPHak39sK42ZodV7nI8qzyuvl+xyh2PgZXHXY+Nwf25Wna46zEddxtrlVZXvhPlquPL8rjdZzIDLm3FihWGl5eXsXjxYmP//v3GqFGjjCZNmhgnTpxwdmllmjZtmtGxY0fj+PHj5nLq1Clz/ZgxY4zWrVsbaWlpxs6dO4077rjD6NWrl9PqXbdunfHHP/7ReP/99w1JxgcffGC3/sUXXzT8/f2N1atXG19++aXxy1/+0ggJCTEKCgrMNv379ze6du1qbNu2zfjss8+MW265xRgyZEitqD8uLs7o37+/3f+PH374wa6NM+uPjo423nnnHWPfvn3Gnj17jAcffNBo06aNkZ+fb7a51t/MpUuXjE6dOhlRUVHG7t27jXXr1hkBAQHG5MmTa0X999xzjzFq1Ci7/wfnzp2rFfUbhmF89NFHxtq1a43//Oc/xqFDh4znnnvOqF+/vrFv3z7DMGr3+4/yuVp2VIar76+vh6vvI69XXd8v7dixw7jpppuMLl26GOPGjTMfd/d+w/ncMTuscrWxjCPUxbytDFcfdzlCXf2cgqu5Un5UdT9fW/5ma2Jffe7cOSMwMNAYOnSosW/fPuPvf/+74evra/ztb39zSp+qYz9b032qqf3k119/bTRo0MBITEw0Dhw4YPz1r381PD09jZSUFKf1qzqOhdV0v1CzXCk7yuNuYwd3Hge462d5d/887g7nXlC9amt2uNO/RVc9Lv3DDz8Ybdu2NZ544glj+/btxtdff22sX7/eOHLkiNmmNufYn/70J6N58+bGmjVrjKysLGPVqlVGo0aNjPnz59fK+l19PFpR/bm5uUZUVJTx3nvvGQcPHjTS09ONnj17GuHh4XbbqG1jT5SvtmaHVe5yPKs8rr5fscodj4GVx12PjcG9uWJ2uOsxHXcaa/1cXfhOlKuOLyvibp/JmFji4nr27GnEx8ebv1++fNlo1aqVMXv2bCdWVb5p06YZXbt2LXNdbm6uUb9+fWPVqlXmY5mZmYYkIz09vYYqLN/Pw7W4uNgICgoyXn75ZfOx3Nxcw9vb2/j73/9uGIZhHDhwwJBkfPHFF2abf/3rX4bNZjP++9//1ljthnF1/YZxZdDxyCOPlPuc2lS/YRjGyZMnDUnGli1bDMOo3N/MunXrDA8PDyMnJ8ds8/rrrxt+fn5GYWGhU+s3jCsnN0oH5M/VpvpLNG3a1Hjrrbdc7v3H/7hadljl6vvr6+Xq+8iqqCv7pR9//NFo166dkZqaapcf7t5v1A7unh2V4cpjGUeoq3l7Le4w7nKEuvw5pa5zpfyo6n6+Nv7NOmpfvWjRIqNp06Z2/XrmmWeM9u3bO7hHjtvPOrNPhuG4/eSkSZOMjh072r3Wo48+akRHRzu6S4ZhOO5YmLP7BcdypewojzuPHdx5HODOn+Xd/fO4u5x7wfVzlexw1X+Lrnxc+plnnjF69+5d7vranmMxMTHGk08+afdYbGysMXTo0Fpfv6uPR8v6XPBzO3bsMCQZ3377ba2rH9fmKtlxLe54PKs8rr5fscpdj4GVx12PjcG9uHp2uPMxHVcda1WWO30nypXHlxVxt89kHtd3nxPUBkVFRcrIyFBUVJT5mIeHh6KiopSenu7Eyip2+PBhtWrVSjfffLOGDh2q7OxsSVJGRoYuXrxo15/Q0FC1adOmVvYnKytLOTk5dvX6+/srIiLCrDc9PV1NmjRRjx49zDZRUVHy8PDQ9u3ba7zmsmzevFktW7ZU+/btNXbsWJ05c8ZcV9vqP3funCSpWbNmkir3N5Oenq7OnTsrMDDQbBMdHa28vDzt37+/Bqu/uv4S7777rgICAtSpUydNnjxZP/30k7muNtV/+fJlrVixQufPn1dkZKTLvf+4wlWzoyrcZX99La6+j7wedW2/FB8fr5iYGLv+SXXj/zWcqy5mR3ncZSzjCHUlb6+XK427HKEufk6Ba+ZHVfbzrvA3W1376vT0dN19993y8vIy20RHR+vQoUM6e/ZsDfXGXlX3s87uk6P2k+np6VeNH6Kjo2vs36CjjoU5u19wHFfMjvLUlbFDXRgHuMNneXf/PO7q515QNa6UHa76b9GVj0t/9NFH6tGjhwYNGqSWLVvqtttu05tvvmmur+051qtXL6Wlpek///mPJOnLL7/U559/rgceeMAl6i/NHcej586dk81mU5MmTVyy/rrMlbKjMtz9eFZ53HG/UhmufgysPO56bAzuw92yQ3Ktz5LX4qpjrWtxx+9EufL48lrc6TNZvRp/RVSb06dP6/Lly3Z/TJIUGBiogwcPOqmqikVERCg5OVnt27fX8ePHNWPGDN11113at2+fcnJy5OXlZQ68SwQGBionJ8c5BVegpKay3v+SdTk5OWrZsqXd+nr16qlZs2a1ok/9+/dXbGysQkJCdPToUT333HN64IEHlJ6eLk9Pz1pVf3FxscaPH68777xTnTp1kqRK/c3k5OSU+f+oZF1NKat+Sfrtb3+rtm3bqlWrVvrqq6/0zDPP6NChQ3r//fdrTf179+5VZGSkLly4oEaNGumDDz5Qhw4dtGfPHpd5//E/rpgdVeUO++trcfV9pFV1cb+0YsUK7dq1S1988cVV69z5/zVqh7qYHWVxp7GMI9SFvL1erjTucoS69jkF/+Nq+VHV/bwr/M1W1746JydHISEhV22jZF3Tpk0dUn95qmM/68w+OXI/WV6bvLw8FRQUyNfX1xFdkuTYY2HO7Bccy9Wyozx1aezg7uMAd/gs7+6fx1353Auqh6tkh6v+W3T149Jff/21Xn/9dSUmJuq5557TF198od///vfy8vJSXFxcrc+xZ599Vnl5eQoNDZWnp6cuX76sP/3pTxo6dKhZW22uvzR3G49euHBBzzzzjIYMGSI/Pz/z9V2l/rrOVbKjMurC8azyuNt+pTJc/RhYedz12BjciztlRwlX+ixZEVcda1XEXb8T5erjy4q422cyJpagRpVcPUOSunTpooiICLVt21YrV67kw5oTDB482Py5c+fO6tKli37xi19o8+bN6tevnxMru1p8fLz27dunzz//3NmlXJfy6h89erT5c+fOnRUcHKx+/frp6NGj+sUvflHTZZapffv22rNnj86dO6d//OMfiouL05YtW5xdFoBSXH0faVVd2y999913GjdunFJTU+Xj4+PscoA6i7EMrpcrjbscoa59ToHrYj/vulx9P+uu+0lXPhYGVBWZ4j5cPWMk982ZEuQNXIUr/lt0h+PSxcXF6tGjh/785z9Lkm677Tbt27dPSUlJiouLc3J117Zy5Uq9++67Wr58uTp27Kg9e/Zo/PjxatWqlUvU764uXryo3/zmNzIMQ6+//rqzy0Edx9ijbnGH8UlZXPFzEoDawx33Ie74nSh3GF9WxN0+k3k4uwBcv4CAAHl6eurEiRN2j584cUJBQUFOqsqaJk2a6NZbb9WRI0cUFBSkoqIi5ebm2rWprf0pqami9z8oKEgnT560W3/p0iX98MMPtbJPN998swICAnTkyBFJtaf+hIQErVmzRps2bdKNN95oPl6Zv5mgoKAy/x+VrKsJ5dVfloiICEmy+3/g7Pq9vLx0yy23KDw8XLNnz1bXrl01f/58l3n/Yc8dssMqd9xfl+bq+8jrUdf2SxkZGTp58qS6d++uevXqqV69etqyZYtee+011atXT4GBgW7Zb9QedTE7KsOVxzKO4O55W51q67jLEeri5xT8j6vnh9X9vCv8zVbXvrq29/V69rPO6pOj95PltfHz83PoyQxHHwtzVr/geK6eHeVx57FDXRsHuNpneXf/PO7q515QPVwhO1z136I7HJcODg5Whw4d7B4LCwtTdna2XQ21NccmTpyoZ599VoMHD1bnzp31+OOPa8KECZo9e7ZL1F+au4xHSyaVfPvtt0pNTTXvVlLy+rW9flzhCtlxvdzxeFZ53GW/UhWudAysPO56bAzuxx2zw5U+S5bHVcda1+KO34lyh/GlFa7+mYyJJS7My8tL4eHhSktLMx8rLi5WWlqaIiMjnVhZ5eXn5+vo0aMKDg5WeHi46tevb9efQ4cOKTs7u1b2JyQkREFBQXb15uXlafv27Wa9kZGRys3NVUZGhtlm48aNKi4uNg9i1ybff/+9zpw5o+DgYEnOr98wDCUkJOiDDz7Qxo0br7odY2X+ZiIjI7V37167DzklB3l+fiCxpusvy549eyTJ7v+Bs+ovT3FxsQoLC2v9+4+yuUN2WOWO+2vJ9feR1cnd90v9+vXT3r17tWfPHnPp0aOHhg4dav7sjv1G7VEXs6MyXHks4wjumreOUNvGXY7A5xRIrp8fVvfzrvA3W1376sjISH366ae6ePGi2SY1NVXt27dX06ZNa6g35bue/WxN96mm9pORkZF22yhp46h/gzV1LKym+4Wa4+rZUR53HjvUtXGAq3yWd/fP4+567gXXpzZnh6v/W3SH49J33nmnDh06ZPfYf/7zH7Vt21ZS7c+xn376SR4e9l/p8fT0VHFxsUvUX5o7jEdLJpUcPnxYGzZsUPPmze3W1/b68T+1OTuqyh2PZ5XHHfYrVeUKx8DK467HxuC+3DE7XOmz5M+5+ljLKnf4TpQ7jC+tcPnPZAZc2ooVKwxvb28jOTnZOHDggDF69GijSZMmRk5OjrNLK9Mf/vAHY/PmzUZWVpbx73//24iKijICAgKMkydPGoZhGGPGjDHatGljbNy40di5c6cRGRlpREZGOq3eH3/80di9e7exe/duQ5Lx6quvGrt37za+/fZbwzAM48UXXzSaNGlifPjhh8ZXX31lPPLII0ZISIhRUFBgbqN///7GbbfdZmzfvt34/PPPjXbt2hlDhgxxev0//vij8fTTTxvp6elGVlaWsWHDBqN79+5Gu3btjAsXLtSK+seOHWv4+/sbmzdvNo4fP24uP/30k9nmWn8zly5dMjp16mTcf//9xp49e4yUlBSjRYsWxuTJk51e/5EjR4yZM2caO3fuNLKysowPP/zQuPnmm4277767VtRvGIbx7LPPGlu2bDGysrKMr776ynj22WcNm81mfPLJJ4Zh1O73H+VzteyoDFffX18PV99HXi/2S1fcc889xrhx48zf60q/4TzumB1WudpYxhHqYt5WhquPuxyhrn5OwdVcKT+qup+vLX+zNbGvzs3NNQIDA43HH3/c2Ldvn7FixQqjQYMGxt/+9rca71N17Wdruk81tZ/8+uuvjQYNGhgTJ040MjMzjYULFxqenp5GSkqKU/pVXcfCarpfqFmulB3lcbexgzuPA9z1s7y7fx53h3MvqF61NTvc8d+iqx2X3rFjh1GvXj3jT3/6k3H48GHj3XffNRo0aGAsW7bMbFObcywuLs644YYbjDVr1hhZWVnG+++/bwQEBBiTJk2qlfW7+ni0ovqLioqMX/7yl8aNN95o7Nmzx+7fdGFhYa2oH9bU1uywyl2OZ5XH1fcr1dlfVz0GVh53PTYG9+aK2eGux3TccaxVoi59J8rVxpcVcbfPZEwscQN//etfjTZt2hheXl5Gz549jW3btjm7pHI9+uijRnBwsOHl5WXccMMNxqOPPmocOXLEXF9QUGD87ne/M5o2bWo0aNDA+NWvfmUcP37cafVu2rTJkHTVEhcXZxiGYRQXFxvPP/+8ERgYaHh7exv9+vUzDh06ZLeNM2fOGEOGDDEaNWpk+Pn5GcOHDzd+/PFHp9f/008/Gffff7/RokULo379+kbbtm2NUaNGXfVhx5n1l1W7JOOdd94x21Tmb+abb74xHnjgAcPX19cICAgw/vCHPxgXL150ev3Z2dnG3XffbTRr1szw9vY2brnlFmPixInGuXPnakX9hmEYTz75pNG2bVvDy8vLaNGihdGvXz/zg4ph1O73HxVzpeyoDFffX18PV99HXi/2S1f8fIBVV/oN53K37LDK1cYyjlAX87YyXH3c5Qh19XMKyuYq+VEd+/na8DdbU/vqL7/80ujdu7fh7e1t3HDDDcaLL77olD5V5362JvtUk/vJTZs2Gd26dTO8vLyMm2++2e41arpf1XksrCb7hZrnKtlRHncbO7jzOMBdP8u7++dxdzj3gupXG7PDHf8tuuJx6Y8//tjo1KmT4e3tbYSGhhpvvPGG3franGN5eXnGuHHjjDZt2hg+Pj7GzTffbPzxj3+0m8hQm+p39fFoRfVnZWWV+29606ZNtaJ+WFcbs8MqdzmeVR5X369Y5Y7HwMrjrsfG4P5cLTvc9ZiOO461StSl70S54viyPO72mcxmGIYhAAAAAAAAAAAAAAAAAAAAAAAA1Dkezi4AAAAAAAAAAAAAAAAAAAAAAAAAzsHEEgAAAAAAAAAAAAAAAAAAAAAAgDqKiSUAAAAAAAAAAAAAAAAAAAAAAAB1FBNLAAAAAAAAAAAAAAAAAAAAAAAA6igmlgAAAAAAAAAAAAAAAAAAAAAAANRRTCwBAAAAAAAAAAAAAAAAAAAAAACoo5hYAgAAAAAAAAAAAAAAAAAAAAAAUEcxsQQAAAAAAAAAAAAAAAAAAAAAAKCOYmIJ4IJycnL01FNP6eabb5a3t7dat26thx9+WGlpaZKkm266STabTTabTb6+vrrpppv0m9/8Rhs3brxqW1988YX69eunJk2aqGnTpoqOjtaXX35p18YwDL3yyiu69dZb5e3trRtuuEF/+tOfaqSvAIDrU11Z8eWXX2rIkCFq3bq1fH19FRYWpvnz59u1eeKJJ8xtlV46duxYZm0vvviibDabxo8f75C+AwCuT23MjoULF+qmm26Sj4+PIiIitGPHDse+CQAAS6rzGNXvf/97hYeHy9vbW926dbtq/TfffFNmdmzbts1sk5ycfNV6Hx8fh/UfAGBdTWbHhQsX9MQTT6hz586qV6+eBgwYcFWb999/X/fdd59atGghPz8/RUZGav369dXdbQBANarOLClx5swZ3XjjjbLZbMrNzTUft3r+AwBQO9VkdkjSu+++q65du6pBgwYKDg7Wk08+qTNnzjiyiwCAalbT2bF582Z1795d3t7euuWWW5ScnOzA3gHlY2IJ4GK++eYbhYeHa+PGjXr55Ze1d+9epaSkqG/fvoqPjzfbzZw5U8ePH9ehQ4e0dOlSNWnSRFFRUXYTQvLz89W/f3+1adNG27dv1+eff67GjRsrOjpaFy9eNNuNGzdOb731ll555RUdPHhQH330kXr27Fmj/QYAVF51ZkVGRoZatmypZcuWaf/+/frjH/+oyZMna8GCBWab+fPn6/jx4+by3XffqVmzZho0aNBVtX3xxRf629/+pi5dujj2TQAAWFIbs+O9995TYmKipk2bpl27dqlr166Kjo7WyZMna+ZNAQBUqDqzo8STTz6pRx99tMLX3bBhg12GhIeH26338/OzW//tt99WT4cBAFVW09lx+fJl+fr66ve//72ioqLKbPPpp5/qvvvu07p165SRkaG+ffvq4Ycf1u7du6un0wCAauWILJGkESNGlHnewsr5DwBA7VTT2fHvf/9bw4YN04gRI7R//36tWrVKO3bs0KhRoxzWRwBA9arp7MjKylJMTIz69u2rPXv2aPz48Ro5ciQXP4FzGABcygMPPGDccMMNRn5+/lXrzp49axiGYbRt29aYO3fuVeunTp1qeHh4GAcPHjQMwzC++OILQ5KRnZ1ttvnqq68MScbhw4cNwzCMAwcOGPXq1TOfAwCo/aozK8ryu9/9zujbt2+56z/44APDZrMZ33zzjd3jP/74o9GuXTsjNTXVuOeee4xx48ZVqj8AAMerjdnRs2dPIz4+3vz98uXLRqtWrYzZs2dXokcAAEdzVHZMmzbN6Nq161WPZ2VlGZKM3bt3l1vTO++8Y/j7+1eyBwCAmlbT2VFaXFyc8cgjj1Sqzg4dOhgzZsyoVFsAQM1yRJYsWrTIuOeee4y0tDRDkrmdspR3/gMAUHvVdHa8/PLLxs0332zX/rXXXjNuuOGGKvcFAFAzajo7Jk2aZHTs2NGu/aOPPmpER0dXuS+AVdyxBHAhP/zwg1JSUhQfH6+GDRtetb5JkyYVPn/cuHEyDEMffvihJKl9+/Zq3ry53n77bRUVFamgoEBvv/22wsLCdNNNN0mSPv74Y918881as2aNQkJCdNNNN2nkyJH64Ycfqrt7AIBqUN1ZUZZz586pWbNm5a5/++23FRUVpbZt29o9Hh8fr5iYmHKvEAkAcI7amB1FRUXKyMiwywwPDw9FRUUpPT39Gj0CADhaTWRHeX75y1+qZcuW6t27tz766KOr1ufn56tt27Zq3bq1HnnkEe3fv9/yawAAqp8zs8OK4uJi/fjjjxWOXwAAzuGILDlw4IBmzpyppUuXysPj2l+fKe/8BwCgdnJGdkRGRuq7777TunXrZBiGTpw4oX/84x968MEHq9wfAIDjOSM70tPTr/ouVXR0NOfF4RRMLAFcyJEjR2QYhkJDQ6/r+c2aNVPLli31zTffSJIaN26szZs3a9myZfL19VWjRo2UkpKif/3rX6pXr54k6euvv9a3336rVatWaenSpUpOTlZGRoZ+/etfV1e3AADVqLqz4ue2bt2q9957T6NHjy5z/bFjx/Svf/1LI0eOtHt8xYoV2rVrl2bPnn1ddQEAHKc2Zsfp06d1+fJlBQYG2rUNDAxUTk7OddUJAKg+js6OsjRq1Ehz5szRqlWrtHbtWvXu3VsDBgywm1zSvn17LV68WB9++KGWLVum4uJi9erVS99///111QkAqD7OyI7r8corryg/P1+/+c1vHPo6AADrqjtLCgsLNWTIEL388stq06bNNZ9f3vkPAEDt5YzsuPPOO/Xuu+/q0UcflZeXl4KCguTv76+FCxdebzcAADXIGdmRk5NT5nnxvLw8FRQUXFcdwPWq5+wCAFSeYRjVsg2bzSZJKigo0IgRI3TnnXfq73//uy5fvqxXXnlFMTEx+uKLL+Tr66vi4mIVFhZq6dKluvXWWyVduRJLeHi4Dh06pPbt21e5JgBA9anurCht3759euSRRzRt2jTdf//9ZT53yZIlatKkiQYMGGA+9t1332ncuHFKTU2Vj49PlesDAFSv2pgdAIDazZHZUZ6AgAAlJiaav99+++06duyYXn75Zf3yl7+UdOWKkJGRkWabXr16KSwsTH/72980a9asKtcMALh+zsgOq5YvX64ZM2boww8/VMuWLR32OgCA61PdWTJ58mSFhYXpscceq9RzOYYFAK7HGdlx4MABjRs3TlOnTlV0dLSOHz+uiRMnasyYMXr77berXA8AwLGcPe4AnI07lgAupF27drLZbDp48OB1Pf/MmTM6deqUQkJCJF05SfLNN9/onXfe0e2336477rhDy5cvV1ZWlnkrruDgYNWrV8+cVCJJYWFhkqTs7Owq9ggAUN2qOytKHDhwQP369dPo0aM1ZcqUMp9rGIYWL16sxx9/XF5eXubjGRkZOnnypLp376569eqpXr162rJli1577TXVq1dPly9fvq5aAQDVozZmR0BAgDw9PXXixAm79idOnFBQUNB11QkAqD6Oyg6rIiIidOTIkXLX169fX7fddluFbQAANaO2ZEd5VqxYoZEjR2rlypWKiopyyGsAAKqmurNk48aNWrVqlXneol+/fpKuHJeaNm2a3XPLO4YFAKjdnJEds2fP1p133qmJEyeqS5cuio6O1qJFi7R48WIdP368ejoGAHAYZ2RHUFBQmefF/fz85OvrW4XeANYxsQRwIc2aNVN0dLQWLlyo8+fPX7U+Nze3wufPnz9fHh4e5lVUfvrpJ3l4eNhd4avk9+LiYklXbtF46dIlHT161Gzzn//8R5LUtm3bKvYIAFDdqjsrJGn//v3q27ev4uLi9Kc//anc527ZskVHjhzRiBEj7B7v16+f9u7dqz179phLjx49NHToUO3Zs0eenp6W+ggAqF61MTu8vLwUHh6utLQ087Hi4mKlpaXZXYkeAOAcjsiO67Fnzx4FBweXu/7y5cvau3dvhW0AADWjtmRHWf7+979r+PDh+vvf/66YmJhq3z4AoHpUd5b885//1Jdffmmet3jrrbckSZ999pni4+PtnlveMSwAQO3mjOwo+S5WaSXnw6vjKvgAAMdyRnZERkbanReXpNTUVM6LwynqObsAANYsXLhQd955p3r27KmZM2eqS5cuunTpklJTU/X6668rMzNTkvTjjz8qJydHFy9eVFZWlpYtW6a33npLs2fP1i233CJJuu+++zRx4kTFx8frqaeeUnFxsV588UXVq1dPffv2lSRFRUWpe/fuevLJJzVv3jwVFxcrPj5e9913n91dTAAAtUd1ZsW+fft07733Kjo6WomJicrJyZF05eBXixYt7F737bffVkREhDp16mT3eOPGja96rGHDhmrevPlVjwMAnKO2ZYckJSYmKi4uTj169FDPnj01b948nT9/XsOHD3fwuwEAqIzqzA5JOnLkiPLz85WTk6OCggLt2bNHktShQwd5eXlpyZIl8vLy0m233SZJev/997V48WLzJIwkzZw5U3fccYduueUW5ebm6uWXX9a3336rkSNH1twbAwAoV01nh3TlTopFRUX64Ycf9OOPP5ptunXrJunKnd3j4uI0f/58RUREmOMXX19f+fv718wbAwCotOrMkl/84hd22z59+rQkKSwsTE2aNLFbV9ExLABA7VbT2fHwww9r1KhRev311xUdHa3jx49r/Pjx6tmzp1q1alVzHQcAXLeazo4xY8ZowYIFmjRpkp588klt3LhRK1eu1Nq1a2uu00AJA4DLOXbsmBEfH2+0bdvW8PLyMm644Qbjl7/8pbFp0ybDMAyjbdu2hiRDkuHl5WW0adPG+M1vfmNs3Ljxqm198sknxp133mn4+/sbTZs2Ne69914jPT3drs1///tfIzY21mjUqJERGBhoPPHEE8aZM2dqoqsAgOtUXVkxbdo0s13ppW3btnbtcnNzDV9fX+ONN96oVH333HOPMW7cuGroKQCgutTG7PjrX/9qtGnTxvDy8jJ69uxpbNu2rbq7DQCoguo8RnXPPfeUmR9ZWVmGYRhGcnKyERYWZjRo0MDw8/MzevbsaaxatcpuG+PHjzdzIzAw0HjwwQeNXbt2OfptAABYUJPZ8fPtlV6utY24uDgHvxMAgOtVnVlS2qZNmwxJxtmzZ+0et3r+AwBQ+9R0drz22mtGhw4dDF9fXyM4ONgYOnSo8f333zuodwAAR6jp7Ni0aZPRrVs3w8vLy7j55puNd955xzEdA67BZhjcYw0AAAAAAAAAAAAAAAAAAAAAAKAu8nB2AQAAAAAAAAAAAAAAAAAAAAAAAHAOJpYAAAAAAAAAAAAAAAAAAAAAAADUUUwsAQAAAAAAAAAAAAAAAAAAAAAAqKOYWAIAAAAAAAAAAAAAAAAAAAAAAFBHMbEEAAAAAAAAAAAAAAAAAAAAAACgjmJiCQAAAAAAAAAAAAAAAAAAAAAAQB3FxBIAAAAAAAAAAAAAAAAAAAAAAIA6ioklAAAAAAAAAAAAAAAAAAAAAAAAdRQTSwAAAAAAAAAAAAAAAAAAAAAAAOooJpYAAAAAAAAAAAAAAAAAAAAAAADUUUwsAQAAAAAAAAAAAAAAAAAAAAAAqKPqObsA2CsuLtaxY8fUuHFj2Ww2Z5cDANfFMAz9+OOPatWqlTw8mMPoaGQHAHdAdtQssgOAOyA7ahbZAcAdkB01i+wA4A7IjppFdgBwB2RHzSI7ALgDsqNmkR0A3IGjsoOJJbXMsWPH1Lp1a2eXAQDV4rvvvtONN97o7DLcHtkBwJ2QHTWD7ADgTsiOmkF2AHAnZEfNIDsAuBOyo2aQHQDcCdlRM8gOAO6E7KgZZAcAd1Ld2cHEklqmcePGkq78j/bz83NyNQBwffLy8tS6dWtznwbHIjsAuAOyo2aRHQDcAdlRs8gOAO6A7KhZZAcAd0B21CyyA4A7IDtqFtkBwB2QHTWL7ADgDhyVHUwsqWVKbq3l5+dHaAFwedwusGaQHQDcCdlRM8gOAO6E7KgZZAcAd0J21AyyA4A7ITtqBtkBwJ2QHTWD7ADgTsiOmkF2AHAn1Z0dHtW6NQAAAAAAAAAAAAAAAAAAAAAAALgMJpYAAAAAAAAAAAAAAAAAAAAAAADUUfWcXQAcLzs7W6dPn1ZAQIDatGnj7HIAALVISUZIIicAAJVCdgAArCI7AABWkR0AAKvIDgCAVWQHAMAqsgOAu2NiiZsqCbDjx4/r17/+tS5cuCBfX18dPHiQMAMASLqSFaGhoSooKJAkcgIAcE1kBwDAKrIDAGAV2QEAsIrsAABYRXYAAKwiOwDUBR7OLgDVryTAwsPD9dBDD+nChQu6++67VVBQYM6WBADg9OnTKigoUGxsrGJjY8kJAMA1kR0AAKvIDgCAVWQHAMAqsgMAYBXZAQCwiuwAUBdwxxI3VDrAzp49q02bNsnf39/ZZQEAaqmAgABnlwAAcDFkBwDAKrIDAGAV2QEAsIrsAABYRXYAAKwiOwC4MyaWuDECDAAAAAAAAAAAAAAAAAAAAAAAVMTD2QUAAAAAAAAAAAAAAAAAAAAAAADAOZhYAgAAAAAAAAAAAAAAAAAAAAAAUEcxsQQAAAAAAAAAAAAAAAAAAAAAAKCOYmIJAAAAAAAAAAAAAAAAAAAAAABAHcXEEgAAAAAAAAAAAAAAAAAAAMCFTZ8+XTabzW4JDQ0111+4cEHx8fFq3ry5GjVqpIEDB+rEiRN228jOzlZMTIwaNGigli1bauLEibp06ZJdm82bN6t79+7y9vbWLbfcouTk5KtqWbhwoW666Sb5+PgoIiJCO3bsuGb9q1atUmhoqHx8fNS5c2etW7fObr1hGJo6daqCg4Pl6+urqKgoHT582MI7BACoCBNLAAAAAAAAAAAAAAAAAAAAABfXsWNHHT9+3Fw+//xzc92ECRP08ccfa9WqVdqyZYuOHTum2NhYc/3ly5cVExOjoqIibd26VUuWLFFycrKmTp1qtsnKylJMTIz69u2rPXv2aPz48Ro5cqTWr19vtnnvvfeUmJioadOmadeuXeratauio6N18uTJcuveunWrhgwZohEjRmj37t0aMGCABgwYoH379pltXnrpJb322mtKSkrS9u3b1bBhQ0VHR+vChQvV9fYBQJ3GxBIAAAAAAAAAAAAAAAAAAADAxdWrV09BQUHmEhAQIEk6d+6c3n77bb366qu69957FR4ernfeeUdbt27Vtm3bJEmffPKJDhw4oGXLlqlbt2564IEHNGvWLC1cuFBFRUWSpKSkJIWEhGjOnDkKCwtTQkKCfv3rX2vu3LlmDa+++qpGjRql4cOHq0OHDkpKSlKDBg20ePHicuueP3+++vfvr4kTJyosLEyzZs1S9+7dtWDBAklX7lYyb948TZkyRY888oi6dOmipUuX6tixY1q9erWD3k0AqFuYWAIAAAAAAAAAAAAAAAAAAAC4uMOHD6tVq1a6+eabNXToUGVnZ0uSMjIydPHiRUVFRZltQ0ND1aZNG6Wnp0uS0tPT1blzZwUGBpptoqOjlZeXp/3795ttSm+jpE3JNoqKipSRkWHXxsPDQ1FRUWabslxru1lZWcrJybFr4+/vr4iIiAq3CwCovHpWn/Dvf/9b33zzjS5fvmw+NmzYsGotCgDgXsgOAIBVZAcAwCqyAwBgFdkBALCK7AAAWEV2AACsqkp2REREKDk5We3bt9fx48c1Y8YM3XXXXdq3b59ycnLk5eWlJk2a2D0nMDBQOTk5kqScnBy7SSUl60vWVdQmLy9PBQUFOnv2rC5fvlxmm4MHD5Zbe3nbLf26pespq01ZCgsLVVhYaP6el5dXblsAqOssTSwZMmSIcnJydNttt8nT01OSZLPZHFIYAMA9kB0AAKvIDgCAVWQHAMAqsgMAYBXZAQCwiuwAAFhV1ex44IEHzJ+7dOmiiIgItW3bVitXrpSvr2+11+sKZs+erRkzZji7DABwCZYmlnz55Zc6cOCAo2oBALghsgMAYBXZAQCwiuwAAFhFdgAArCI7AABWkR0AAKuqOzuaNGmiW2+9VUeOHNF9992noqIi5ebm2t215MSJEwoKCpIkBQUFaceOHXbbOHHihLmu5L8lj5Vu4+fnJ19fX3l6esrT07PMNiXbKEt52y39uiWPBQcH27Xp1q1bududPHmyEhMTzd/z8vLUunXrctsDQF3mYaVxz549dejQIUfVAgBwQ2QHAMAqsgMAYBXZAQCwiuwAAFhFdgAArCI7AABWVXd25Ofn6+jRowoODlZ4eLjq16+vtLQ0c/2hQ4eUnZ2tyMhISVJkZKT27t2rkydPmm1SU1Pl5+enDh06mG1Kb6OkTck2vLy8FB4ebtemuLhYaWlpZpuyXGu7ISEhCgoKsmuTl5en7du3V7hdb29v+fn52S0AgLJZumPJnj171LVrV7Vv317e3t4yDEM2m+2qGYoAAJQgOwAAVpEdAACryA4AgFVkBwDAKrIDAGAV2QEAsKqq2fH000/r4YcfVtu2bXXs2DFNmzZNnp6eGjJkiPz9/TVixAglJiaqWbNm8vPz01NPPaXIyEjdcccdkqT7779fHTp00OOPP66XXnpJOTk5mjJliuLj4+Xt7S1JGjNmjBYsWKBJkybpySef1MaNG7Vy5UqtXbvWrCMxMVFxcXHq0aOHevbsqXnz5un8+fMaPny42WbYsGG64YYbNHv2bEnSuHHjdM8992jOnDmKiYnRihUrtHPnTr3xxhuSJJvNpvHjx+uFF15Qu3btFBISoueff16tWrXSgAEDquPtB4A6z9LEkg8//NBRdQAA3BTZAQCwiuwAAFhFdgAArCI7AABWkR0AAKvIDgCAVVXNju+//15DhgzRmTNn1KJFC/Xu3Vvbtm1TixYtJElz586Vh4eHBg4cqMLCQkVHR2vRokXm8z09PbVmzRqNHTtWkZGRatiwoeLi4jRz5kyzTUhIiNauXasJEyZo/vz5uvHGG/XWW28pOjrabPPoo4/q1KlTmjp1qnJyctStWzelpKQoMDDQbJOdnS0PDw/z9169emn58uWaMmWKnnvuObVr106rV69Wp06dzDaTJk3S+fPnNXr0aOXm5qp3795KSUmRj49Pld43AMAVliaWtG3bVrt379bnn38uSbrrrrvUrVs3R9QFAHATZAcAwCqyAwBgFdkBALCK7AAAWEV2AACsIjsAAFZVNTtWrFhR4XofHx8tXLhQCxcurLCGdevWVbidPn36aPfu3RW2SUhIUEJCQrnrN2/efNVjgwYN0qBBg8p9js1m08yZM+0mugAAqo/HtZv8zyuvvKKRI0cqPz9f+fn5GjVqlF599VVH1QYAcANkBwDAKrIDAGAV2QEAsIrsAABYRXYAAKwiOwAAVpEdAABnsnTHkqVLl+qLL76Qt7e3JCkxMVG33367EhMTHVIcAMD1kR0AAKvIDgCAVWQHAMAqsgMAYBXZAQCwiuwAAFhFdgAAnMnSHUsk6cKFC2X+DABAeaqSHdOnT5fNZrNbQkND7bYXHx+v5s2bq1GjRho4cKBOnDhht43s7GzFxMSoQYMGatmypSZOnKhLly7Ztdm8ebO6d+8ub29v3XLLLUpOTr6qloULF+qmm26Sj4+PIiIitGPHjmvWv2rVKoWGhsrHx0edO3e+6laRhmFo6tSpCg4Olq+vr6KionT48GEL7xAAuCfGHQAAq8gOAIBVZAcAwCqyAwBgFefKOVcOAFYx7gAAOIulO5ZMnDhR4eHhioqKkmEY2rhxo6ZNm+ao2gAAbqA6sqNjx47asGGD+Xu9ev+LrwkTJmjt2rVatWqV/P39lZCQoNjYWP373/+WJF2+fFkxMTEKCgrS1q1bdfz4cQ0bNkz169fXn//8Z0lSVlaWYmJiNGbMGL377rtKS0vTyJEjFRwcrOjoaEnSe++9p8TERCUlJSkiIkLz5s1TdHS0Dh06pJYtW5ZZ99atWzVkyBDNnj1bDz30kJYvX64BAwZo165d6tSpkyTppZde0muvvaYlS5YoJCREzz//vKKjo3XgwAH5+PhYep8AwF0w7gAAWEV2AACsIjsAAFaRHQAAqzhXzrlyALCKcQcAwJksTSx5/PHH1a9fP33xxReSrsyMDw4OdkhhAAD3UB3ZUa9ePQUFBV31+Llz5/T2229r+fLluvfeeyVJ77zzjsLCwrRt2zbdcccd+uSTT3TgwAFt2LBBgYGB6tatm2bNmqVnnnlG06dPl5eXl5KSkhQSEqI5c+ZIksLCwvT5559r7ty55sGyV199VaNGjdLw4cMlSUlJSVq7dq0WL16sZ599tsy658+fr/79+2vixImSpFmzZik1NVULFixQUlKSDMPQvHnzNGXKFD3yyCOSrtzSMjAwUKtXr9bgwYMtvU8A4C4YdwAArCI7AABWkR0AAKvIDgCAVZwr51w5AFjFuAMA4EwelWmUlZUlSTpw4IByc3PVrl07tWvXTmfPntWBAwccWiAAwLVVR3YcPnxYrVq10s0336yhQ4cqOztbkpSRkaGLFy8qKirKbBsaGqo2bdooPT1dkpSenq7OnTsrMDDQbBMdHa28vDzt37/fbFN6GyVtSrZRVFSkjIwMuzYeHh6Kiooy25TlWtvNyspSTk6OXRt/f39FRERUuN3CwkLl5eXZLQDgThh3AACsqmp2TJ8+XTabzW4JDQ0111+4cEHx8fFq3ry5GjVqpIEDB+rEiRN228jOzlZMTIwaNGigli1bauLEibp06ZJdm82bN6t79+7y9vbWLbfcouTk5KtqWbhwoW666Sb5+PgoIiJCO3bsuGb9q1atUmhoqHx8fNS5c2etW7fObr1hGJo6daqCg4Pl6+urqKgoHT58uNLvDwC4I8YdAACrGHcw7gAAqzhXzrlyALCKY1YAAGeq1B1LZs+erTfeeEPx8fFXrbPZbNq4cWO1FwYAcA9VzY6IiAglJyerffv2On78uGbMmKG77rpL+/btU05Ojry8vNSkSRO75wQGBionJ0eSlJOTY3egrGR9ybqK2uTl5amgoEBnz57V5cuXy2xz8ODBcmsvb7ulX7d0PWW1Kcvs2bM1Y8aMctcDgKurznHHiy++qMmTJ2vcuHGaN2+epCsn6f/whz9oxYoVKiwsVHR0tBYtWmS3P87OztbYsWO1adMmNWrUSHFxcZo9e7bdLeY3b96sxMRE7d+/X61bt9aUKVP0xBNP2L3+woUL9fLLLysnJ0ddu3bVX//6V/Xs2bPCmletWqXnn39e33zzjdq1a6e//OUvevDBB831hmFo2rRpevPNN5Wbm6s777xTr7/+utq1a2f5/QEAd1Ed2dGxY0dt2LDB/L30Pn/ChAlau3atVq1aJX9/fyUkJCg2Nlb//ve/JUmXL19WTEyMgoKCtHXrVh0/flzDhg1T/fr19ec//1nSlZPlMTExGjNmjN59912lpaVp5MiRCg4ONq/++N577ykxMVFJSUmKiIjQvHnzFB0drUOHDqlly5Zl1r1161YNGTJEs2fP1kMPPaTly5drwIAB2rVrlzp16iRJeumll/Taa69pyZIlCgkJ0fPPP6/o6GgdOHBAPj4+lX6PAMCdcL4DAGAV4w7GHQBgFefKOVcOAFZxzAoA4EyVmljyxhtvSJJWrlypFi1a2K07depU9VcFAHAbVc2OBx54wPy5S5cuioiIUNu2bbVy5Ur5+vpWW52uZPLkyUpMTDR/z8vLU+vWrZ1YEQBUr+oad3zxxRf629/+pi5dutg9zkl6AHA/1ZEd9erVU1BQ0FWPnzt3Tm+//baWL1+ue++9V5L0zjvvKCwsTNu2bdMdd9yhTz75RAcOHNCGDRsUGBiobt26adasWXrmmWc0ffp0eXl5KSkpSSEhIZozZ44kKSwsTJ9//rnmzp1rZserr76qUaNGafjw4ZKkpKQkrV27VosXL9azzz5bZt3z589X//79NXHiREnSrFmzlJqaqgULFigpKUmGYWjevHmaMmWKHnnkEUnS0qVLFRgYqNWrV2vw4MGW3icAcBec7wAAWMW4g3EHAFjFufLqx7lyAO6OY1YAAGfysNK45GDTtR4DAKBEdWdHkyZNdOutt+rIkSMKCgpSUVGRcnNz7dqcOHHCPDETFBR01a3iS36/Vhs/Pz/5+voqICBAnp6eZbYp6wRQifK2W/p1S9dT2e16e3vLz8/PbgEAd1Id2ZGfn6+hQ4fqzTffVNOmTc3HS07Sv/rqq7r33nsVHh6ud955R1u3btW2bdskyTxJv2zZMnXr1k0PPPCAZs2apYULF6qoqEiS7E7Sh4WFKSEhQb/+9a81d+5c87VKn6Tv0KGDkpKS1KBBAy1evLjcukufpA8LC9OsWbPUvXt3LViwQJKuOknfpUsXLV26VMeOHdPq1astvUcA4E6qIzsOHz6sVq1a6eabb9bQoUOVnZ0tScrIyNDFixcVFRVltg0NDVWbNm2Unp4uSUpPT1fnzp3trrAYHR2tvLw87d+/32xTehslbUq2UVRUpIyMDLs2Hh4eioqKMtuU5VrbzcrKUk5Ojl0bf39/RUREVLjdwsJC5eXl2S0A4E6qmh3Tp0+XzWazW0JDQ831Fy5cUHx8vJo3b65GjRpp4MCBVx0Dys7OVkxMjBo0aKCWLVtq4sSJunTpkl2bzZs3q3v37vL29tYtt9yi5OTkq2pZuHChbrrpJvn4+CgiIkI7duy4Zv2rVq1SaGiofHx81LlzZ61bt85uvWEYmjp1qoKDg+Xr66uoqCgdPny40u8PALgjxh2MOwDAKs6Vc64cAKziO7oAAGeq1MSSI0eOaO3atcrLy9O6devMZcWKFSosLHR0jQAAF7V+/fpqz478/HwdPXpUwcHBCg8PV/369ZWWlmauP3TokLKzsxUZGSlJioyM1N69e3Xy5EmzTWpqqvz8/NShQwezTeltlLQp2YaXl5fCw8Pt2hQXFystLc1sU5ZrbTckJERBQUF2bfLy8rR9+/YKtwsA7qy6siM+Pl4xMTFXnfDmJD0n6QG4n+rIjoiICCUnJyslJUWvv/66srKydNddd+nHH39UTk6OvLy81KRJE7vnBAYGKicnR5KUk5Njlxsl60vWVdQmLy9PBQUFOn36tC5fvlxmm5JtlKW87ZZ+3dL1VHa7s2fPlr+/v7lw5UcA7qS6xh0dO3bU8ePHzeXzzz83102YMEEff/yxVq1apS1btujYsWOKjY0115fcKbGoqEhbt27VkiVLlJycrKlTp5ptSu6U2LdvX+3Zs0fjx4/XyJEjtX79erNNyZ0Sp02bpl27dqlr166Kjo62Oxb2cyV3ShwxYoR2796tAQMGaMCAAdq3b5/ZpuROiUlJSdq+fbsaNmyo6OhoXbhwwdJ7BADugnEH4w4AsIpz5ZwrBwCrHJEdAABYUa8yjfbv36/Vq1fr7NmzWrVqlfl448aN9eabbzqsOACAa/vwww+rnB1PP/20Hn74YbVt21bHjh3TtGnT5OnpqSFDhsjf318jRoxQYmKimjVrJj8/Pz311FOKjIzUHXfcIUm6//771aFDBz3++ON66aWXlJOToylTpig+Pl7e3t6SpDFjxmjBggWaNGmSnnzySW3cuFErV67U2rVrzToSExMVFxenHj16qGfPnpo3b57Onz9v3ipekoYNG6YbbrhBs2fPliSNGzdO99xzj+bMmaOYmBitWLFCO3fu1BtvvCFJstlsGj9+vF544QW1a9dOISEhev7559WqVSsNGDDgut93AHBl1ZEdK1as0K5du/TFF19cta6mTtKfPXu23JP0Bw8eLLd2R56knzFjRrnrAcCVVUd2PPDAA+bPXbp0UUREhNq2bauVK1fK19e3Wut1FZMnT1ZiYqL5e15eHl/yAuA2qiM7JKlevXplXkm35E6Jy5cv17333itJeueddxQWFqZt27bpjjvuMO+UuGHDBgUGBqpbt26aNWuWnnnmGU2fPl1eXl52d0qUpLCwMH3++eeaO3eueaXK0ndKlK7cXXHt2rVavHixnn322TLrLn2nREmaNWuWUlNTtWDBAiUlJV11p0RJWrp0qQIDA7V69WoNHjzY0vsEAO6AcYdjMO4A4M44V865cgCwqrqOWQEAcL0qNbHkkUce0SOPPKIdO3aoZ8+ejq4JDpSZmSlJCggIUJs2bZxcDQB3t2jRIh08eLBK2fH9999ryJAhOnPmjFq0aKHevXtr27ZtatGihSRp7ty58vDw0MCBA1VYWKjo6GgtWrTIfL6np6fWrFmjsWPHKjIyUg0bNlRcXJxmzpxptgkJCdHatWs1YcIEzZ8/XzfeeKPeeustu1tJPvroozp16pSmTp2qnJwcdevWTSkpKXZf7M3OzpaHx/9uBtarVy8tX75cU6ZM0XPPPad27dpp9erV6tSpk9lm0qRJOn/+vEaPHq3c3Fz17t1bKSkp8vHxue73DABcWVWz47vvvtO4ceOUmprKvrQUTtIDcGfVMe74uSZNmujWW2/VkSNHdN9996moqEi5ubl2ExNPnDhhfpk4KChIO3bssNvGiRMnzHUl/y15rHQbPz8/+fr6ytPTU56enmW2KetLyyXK227p1y15LDg42K5Nt27dyt2ut7e3+QUDAHA31ZUdhw8fVqtWreTj46PIyEjNnj1bbdq0ueadEu+4445y75Q4duxY7d+/X7fddlu5dzQcP368pP/dKXHy5Mnm+sreKbH0+KBku6tXr5Z07TslljexpLCw0O4KmtwpEYA7YdzBuAMArOJcOefKAcAqR4w7AACwolITS0qEhoZq9uzZOnDggN3JgZUrV1Z7YaheP/30k2w2mx577DFJkq+vrw4ePMjkEgAOV9XsWLFiRYXrfXx8tHDhQi1cuLDcNm3bttW6desq3E6fPn20e/fuCtskJCQoISGh3PWbN2++6rFBgwZp0KBB5T7HZrNp5syZdgfvAKCuq0p2ZGRk6OTJk+revbv52OXLl/Xpp59qwYIFWr9+PSfpAcANVfcxq/z8fB09elSPP/64wsPDVb9+faWlpWngwIGSpEOHDik7O1uRkZGSpMjISP3pT3/SyZMn1bJlS0lSamqq/Pz81KFDB7PNz8clqamp5ja8vLwUHh6utLQ086qMxcXFSktLq3AcEhkZqbS0NPNLxj/fbkhIiIKCgpSWlmZmRV5enrZv366xY8de1/sDAO6gqtkRERGh5ORktW/fXsePH9eMGTN01113ad++fdwpEQDcFOMOxh0AYBXnyjlXDgBW8R1dAIAzeVy7yf8MHTpUjRo10vbt2xUXFyebzaa2bds6qjZUo6KiIhmGodjYWMXGxqqgoECnT592dlkA6gCyAwBgVVWyo1+/ftq7d6/27NljLj169NDQoUPNn0tO0pco6yT93r17dfLkSbNNWSfpS2+jpE1ZJ+lLlJykL2lTlmttt/RJ+hIlJ+kr2i4AuLuqjjuefvppbdmyRd988422bt2qX/3qV/L09NSQIUPk7++vESNGKDExUZs2bVJGRoaGDx+uyMhI3XHHHZKk+++/Xx06dNDjjz+uL7/8UuvXr9eUKVMUHx9vTuwbM2aMvv76a02aNEkHDx7UokWLtHLlSk2YMMGsIzExUW+++aaWLFmizMxMjR07VufPn9fw4cPNNsOGDbO7Mv24ceOUkpKiOXPm6ODBg5o+fbp27txpnui32WwaP368XnjhBX300Ufau3evhg0bplatWplfJAOAuqiq2fHAAw9o0KBB6tKli6Kjo7Vu3Trl5ubW6ZP8kydP1rlz58zlu+++c3ZJAFCtGHcw7gAAqzhXDgCwiuwAADiTpTuWHDt2TE899ZTefPNNxcTE6MEHH1RERISjaoMDBAQEOLsEAHUM2QEAsKoq2dG4cWO726hLUsOGDdW8eXPz8ZKT9M2aNZOfn5+eeuqpck/Sv/TSS8rJySnzJP2CBQs0adIkPfnkk9q4caNWrlyptWvXmq+bmJiouLg49ejRQz179tS8efPKPEl/ww03aPbs2ZKunKS/5557NGfOHMXExGjFihXauXOn3njjDUn2J+nbtWunkJAQPf/885ykB1DnVXXc8f3332vIkCE6c+aMWrRood69e2vbtm1q0aKFJGnu3Lny8PDQwIEDVVhYqOjoaC1atMh8vqenp9asWaOxY8cqMjJSDRs2VFxcnN3VFkNCQrR27VpNmDBB8+fP14033qi33npL0dHRZptHH31Up06d0tSpU5WTk6Nu3bopJSXF7orx2dnZ8vD437VievXqpeXLl2vKlCl67rnn1K5dO61evdouDydNmqTz589r9OjRys3NVe/evZWSkiIfHx9rbzQAuJHqPmbVpEkT3XrrrTpy5Ijuu+8+7pQIAG6IcQfjDgCwinPlAACryA4AgDNZmlhSr96V5oGBgUpLS1OrVq105swZhxQGAHAPZAcAwCpHZwcn6QHA/VQ1O1asWFHheh8fHy1cuFALFy4st03btm21bt26CrfTp08f7d69u8I2CQkJ5lV/y7J58+arHhs0aJAGDRpU7nNsNptmzpxpl2UAUNdV97gjPz9fR48e1eOPP67w8HDzTokDBw6UVPadEv/0pz/p5MmTatmypaSy75T482wp706JJRPNS+6UWFGWlNwpcfz48WVut/SdEksmkpTcKXHs2LHX/R4BgKtj3MG4AwCs4lw5AMAqsgMA4EyWJpY899xzOnfunObMmaPf//73+vHHH/Xqq686qjYAgBsgOwAAVlV3dvz8RDgn6QHA/TDuAABYVdXsePrpp/Xwww+rbdu2OnbsmKZNmyZPT08NGTJE/v7+3CkRANwQ4w4AgFVkBwDAKrIDAOBMliaWPPLII5KkLl26lPkFqGv59NNP9fLLLysjI0PHjx/XBx98YHcSwjAMTZs2TW+++aZyc3N155136vXXX1e7du3MNj/88IOeeuopffzxx+ZVhufPn69GjRqZbb766ivFx8friy++UIsWLfTUU09p0qRJdrWsWrVKzz//vL755hu1a9dOf/nLX/Tggw9WWP/mzZuVmJio/fv3q3Xr1poyZYqeeOIJuzYLFy7Uyy+/rJycHHXt2lV//etf1bNnT8vvFQC4i6pmBwCg7iE7AABWkR0AAKuqmh3ff/+9hgwZojNnzqhFixbq3bu3tm3bphYtWkjiTokA4I4YdwAArCI7AABWkR0AAGeyNLHk6NGjWrBggb755htdvnzZfPyjjz6q1PPPnz+vrl276sknn1RsbOxV61966SW99tprWrJkiXkFrOjoaB04cMA8WTF06FAdP35cqampunjxooYPH67Ro0dr+fLlkq7cjv3+++9XVFSUkpKStHfvXj355JNq0qSJRo8eLUnaunWrhgwZotmzZ+uhhx7S8uXLNWDAAO3atcvuxElpWVlZiomJ0ZgxY/Tuu+8qLS1NI0eOVHBwsHkS57333lNiYqKSkpIUERGhefPmKTo6WocOHTJvZQ8AdU1VswMAUPeQHQAAq8gOAIBVVc2OFStWVLieOyUCgPth3AEAsIrsAABYRXYAAJzJ0sSSX/3qV0pISNBvfvMbu6tbVdYDDzygBx54oMx1hmFo3rx5mjJlijnrcunSpQoMDNTq1as1ePBgZWZmKiUlRV988YV69OghSfrrX/+qBx98UK+88opatWqld999V0VFRVq8eLG8vLzUsWNH7dmzR6+++qo5sWT+/Pnq37+/Jk6cKEmaNWuWUlNTtWDBAiUlJZVZX1JSkkJCQjRnzhxJUlhYmD7//HPNnTvXnFjy6quvatSoUeYt5pOSkrR27VotXrxYzz77rOX3CwDcQVWzAwBQ95AdAACryA4AgFVkBwDAKrIDAGAV2QEAsIrsAAA4k6WJJQ0aNDAnZ1S3rKws5eTkKCoqynzM399fERERSk9P1+DBg5Wenq4mTZqYk0okKSoqSh4eHtq+fbt+9atfKT09XXfffbe8vLzMNtHR0frLX/6is2fPqmnTpkpPT1diYqLd60dHR2v16tXl1peenm5XW8lzxo8fL0kqKipSRkaGJk+ebK738PBQVFSU0tPTy91uYWGhCgsLzd/z8vLKbQsArsiR2QEAcE9kBwDAKrIDAGAV2QEAsIrsAABYRXYAAKwiOwAAzmRpYsnkyZP1zDPPKCoqSt7e3ubjd999d5ULycnJkSQFBgbaPR4YGGiuy8nJUcuWLe3W16tXT82aNbNrExISctU2StY1bdpUOTk5Fb5OefWV9Zy8vDwVFBTo7Nmzunz5cpltDh48WO52Z8+erRkzZpS7HgBcnSOzAwDgnsgOAIBVZAcAwCqyAwBgFdkBALCK7AAAWEV2AACcydLEkvXr12vz5s06cuSIeZstm81GaFXB5MmT7e6ekpeXp9atWzuxIgCoXmQHAMAqsgMAYBXZAQCwiuwAAFhFdgAArCI7AABWkR0AAGeyNLFkw4YNOnTokGw2W7UXEhQUJEk6ceKEgoODzcdPnDihbt26mW1Onjxp97xLly7phx9+MJ8fFBSkEydO2LUp+f1abUrWl1dfWc/x8/OTr6+vPD095enpaXm73t7edjNLAcDdODI7AADuiewAAFhFdgAArCI7AABWkR0AAKvIDgCAVWQHAMCZPKw07tmzp44ePeqQQkJCQhQUFKS0tDTzsby8PG3fvl2RkZGSpMjISOXm5iojI8Nss3HjRhUXFysiIsJs8+mnn+rixYtmm9TUVLVv315NmzY125R+nZI2Ja9Tlms9x8vLS+Hh4XZtiouLlZaWVuF2AcDdOTI7AADuiewAAFhFdgAArCI7AABWkR0AAKvIDgCAVWQHAMCZLN2xZN++ferUqZPat28vb29vGYYhm82mHTt2VOr5+fn5OnLkiPl7VlaW9uzZo2bNmqlNmzYaP368XnjhBbVr104hISF6/vnn1apVKw0YMECSFBYWpv79+2vUqFFKSkrSxYsXlZCQoMGDB6tVq1aSpN/+9reaMWOGRowYoWeeeUb79u3T/PnzNXfuXPN1x40bp3vuuUdz5sxRTEyMVqxYoZ07d+qNN94w20yePFn//e9/tXTpUknSmDFjtGDBAk2aNElPPvmkNm7cqJUrV2rt2rXmcxITExUXF6cePXqoZ8+emjdvns6fP6/hw4dbeZsBwK1UNTsAAHUP2QEAsIrsAABYRXYAAKwiOwAAVpEdAACryA4AgDNZmljy4YcfVunFdu7cqb59+5q/JyYmSpLi4uKUnJysSZMm6fz58xo9erRyc3PVu3dvpaSkyMfHx3zOu+++q4SEBPXr108eHh4aOHCgXnvtNXO9v7+/PvnkE8XHxys8PFwBAQGaOnWqRo8ebbbp1auXli9frilTpui5555Tu3bttHr1anXq1Mlsc/z4cWVnZ5u/h4SEaO3atZowYYLmz5+vG2+8UW+99Zaio6PNNo8++qhOnTqlqVOnKicnR926dVNKSooCAwOr9L4BgCuranYAAOoesgMAYBXZAQCwiuwAAFhFdgAArCI7AABWkR0AAGeq1MSSwsJCeXt7q0WLFlV6sT59+sgwjHLX22w2zZw5UzNnziy3TbNmzbR8+fIKX6dLly767LPPKmwzaNAgDRo0qNz1ycnJVz3Wp08f7d69u8LtJiQkKCEhocI2AFCXVDU7AAB1D9kBALCK7AAAWEV2AACsIjsAAFaRHQAAq8gOAIAzVWpiycCBA7VmzRp17NhRNpvNvL1WyX+//vprR9cJAHBRZAcAwCqyAwBgFdkBALCK7AAAWEV2AACsIjsAAFaRHQAAZ6rUxJI1a9ZIkrKyshxaDADA/ZAdAACryA4AgFVkBwDAKrIDAGAV2QEAsIrsAABYRXYAAJzJw0rjnj17VuoxAABKkB0AAKvIDgCAVWQHAMAqsgMAYBXZAQCwiuwAAFhFdgAAnKlSdyw5ffq0Tpw4ofz8fGVmZsowDElSXl6e8vLyHFogAMB1ZWZmkh0AAEvIDgCAVWQHAMAqsgMAYBXZAQCwiuwAAFhFdgAAnK1SE0vWrl2r5ORkfffdd4qPjzdDq3Hjxvrzn//s0AIBAK5r4sSJZAcAwBKyAwBgFdkBALCK7AAAWEV2AACsIjsAAFaRHQAAZ6vUxJK4uDjFxcVp9erVGjBggINLAgC4izVr1mjjxo1kBwCg0sgOAIBVZAcAwCqyAwBgFdkBALCK7AAAWEV2AACczcNK4wMHDujHH3/U5cuXNWjQIN16661avXq1g0oDALgDsgMAYBXZAQCwiuwAAFhFdgAArCI7AABWkR0AAKuqmh2zZ8/W7bffrsaNG6tly5YaMGCADh06ZNemT58+stlsdsuYMWPs2mRnZysmJkYNGjRQy5YtNXHiRF26dMmuzebNm9W9e3d5e3vrlltuUXJy8lX1LFy4UDfddJN8fHwUERGhHTt2XLMPq1atUmhoqHx8fNS5c2etW7fObr1hGJo6daqCg4Pl6+urqKgoHT58uJLvEACgIpYmlqxatUqNGzfWmjVr5OPjo88//1wzZsxwVG0AADdAdgAArCI7AABWkR0AAKvIDgCAVWQHAMAqsgMAYFVVs2PLli2Kj4/Xtm3blJqaqosXL+r+++/X+fPn7dqNGjVKx48fN5eXXnrJXHf58mXFxMSoqKhIW7du1ZIlS5ScnKypU6eabbKyshQTE6O+fftqz549Gj9+vEaOHKn169ebbd577z0lJiZq2rRp2rVrl7p27aro6GidPHmy3Pq3bt2qIUOGaMSIEdq9e7cGDBigAQMGaN++fWabl156Sa+99pqSkpK0fft2NWzYUNHR0bpw4UKl3ycAQNksTSwpKCiQJH344YcaPHiwWrZsKcMwHFIYAMA9kB0AAKvIDgCAVWQHAMAqsgMAYBXZAQCwiuwAAFhV1exISUnRE088oY4dO6pr165KTk5Wdna2MjIy7No1aNBAQUFB5uLn52eu++STT3TgwAEtW7ZM3bp10wMPPKBZs2Zp4cKFKioqkiQlJSUpJCREc+bMUVhYmBISEvTrX/9ac+fONbfz6quvatSoURo+fLg6dOigpKQkNWjQQIsXLy63/vnz56t///6aOHGiwsLCNGvWLHXv3l0LFiyQdOVuJfPmzdOUKVP0yCOPqEuXLlq6dKmOHTvGXcEAoBpYmljy8MMPq23btsrIyND999+vU6dOydvb21G1waLs7Gzt2rVLmZmZzi4FAExkBwDAKrIDAGAV2QEAsIrsAABYRXYAAKwiOwAAVlV3dpw7d06S1KxZM7vH3333XQUEBKhTp06aPHmyfvrpJ3Ndenq6OnfurMDAQPOx6Oho5eXlaf/+/WabqKgou21GR0crPT1dklRUVKSMjAy7Nh4eHoqKijLblOVa283KylJOTo5dG39/f0VERJS73cLCQuXl5dktAICyWZpY8vLLL2v37t3atWuX6tevrwYNGujDDz90VG2wIDs7W6GhoQoPD9djjz3m7HIAwER2AACsIjsAAFaRHQAAq8gOAIBVZAcAwCqyAwBgVXVmR3FxscaPH68777xTnTp1Mh//7W9/q2XLlmnTpk2aPHmy/u///s/uO6c5OTl2k0okmb/n5ORU2CYvL08FBQU6ffq0Ll++XGabkm2Upbztln7d0vVUZruzZ8+Wv7+/ubRu3brc1weAus7SxJLc3Fy9+OKLevzxxyVJ33//vT777DOHFAZrTp8+rYKCAsXGxqpv377OLgcATGQHAMAqsgMAYBXZAQCwiuwAAFhFdgAArCI7AABWVWd2xMfHa9++fVqxYoXd46NHj1Z0dLQ6d+6soUOHaunSpfrggw909OjRKtdfG02ePFnnzp0zl++++87ZJQFArWVpYklcXJzCwsK0b98+SVJISIhmzZrlkMJwfQICAtS0aVNnlwEApqpmx+zZs3X77bercePGatmypQYMGKBDhw7ZtenTp49sNpvdMmbMGLs22dnZiomJUYMGDdSyZUtNnDhRly5dsmuzefNmde/eXd7e3rrllluUnJx8VT0LFy7UTTfdJB8fH0VERGjHjh3X7MOqVasUGhoqHx8fde7cWevWrbNbbxiGpk6dquDgYPn6+ioqKkqHDx+u5DsEAO6HcQcAwCqyAwBgFdkBALCK7AAAWMW5cs6VA4BV1TXuSEhI0Jo1a7Rp0ybdeOONFbaNiIiQJB05ckSSFBQUpBMnTti1Kfk9KCiowjZ+fn7y9fVVQECAPD09y2xTso2ylLfd0q9bup7KbNfb21t+fn52CwCgbJYmlhw7dkzDhw+Xp6enJMnLy0seHpY2AQCoY6qaHVu2bFF8fLy2bdum1NRUXbx4Uffff7/Onz9v127UqFE6fvy4ubz00kvmusuXLysmJkZFRUXaunWrlixZouTkZE2dOtVsk5WVpZiYGPXt21d79uzR+PHjNXLkSK1fv95s89577ykxMVHTpk3Trl271LVrV0VHR+vkyZPl1r9161YNGTJEI0aM0O7duzVgwAANGDDAHABK0ksvvaTXXntNSUlJ2r59uxo2bKjo6GhduHCh0u8TALgTxh0AAKvIDgCAVWQHAMAqsgMAYBXnyjlXDgBWVTU7DMNQQkKCPvjgA23cuFEhISHXfM6ePXskScHBwZKkyMhI7d27124fn5qaKj8/P3Xo0MFsk5aWZred1NRURUZGmnWHh4fbtSkuLlZaWprZpizX2m5ISIiCgoLs2uTl5Wn79u0VbhcAUDmWjnQ1bNhQubm5stlskqRdu3apcePGDikMAOAeqpodKSkpeuKJJ9SxY0d17dpVycnJys7OVkZGhl27Bg0aKCgoyFxKzy7/5JNPdODAAS1btkzdunXTAw88oFmzZmnhwoUqKiqSJCUlJSkkJERz5sxRWFiYEhIS9Otf/1pz5841t/Pqq69q1KhRGj58uDp06KCkpCQ1aNBAixcvLrf++fPnq3///po4caLCwsI0a9Ysde/eXQsWLJB0ZUA3b948TZkyRY888oi6dOmipUuX6tixY1q9enWl3ycAcCdVzY7KXMHrwoULio+PV/PmzdWoUSMNHDjwqquacAUvAHAdNZEdXP0RANwL5zsAAFYx7mDcAQBWca6cc+UAYFVVsyM+Pl7Lli3T8uXL1bhxY+Xk5CgnJ0cFBQWSpKNHj2rWrFnKyMjQN998o48++kjDhg3T3XffrS5dukiS7r//fnXo0EGPP/64vvzyS61fv15TpkxRfHy8vL29JUljxozR119/rUmTJungwYNatGiRVq5cqQkTJpi1JCYm6s0339SSJUuUmZmpsWPH6vz58xo+fLjZZtiwYZo8ebL5+7hx45SSkqI5c+bo4MGDmj59unbu3KmEhARJks1m0/jx4/XCCy/oo48+0t69ezVs2DC1atVKAwYMuL43HQBgsjSxZM6cORowYICysrLUr18/DR48WK+99pqjagMAuIHqzo5z585Jkpo1a2b3+LvvvquAgAB16tRJkydP1k8//WSuS09PV+fOnRUYGGg+Fh0drby8PO3fv99sExUVZbfN6OhopaenS5KKioqUkZFh18bDw0NRUVFmm7Jca7tZWVnKycmxa+Pv76+IiIgKtwsA7qyq2VGZK3hNmDBBH3/8sVatWqUtW7bo2LFjio2NNddzBS8AcC01kR0SV38EAHfC+Q4AgFWMOxh3AIBVnCuv/nPlhYWFysvLs1sAwJ1UNTtef/11nTt3Tn369FFwcLC5vPfee5Ku3Elkw4YNuv/++xUaGqo//OEPGjhwoD7++GNzG56enlqzZo08PT0VGRmpxx57TMOGDdPMmTPNNiEhIVq7dq1SU1PVtWtXzZkzR2+99Zaio6PNNo8++qheeeUVTZ06Vd26ddOePXuUkpJil0nZ2dk6fvy4+XuvXr20fPlyvfHGG+ratav+8Y9/aPXq1erUqZPZZtKkSXrqqac0evRo3X777crPz1dKSop8fHysvdkAgKvUs9I4PDxcGzZs0KFDh1RcXKzQ0FDVr1/fUbUBANxAdWZHcXGxxo8frzvvvNNuwPDb3/5Wbdu2VatWrfTVV1/pmWee0aFDh/T+++9LknJycuwGJZLM33Nycipsk5eXp4KCAp09e1aXL18us83BgwfLrbm87ZZ+3dL1lNXm5woLC1VYWGj+zsEyAO6mqtmRkpJi93tycrJatmypjIwM3X333Tp37pzefvttLV++XPfee68k6Z133lFYWJi2bdumO+64w7yC14YNGxQYGKhu3bpp1qxZeuaZZzR9+nR5eXnZXcFLksLCwvT5559r7ty55gGz0lfwkq5c9Wvt2rVavHixnn322TLrL30FL0maNWuWUlNTtWDBAiUlJV11BS9JWrp0qQIDA7V69WoNHjzYwrsNAO7B0dlRouTqj2UhOwDAtXC+AwBgFeMOxh0AYBXnyqv/XPns2bM1Y8aMcl8TAFxdVbPDMIwK17du3Vpbtmy55nbatm171R0Kf65Pnz7avXt3hW0SEhLMu42UZfPmzVc9NmjQIA0aNKjc59hsNs2cOdNuogsAoHpYumOJJNWrV08dO3ZU586dOckCAKiU6sqO+Ph47du3TytWrLB7fPTo0YqOjlbnzp01dOhQLV26VB988IGOHj1a1dJrpdmzZ8vf399cWrdu7eySAKDaVee44+dX8MrIyNDFixftroAVGhqqNm3amFfA4gpeAOB6HJkdJbj6IwC4F853AACsYtzBuAMArOJcefWaPHmyzp07Zy7fffeds0sCgGrHMSsAgLNYnlgC95GZmaldu3YpOzvb2aUAwDUlJCRozZo12rRpk2688cYK20ZEREiSjhw5IkkKCgrSiRMn7NqU/F5y1a/y2vj5+cnX11cBAQHy9PQss015Vw6raLulX7d0PZXZLgfLAKDyyrqCV05Ojry8vNSkSRO7tj+/SlZVr+B1+vTpcq/gVd6VtirablWv4MWkRAConIqu/rhs2TJt2rRJkydP1v/93//pscceM9eTHQAAAAAqi3HHFYw7AKByOFf+P97e3vLz87NbAAAAAFQPJpbUQfn5+bLZbHrssccUHh6u0NBQJpcAqLUMw1BCQoI++OADbdy4USEhIdd8zp49eyRJwcHBkqTIyEjt3btXJ0+eNNukpqbKz89PHTp0MNukpaXZbSc1NVWRkZGSJC8vL4WHh9u1KS4uVlpamtmmLNfabkhIiIKCguza5OXlafv27eVul4NlAFB55V3Bq65hUiIAVB5Xf7yC7AAAAAAch3HHFYw7AKBinCsHAAAAUJMqNbFk/vz55s+7du1yWDGoGRcuXJBhGIqNjVVsbKx5ZRoAcJSqZEd8fLyWLVum5cuXq3HjxsrJyVFOTo4KCgokSUePHtWsWbOUkZGhb775Rh999JGGDRumu+++W126dJEk3X///erQoYMef/xxffnll1q/fr2mTJmi+Ph4eXt7S5LGjBmjr7/+WpMmTdLBgwe1aNEirVy5UhMmTDBrSUxM1JtvvqklS5YoMzNTY8eO1fnz5zV8+HCzzbBhwzR58mTz93HjxiklJUVz5szRwYMHNX36dO3cuVMJCQmSJJvNpvHjx+uFF17QRx99pL1792rYsGFq1aqVBgwYcN3vGwC4uuoYd5R3Ba+goCAVFRUpNzfXrv3Pr5LFFbwAwLU4MjvKwtUfAcD1cb4DAGAV4w7GHQBgFefKOVcOAFZxzAoA4CyVmliyZMkS8+eRI0c6rBjUrICAAAUEBDi7DAB1QFWy4/XXX9e5c+fUp08fBQcHm8t7770n6crVUTZs2KD7779foaGh+sMf/qCBAwfq448/Nrfh6empNWvWyNPTU5GRkXrsscc0bNgwzZw502wTEhKitWvXKjU1VV27dtWcOXP01ltvKTo62mzz6KOP6pVXXtHUqVPVrVs37dmzRykpKXa3dc/Oztbx48fN33v16qXly5frjTfeUNeuXfWPf/xDq1evtru1/aRJk/TUU09p9OjRuv3225Wfn6+UlBT5+Phc9/sGAK6uKtlxrSt4hYeHq379+nZXwDp06JCys7PNK2BxBS8AcD2OzI6ycPVHAHB9nO8AAFjFuINxBwBYxblyzpUDgFUcswIAOEs9ZxcAAEBFDMOocH3r1q21ZcuWa26nbdu2WrduXYVt+vTpo927d1fYJiEhwbyCSlk2b9581WODBg3SoEGDyn2OzWbTzJkz7Q7eAQCuX3x8vJYvX64PP/zQvIKXJPn7+8vX11f+/v4aMWKEEhMT1axZM/n5+empp55SZGSk7rjjDkn2V/B66aWXlJOTU+YVvBYsWKBJkybpySef1MaNG7Vy5UqtXbvWrCUxMVFxcXHq0aOHevbsqXnz5pV5Ba8bbrhBs2fPlnTlCl733HOP5syZo5iYGK1YsUI7d+7UG2+8Icn+Cl7t2rVTSEiInn/+ea7gBQBVcK3sOHr0qJYvX64HH3xQzZs311dffaUJEyaUe/VHsgMAAADAzzHuAABYxblyAAAAADWpUhNLTp06pUWLFskwDPPn0n73u985pDgAgGt788035ePjQ3YAACqtOrLj9ddfl3TlJEhp77zzjp544glJ0ty5c+Xh4aGBAweqsLBQ0dHRdq9XcgWvsWPHKjIyUg0bNlRcXFyZV/CaMGGC5s+frxtvvLHMK3idOnVKU6dOVU5Ojrp161bmFbw8PP53M8mSK3hNmTJFzz33nNq1a1fmFbzOnz+v0aNHKzc3V7179+YKXgDqrJrIjpKrP5Z82ap169YaOHCgpkyZYrYlOwDAdXDMCgBgFeMOxh0AYBXjDgCAVWQHAMDZKjWxZOTIkTp16tRVPwMAUJEzZ87I29ub7AAAVFp1ZMe1ruAlST4+Plq4cKEWLlxYbhuu4AUArqEmsoOrPwKAe+GYFQDAKsYdVzDuAIDKY9wBALCK7AAAOFulJpZMmzbN0XUAANzQs88+Kz8/P2eXAQBwIWQHAMAqsgMAYBXZAQCwiuwAAFhFdgAArCI7AADOVqmJJde6osjUqVOrpRgAgHv5y1/+Im9v7zLXkR0AgLKQHQAAq8gOAIBVZAcAwCqyAwBgFdkBALCK7AAAOJtHZRrNnDlT77//viQpICBAzZs3t1sAACjLxx9/LInsAABUHtkBALCK7AAAWEV2AACsIjsAAFaRHQAAq8gOAICzVeqOJd9//73+8Y9/6IMPPpCXl5cGDRqkX/3qV2ratKmj6wMAuLBhw4bpX//6F9kBAKg0sgMAYBXZAQCwiuwAAFhFdgAArCI7AABWkR0AAGer1B1LgoKClJCQoLS0NC1evFjnzp1TWFiYlixZ4uj6AAAubPTo0WQHAMASsgMAYBXZAQCwiuwAAFhFdgAArCI7AABWkR0AAGer1B1LJMkwDG3ZskXvvfeeduzYoSFDhujOO+90ZG0AABdnGIY2b95MdgAAKo3sAABYRXYAAKwiOwAAVpEdAACryA4AgFVkBwDA2So1sSQhIUHbtm3TXXfdpWHDhun11193dF0AADfQp08f9enTh+wAAFQa2QEAsIrsAABYRXYAAKwiOwAAVpEdAACryA4AgLNVamLJokWL1KxZM3377bdatmyZbDabpCszJG02m06ePOnQIgEArik7O1vLli0jOwAAlUZ2AACsIjsAAFaRHQAAq8gOAIBVZAcAwCqyAwDgbJWaWFJcXOzoOgAAbigrK0t+fn7OLgMA4ELIDgCAVWQHAMAqsgMAYBXZAQCwiuwAAFhFdgAAnK1SE0suXLigpKQkHTlyRF26dNGTTz6pevUq9VQAQB22aNEiff/992QHAKDSyA4AgFVkBwDAKrIDAGAV2QEAsIrsAABYRXYAAJzNozKN4uLitHPnTnXu3Fnr1q3T008/7ei64CTZ2dnatWuXdu3apezsbGeXA8DF7d69m+wAAFhCdgAArCI7AABWkR0AAKvIDgCAVWQHAMAqsgMA4GyVmtJ44MAB7d27V5I0YsQI9ezZ06FFwTmys7MVGhqqgoICSZK3t7f++c9/qnPnzmrTpo2TqwPgit588035+fmRHQCASiM7AABWkR0AAKvIDgCAVWQHAMAqsgMAYBXZAQBwtkpNLKlfv/7/nsDttdxSZmamJKmgoECxsbH66aeftH79ej300EPmBJPg4GAFBAQwyQSAZWQHAMAqsgMAYBXZAQCwiuwAAFhFdgAArCI7AABWkR0AAGepVAJ99dVXatmypSTJMAzl5uaqZcuWMgxDNptNJ0+edGiRcJz8/HzZbP/P3r3HRVnn//9/DigHD2BKHMwTlYXmgbREsuzEhoVtLK6lq2lm+tGFVmVTs4+H0opy89SqsR1M+xRrumta6mKIaQdRE6U0hU2zqK+OhwoR5aBy/f7wx8QoIJcMDDM87rfb3IS53nPN67rU6znv65r39bZo6NChtucCAgJ04sQJGYahXr166csvv1T//v0lSb6+vsrOzmZwCYBque6662SxWMgOAEC1kR0AALPIDgCAWWQHAMAssgMAYBbZAQAwi+wAADhbtQaWnDt3rrbrgJMUFRXJMAzFxcXp119/1SeffGK33Nvb27ZcklatWqUTJ04wsARAtRw8eFB+fn7OLgMA4ELIDgCAWWQHAMAssgMAYBbZAQAwi+wAAJhFdrie/fv3S7pwM3e+UwvAHTBnFiRdCLbqLicMAQAAAAAAAAAAAAAAAAAA0NAUFBTIYrFo6NChkiRfX19lZ2fzfVoALo+BJag2whAAAAAAAAAAAAAAAAAAAAANVVFRkQzDUFxcnCRp1apVOnHiBN+lBeDyPJxdAFxH+TCMi4tTYWGhTpw44eyyAAAAAAAAAAAAAAAAAAAAgDoTEBCggIAAZ5cBAA7DjCUwjSAEAAAAUGb//v2SLvQTuAMLAAAAAAAAAAAAAAAA4HoYWAIAAAAAMK2goEAWi0VDhw6VJPn6+io7O5vBJQAAAAAAAAAAAAAAAICL8XB2AQAAAAAA11NUVCTDMBQXF6e4uDgVFhbqxIkTzi4LAAAAAAAAAAAAAAAAgEnMWIIa2b9/vyQpICCAOxMDgBvguA4AMCsgIMDZJQAAAAAAAAAAANQI18oBAADQ0DGwBFekoKBAFotFQ4cOlSR5e3vr3//+t7p27UrnCgBc0MXHdV9fX2VnZ3NMBwAAAAAAAAAAAAC4La6VAwAcYf/+/QxOBODyPJxdAFxTUVGRDMNQXFyc+vXrp5KSEvXv319hYWHKzc11dnkAAJPKH9fj4uJUWFioEydOOLssAAAAAAAAAAAAAABqDdfKAQA1UX6AIt+fBeDqGFiCGgkICFCTJk1kGIb69u1L5woAXFxAQIACAgKcXQYAwEXt37+fE2UAAAAAAAAAAMDlcK0cAHAlygYo8v1ZAO6gwQ8sWbRokTp06CAfHx9FRERox44dVbZfuXKlwsLC5OPjo65du2r9+vV2yw3D0PTp0xUSEiJfX19FRUXp22+/rc1NqDf8/f0lXfgy2a5du/hCGQC31VCygy8HA4DjuHt2cBcWAHA8d88OAIDjkR0AALPIDgCAWWQHAMCshpIdZd+fBQBX1qAHlrz//vtKTEzUjBkztGvXLnXv3l3R0dE6duxYhe23bt2qwYMHa+TIkdq9e7diY2MVGxurvXv32trMnj1br776qpKTk7V9+3Y1bdpU0dHRKioqqqvNcpozZ87YvkzWs2dP3XDDDVq3bh2DTAC4lYaQHXw5GAAcqyFkx8V3Yfnss8/oBwBADbh7dnBTEgBwPHfPDgCA47l7dtDvAADHc/fsAAA4XkPMDvoiAFxZgx5YMnfuXI0aNUojRoxQ586dlZycrCZNmmjJkiUVtl+wYIH69euniRMnqlOnTpo1a5Z69OihhQsXSrowEnL+/PmaOnWqHnroIXXr1k3vvPOODh8+rNWrV9fhljlHSUmJDMNQXFyc+vXrp5KSEvXv359BJgDcSkPIDr4cDACO1RCyo0zjxo3tBpszQBEAroy7Zkf5QezkBAA4lrtmRxkuyAOA47lrdlzc7yi7Tk2GAEDNuWt2VGT//v1kBwA4QEPKjqpuzJ6RkaFdu3ZxfgtAvdfI2QU4S0lJiTIzMzVlyhTbcx4eHoqKilJGRkaFr8nIyFBiYqLdc9HR0bZAOnTokKxWq6KiomzL/f39FRERoYyMDA0aNMjxG1IPBQQE6MSJE7ZBJmfOnNGGDRvUv39/SZK3t7f+/e9/KyQkRMXFxfL29rb9KcnUz2ZfFxAQoHbt2tXRngDgbhpadpT/crBU8fFb4jgLAFVpaNlRfrC5JK1atUqfffaZOnXq5NDP9nXVf6jL19Xn2hz9uvKfF3Jzc3XixAm7tnyeQEPnztlRNoj94py49tprOc5e5nWVHTs5ZgKQ3Ds7yn85WPrt/FTLli25pgAANeDO2VG+31H+OnV1rnE0lPNC5BuAK+HO2VFe+T5IQ8oOsgFAbWgo2VGm/LXyi78za7FYZBiGJOd9f7a+XO+43LWPyjKJayNA3WiwA0tOnDih8+fPKygoyO75oKAgZWdnV/gaq9VaYXur1WpbXvZcZW0uVlxcrOLiYtvvJ0+elCTl5+eb2JoLHRtJOnLkiPLy8i75uWy9lS13xOsqanv27FmdPn1ahmHotttuU3FxsTIzM22BWde8vb31f//3fwoJCVFpaamkCx9Wqvr5cstd8XX1uTb2Rf3bpuDgYAUHB8uMsmNY2Qdid9HQsuP48eOmj98cZ+t/bewLtonsqFsNLTvK1nv27FkVFhZKku0LYECZss8LkvToo4/a/dssvzwoKKjeHS+v9HX1ubb6sk1kx28aQnaQE+ZVduykD1b/a2Obam9fkB2/cffscOb1BY6z9b82tsk1aqsv+4Ls+I27Z4dkf536hhtu0H//+1+nXaOub+ri3Et9PkawTewLsuPKNITsKN8HaWjZcbls4NjCvmCbyI4r0ZCyo/x6L/7ObEFBgb7++ut68f3Z+qaiax8VZdLRo0drfG2k/M/1+dhypa+rz7WxTa6VHQ12YEl9kZSUpOeee+6S59u2bXtF6/voo48q/Pnrr7+ucrkjXne5tlu3bjWzKbWiuLhYDz/8sLPLABqMn3/+Wf7+/s4uw+3UdXaYOX5znAVQU6dOnSI7aoEz+x3AxS73eYHPEzCL7KgddZUdqJ7Kjo0cM4ErQ3bUjtrMDmddX+A4C6AM2VE76qrf8d///veK1ueuyDegbpAdtYPsqB1kA1A/kB21w5nXysuf06oP35+tbyrKn+pkErkF/MbR2dFgB5YEBATI09NTR48etXv+6NGjlY76CQ4OrrJ92Z9Hjx5VSEiIXZvw8PAK1zllyhS7qbtKS0v1yy+/qFWrVrJYLNXenvz8fLVt21Y//vij/Pz8qv26hoR9dHnso+phP13eyZMn1a5dO7Vs2dLZpTgU2VF/ULvzuHL91O4c1a3dMAydOnVKrVu3rsPqah/Z0bCwfyrHvqka+6dqle0fsuM3ZEftcNXaXbVuyXVrd9W6pYZXO9nxG7Kj/mhI29uQtlVie90F2fEbssPxqLtuUXfdccWaJcfVTXb8huyoe2yXa3HX7ZLcd9tqa7vIjt+QHc7VELZRahjbyTa6j7q+Vt5gB5Z4eXmpZ8+eSk9PV2xsrKQLgZGenq6EhIQKXxMZGan09HSNHz/e9lxaWpoiIyMlSaGhoQoODlZ6erotpPLz87V9+3aNHTu2wnV6e3vL29vb7rkWLVpc8Xb5+fm59X8QR2AfXR77qHrYT5fn4eHh7BIciuyof6jdeVy5fmp3jurU7o53XyE7Gib2T+XYN1Vj/1Stov1DdlxAdtQuV63dVeuWXLd2V61bali1kx0XkB31T0Pa3oa0rRLb6w7IjgvIjtpD3XWLuuuOK9YsOaZusuMCssN52C7X4q7bJbnvttXGdpEdF5Ad9UND2EapYWwn2+g+6upaeYMdWCJJiYmJGj58uG655Rb16tVL8+fP1+nTpzVixAhJ0rBhw3TNNdcoKSlJkjRu3DjdeeedmjNnjmJiYrR8+XLt3LlTr7/+uiTJYrFo/Pjxev7559WxY0eFhoZq2rRpat26tS0YAQCujewAAJhFdgAAzCI7AABmkR0AALPIDgCAWWQHAMAssgMAXEuDHljyyCOP6Pjx45o+fbqsVqvCw8OVmpqqoKAgSVJubq7d3fZvu+02paSkaOrUqXrmmWfUsWNHrV69Wl26dLG1mTRpkk6fPq3Ro0crLy9Pt99+u1JTU+Xj41Pn2wcAcDyyAwBgFtkBADCL7AAAmEV2AADMIjsAAGaRHQAAs8gOAHAxBtxCUVGRMWPGDKOoqMjZpdRb7KPLYx9VD/vp8thHrsGV/56o3XlcuX5qdw5Xrh2X4u+zauyfyrFvqsb+qRr7x7W58t+fq9buqnUbhuvW7qp1Gwa1o35qaH+3DWl7G9K2GgbbC9QlV/33R911i7rrjivWbBiuWzeujLv+fbNdrsVdt8sw3Hfb3HW7UD0N4e+/IWyjYTSM7WQb3Uddb6fFMAzD2YNbAAAAAAAAAAAAAAAAAAAAAAAAUPc8Lt8EAAAAAAAAAAAAAAAAAAAAAAAA7oiBJQAAAAAAAAAAAAAAAAAAAAAAAA0UA0sAAAAAAAAAAAAAAAAAAAAAAAAaKAaWAAAAAAAAAAAAAAAAAAAAAAAANFAMLHEDixYtUocOHeTj46OIiAjt2LHD2SXVqU8//VQPPvigWrduLYvFotWrV9stNwxD06dPV0hIiHx9fRUVFaVvv/3Wrs0vv/yiIUOGyM/PTy1atNDIkSNVUFBQh1tRe5KSknTrrbeqefPmCgwMVGxsrHJycuzaFBUVKT4+Xq1atVKzZs00YMAAHT161K5Nbm6uYmJi1KRJEwUGBmrixIk6d+5cXW5KrXrttdfUrVs3+fn5yc/PT5GRkfrPf/5jW84+svfSSy/JYrFo/PjxtufYR66lPmRHXR2/v/76a91xxx3y8fFR27ZtNXv27BrXXpfH1s2bN6tHjx7y9vbW9ddfr6VLl9ao9ro63jm67orU5rGoNup/9tlnZbFY7B5hYWEuUbsk/b//9/80dOhQtWrVSr6+vuratat27txpW16f/8/CMepDdjgDn6erj8+Il6qrY6crOn/+vKZNm6bQ0FD5+vrquuuu06xZs2QYhq1NQ94/7qQ+5Ud1jul33XXXJZ/ZxowZY9fGGcetuvosWRs6dOhwSe0Wi0Xx8fGS6s8+d+U+alW1nz17VpMnT1bXrl3VtGlTtW7dWsOGDdPhw4ft1lHR39NLL73k1Nol6bHHHrukrn79+tm1oZ/hfupTdlwpVz5uX44rHy+vREM6TrnyOU+gPmWHO5xLcrVzPK52/sVVzom4auY7on/kKtmNmqlP2XE5rnxOqyru2m9ylXNh1eGqWVCT7arv59LgXK6UHeW5Qx/FLFfr05jhav0fs1ylv2SWS2WqAZe2fPlyw8vLy1iyZInxzTffGKNGjTJatGhhHD161Nml1Zn169cb//u//2usWrXKkGR88MEHdstfeuklw9/f31i9erXx1VdfGb///e+N0NBQo7Cw0NamX79+Rvfu3Y1t27YZn332mXH99dcbgwcPruMtqR3R0dHG22+/bezdu9fIysoyHnjgAaNdu3ZGQUGBrc2YMWOMtm3bGunp6cbOnTuN3r17G7fddptt+blz54wuXboYUVFRxu7du43169cbAQEBxpQpU5yxSbXiww8/NNatW2f897//NXJycoxnnnnGaNy4sbF3717DMNhH5e3YscPo0KGD0a1bN2PcuHG259lHrqO+ZEddHL9PnjxpBAUFGUOGDDH27t1r/POf/zR8fX2Nf/zjHzWqva6Ord99953RpEkTIzEx0di3b5/x97//3fD09DRSU1OvuPa6ON7VRt0Xq81jUW3VP2PGDOOmm24yjhw5YnscP37cJWr/5ZdfjPbt2xuPPfaYsX37duO7774zNmzYYBw4cMDWpj7/n0XN1ZfscAY+T1cPnxEvVVfHTlf1wgsvGK1atTLWrl1rHDp0yFi5cqXRrFkzY8GCBbY2DXn/uIv6lh/VOabfeeedxqhRo+w+s508edK23FnHrbr4LFlbjh07Zld3WlqaIcn45JNPDMOoP/vclfuoVdWel5dnREVFGe+//76RnZ1tZGRkGL169TJ69uxpt4727dsbM2fOtPt7KP9/wxm1G4ZhDB8+3OjXr59dXb/88otdG/oZ7qW+ZceVcuXj9uW48vHySjSk45Qrn/NEw1bfssPVzyW52jkeVzz/4irnRFw18x3RP3KV7MaVq2/ZcTmufE6rKu7ab3KVc2HV4apZUJPtqu/n0uA8rpYd5bl6H8UsV+vTmOGK/R+zXKW/ZJYrZSoDS1xcr169jPj4eNvv58+fN1q3bm0kJSU5sSrnufg/XGlpqREcHGz87W9/sz2Xl5dneHt7G//85z8NwzCMffv2GZKML7/80tbmP//5j2GxWIz/9//+X53VXleOHTtmSDK2bNliGMaF/dG4cWNj5cqVtjb79+83JBkZGRmGYVw4qHl4eBhWq9XW5rXXXjP8/PyM4uLiut2AOnTVVVcZb775JvuonFOnThkdO3Y00tLSjDvvvNP24Yt95FrqY3bU1vF78eLFxlVXXWX3b2zy5MnGjTfe6ND6a+vYOmnSJOOmm26ye69HHnnEiI6Odmj9jj7e1XbdtX0sqq36Z8yYYXTv3r3CZfW99smTJxu33357pctd7f8szKuP2eEsfJ6+FJ8RK1ZXx05XFRMTYzz++ON2z8XFxRlDhgwxDIP94y7qe35cfEw3DMPuOFYRZx236uKzZF0ZN26ccd111xmlpaWGYdTPfe7KfdSKLkhcbMeOHYYk44cffrA91759e2PevHmVvsZZtQ8fPtx46KGHKn1NfdnvcJz6nh3V5U7H7aq48vHySjS045Srn/NEw1Hfs8OVziW54jkeVzz/4ornRFw186+kf1Qf6kbtq+/ZcTmudE6rKg2l3+QK58Kqw1Wz4HJc+Vwa6parZ0d5rtRHMcsV+zRmuGL/xyxX7C+ZVd8z1cP8HCeoL0pKSpSZmamoqCjbcx4eHoqKilJGRoYTK6s/Dh06JKvVareP/P39FRERYdtHGRkZatGihW655RZbm6ioKHl4eGj79u11XnNtO3nypCSpZcuWkqTMzEydPXvWbh+FhYWpXbt2dvuoa9euCgoKsrWJjo5Wfn6+vvnmmzqsvm6cP39ey5cv1+nTpxUZGck+Kic+Pl4xMTF2+0Li35ErcZXscNTxOyMjQ3379pWXl5etTXR0tHJycvTrr786rN7aOrZmZGRc8v8tOjraYX9XtXW8q+26a/tYVJv1f/vtt2rdurWuvfZaDRkyRLm5uS5R+4cffqhbbrlFAwcOVGBgoG6++Wa98cYbtuWu9n8W5rhKdtQVPk9fis+IFaurY6eruu2225Senq7//ve/kqSvvvpKn3/+ue6//35J7B934Ar5cfExvcx7772ngIAAdenSRVOmTNGZM2dsy5x53Krtz5J1oaSkRO+++64ef/xxWSwW2/P1dZ+XcbfPuydPnpTFYlGLFi3snn/ppZfUqlUr3Xzzzfrb3/6mc+fO2ZY5s/bNmzcrMDBQN954o8aOHauff/7Zri5X2e+4PFfIDjPc4bhtlrsdL6vLXY9TrnrOEw2LK2SHK51LcsVzPK54/sUdzom4U+Zf3D9ylbpx5VwhOy7H1c5pVcXd+02uei6sOtwpCy7H1c6lwfHcITvKc6U+ilmu2KcxwxX7P2a5Q3/JrPqWqY1qukFwnhMnTuj8+fN2BzJJCgoKUnZ2tpOqql+sVqskVbiPypZZrVYFBgbaLW/UqJFatmxpa+MuSktLNX78ePXp00ddunSRdGH7vby8Lvnwe/E+qmgfli1zF3v27FFkZKSKiorUrFkzffDBB+rcubOysrLYR5KWL1+uXbt26csvv7xkGf+OXIerZIejjt9Wq1WhoaGXrKNs2VVXXVXjWmvz2FpZm/z8fBUWFsrX1/eKaq7t411t1S3VzbGotuqPiIjQ0qVLdeONN+rIkSN67rnndMcdd2jv3r31vvbvvvtOr732mhITE/XMM8/oyy+/1F/+8hd5eXlp+PDhLvV/Fua5SnbUBT5PX4rPiJWrq2Onq3r66aeVn5+vsLAweXp66vz583rhhRc0ZMgQSfTn3UF9z4+KjumS9Kc//Unt27dX69at9fXXX2vy5MnKycnRqlWrJDnvuFUXnyXrwurVq5WXl6fHHnvM9lx93efludPn3aKiIk2ePFmDBw+Wn5+f7fm//OUv6tGjh1q2bKmtW7dqypQpOnLkiObOnevU2vv166e4uDiFhobq4MGDeuaZZ3T//fcrIyNDnp6eLrPfUT31PTvMcJfjtlnudLysLnc9TrniOU80TPU9O1zpXJKrnuNxxfMv7nBOxF0yv6L+kSvUjZqp79lxOa52TqsqDaHf5KrnwqrDXbLgclztXBpqh6tnR3mu1Ecxy1X7NGa4Yv/HLHfoL5lV3zKVgSVAAxIfH6+9e/fq888/d3Yp9dKNN96orKwsnTx5Uv/61780fPhwbdmyxdll1Qs//vijxo0bp7S0NPn4+Di7HKBeccVjq6se71z9WFQ2el6SunXrpoiICLVv314rVqyo9xfMS0tLdcstt+jFF1+UJN18883au3evkpOTNXz4cCdXB9QdVzzm1yZXPy7XNo6dVVuxYoXee+89paSk6KabblJWVpbGjx+v1q1bs39QJyo7po8ePdr2c9euXRUSEqJ7771XBw8e1HXXXVfXZdq48mfJ8t566y3df//9at26te25+rrP3dHZs2f18MMPyzAMvfbaa3bLEhMTbT9369ZNXl5e+p//+R8lJSXJ29u7rku1GTRokO3nrl27qlu3brruuuu0efNm3XvvvU6rC7gcdzlu4/Lc9ThF/xdwDFf5v+TK53hc8fwL50Tqh6r6R0B95mrntKrSEPpNnAtzba54Lg24HFfpo5jlyn0aM1yx/2MW/SXn83B2AbhyAQEB8vT01NGjR+2eP3r0qIKDg51UVf1Sth+q2kfBwcE6duyY3fJz587pl19+cav9mJCQoLVr1+qTTz5RmzZtbM8HBwerpKREeXl5du0v3kcV7cOyZe7Cy8tL119/vXr27KmkpCR1795dCxYsYB/pwnRwx44dU48ePdSoUSM1atRIW7Zs0auvvqpGjRopKCiowe8jV+Eq2eGo43dt/7ur7WNrZW38/PxqdDKtto93tVV3XR2Laqv+i7Vo0UI33HCDDhw4UO/3fUhIiDp37mz3XKdOnWzTUbvK/1lcGVfJjtrG5+lL8RmxanV17HRVEydO1NNPP61Bgwapa9euevTRRzVhwgQlJSVJYv+4g/qcH5Ud0ysSEREhSTpw4ICk+nPcqo3PkrXthx9+0MaNG/XEE09U2a4+7nN3+LxbdiH8hx9+UFpamt0dFisSERGhc+fO6fvvv7fV5+y/B0m69tprFRAQYPfvoz7vd5hTn7OjplzxuH0l3OF4WVPucJxy1XOeaJjqc3a40rkkVz7H44rnX9zhnIirZ35V/aP6XDccoz5nx+W4wzmtqrhbv8mVz4VVh6tnweW4y7k0OIYrZ0d5rtRHMcuV+zRmuGL/xyx36C+ZVd8ylYElLszLy0s9e/ZUenq67bnS0lKlp6crMjLSiZXVH6GhoQoODrbbR/n5+dq+fbttH0VGRiovL0+ZmZm2Nps2bVJpaantw7srMwxDCQkJ+uCDD7Rp06ZLpjrq2bOnGjdubLePcnJylJuba7eP9uzZY3dgKvvQfHFQuZPS0lIVFxezjyTde++92rNnj7KysmyPW265RUOGDLH93ND3katwlexw1PE7MjJSn376qc6ePWtrk5aWphtvvLFGU4vW1bE1MjLSbh1lbRz9d+Xo411t1V1Xx6K62u8FBQU6ePCgQkJC6v2+79Onj3Jycuye++9//6v27dtLqv//Z1EzrpIdtYXP05XjM2LV6urY6arOnDkjDw/701Kenp4qLS2VxP5xB/UxPy53TK9IVlaWpAsn66X6c9yqjc+Ste3tt99WYGCgYmJiqmxXH/e5q3/eLbsQ/u2332rjxo1q1arVZV+TlZUlDw8P29Tq9eWz+k8//aSff/7Z7t9Hfd3vMK8+ZoejuOJx+0q4+vHSEVz5OOVu5zzRMNTH7HDFc0mufI7HFc+/uMM5EVfO/Mv1j+pr3XCc+pgdl+NO57Sq4m79Jlc+F1YdrpwFl+NO59LgGK6YHeW5Yh/FLFfu05jhiv0fs9yhv2RWvctUAy5t+fLlhre3t7F06VJj3759xujRo40WLVoYVqvV2aXVmVOnThm7d+82du/ebUgy5s6da+zevdv44YcfDMMwjJdeeslo0aKFsWbNGuPrr782HnroISM0NNQoLCy0raNfv37GzTffbGzfvt34/PPPjY4dOxqDBw921iY51NixYw1/f39j8+bNxpEjR2yPM2fO2NqMGTPGaNeunbFp0yZj586dRmRkpBEZGWlbfu7cOaNLly7GfffdZ2RlZRmpqanG1VdfbUyZMsUZm1Qrnn76aWPLli3GoUOHjK+//tp4+umnDYvFYnz88ceGYbCPKnLnnXca48aNs/3OPnId9SU76uL4nZeXZwQFBRmPPvqosXfvXmP58uVGkyZNjH/84x81qr2ujq3fffed0aRJE2PixInG/v37jUWLFhmenp5GamrqFddeF8e72qi7MrVxLKqt+v/6178amzdvNg4dOmR88cUXRlRUlBEQEGAcO3as3te+Y8cOo1GjRsYLL7xgfPvtt8Z7771nNGnSxHj33Xdtberz/1nUXH3JDmfg87Q5fEb8TV0dO13V8OHDjWuuucZYu3atcejQIWPVqlVGQECAMWnSJFubhrx/3EV9y4/LHdMPHDhg0fAagQABAABJREFUzJw509i5c6dx6NAhY82aNca1115r9O3b17YOZx236uKzZG06f/680a5dO2Py5Ml2z9enfe7KfdSqai8pKTF+//vfG23atDGysrLs/u0XFxcbhmEYW7duNebNm2dkZWUZBw8eNN59913j6quvNoYNG+bU2k+dOmU89dRTRkZGhnHo0CFj48aNRo8ePYyOHTsaRUVFtnXQz3Av9S07rpSrH7er4srHS0dvr7sdp1z5nCcatvqWHe5yLslVzvG44vkXVzkn4qqZX9P+kbPqRt2qb9lxOa58Tqsq7txvcoVzYdXhqllQk+2q7+fS4Dyulh3luUsfxSxX6dOY4Yr9H7Ncpb9klitlKgNL3MDf//53o127doaXl5fRq1cvY9u2bc4uqU598sknhqRLHsOHDzcMwzBKS0uNadOmGUFBQYa3t7dx7733Gjk5OXbr+Pnnn43BgwcbzZo1M/z8/IwRI0YYp06dcsLWOF5F+0aS8fbbb9vaFBYWGn/+85+Nq666ymjSpInxhz/8wThy5Ijder7//nvj/vvvN3x9fY2AgADjr3/9q3H27Nk63pra8/jjjxvt27c3vLy8jKuvvtq49957bV+yNgz2UUUu/vDFPnIt9SE76ur4/dVXXxm333674e3tbVxzzTXGSy+9VOPa6/LY+sknnxjh4eGGl5eXce2119q9x5Woq+Odo+uuTG0di2qj/kceecQICQkxvLy8jGuuucZ45JFHjAMHDrhE7YZhGB999JHRpUsXw9vb2wgLCzNef/11u+X1+f8sHKM+ZIcz8HnaHD4j2qurY6crys/PN8aNG2e0a9fO8PHxMa699lrjf//3f+0u4jfk/eNO6lN+XO6Ynpuba/Tt29do2bKl4e3tbVx//fXGxIkTjZMnT9qtxxnHrbr6LFlbNmzYYEi65P9wfdrnrtxHrar2Q4cOVfpv/5NPPjEMwzAyMzONiIgIw9/f3/Dx8TE6depkvPjii3ZfinZG7WfOnDHuu+8+4+qrrzYaN25stG/f3hg1atQlF2vpZ7if+pQdV8rVj9tVceXj5ZVoSMcpVz7nCdSn7HCXc0mudI7H1c6/uMo5EVfN/Jr2j5xVN+pefcqOy3Hlc1pVced+kyucC6sOV82CmmxXfT+XBudypewoz136KGa5Up/GDFfr/5jlKv0ls1wpUy2GYRgCAAAAAAAAAAAAAAAAAAAAAABAg+Ph7AIAAAAAAAAAAAAAAAAAAAAAAADgHAwsAQAAAAAAAAAAAAAAAAAAAAAAaKAYWAIAAAAAAAAAAAAAAAAAAAAAANBAMbAEAAAAAAAAAAAAAAAAAAAAAACggWJgCQAAAAAAAAAAAAAAAAAAAAAAQAPFwBIAAAAAAAAAAAAAAAAAAAAAAIAGioElAAAAAAAAAAAAAAAAAAAAAAAADRQDSwAAAAAAAAAAAAAAAAAAAAAAABooBpYALsBqterJJ5/UtddeK29vb7Vt21YPPvig0tPTJUkdOnSQxWKRxWKRr6+vOnTooIcfflibNm26ZF1/+ctf1LNnT3l7eys8PPyS5d9//71tXeUf27Ztq7C25cuXy2KxKDY21pGbDABwMEdmSUU5sXz5ctvyVatW6Xe/+52uvvpq+fn5KTIyUhs2bKizbQUA1B5H5cnPP/+sfv36qXXr1rb1JCQkKD8/3xmbBQCoRY7si3z55Ze699571aJFC1111VWKjo7WV199VdebBABwoLo8ZyVJxcXF+t///V+1b99e3t7e6tChg5YsWVIn2woAcIy6vHYuSStWrFB4eLiaNGmi9u3b629/+1ttbh4AoBbU5bWNzz//XH369FGrVq3k6+ursLAwzZs3r063FwBgXl32M4qKivTYY4+pa9euatSoEd+9Rb3CwBKgnvv+++/Vs2dPbdq0SX/729+0Z88epaam6u6771Z8fLyt3cyZM3XkyBHl5OTonXfeUYsWLRQVFaUXXnjhknU+/vjjeuSRR6p8340bN+rIkSO2R8+ePSus7amnntIdd9xR8w0FANSa2siSt99+2y4nyndyPv30U/3ud7/T+vXrlZmZqbvvvlsPPvigdu/eXRebCwCoJY7MEw8PDz300EP68MMP9d///ldLly7Vxo0bNWbMGGdsGgCgljgyOwoKCtSvXz+1a9dO27dv1+eff67mzZsrOjpaZ8+edcbmAQBqqK7PWUnSww8/rPT0dL311lvKycnRP//5T9144421vakAAAep62vn//nPfzRkyBCNGTNGe/fu1eLFizVv3jwtXLiw1rYRAOBYdX1to2nTpkpISNCnn36q/fv3a+rUqZo6dapef/31Ot1uAED11XU/4/z58/L19dVf/vIXRUVF1dp2AVeikbMLAFC1P//5z7JYLNqxY4eaNm1qe/6mm27S448/bvu9efPmCg4OliS1a9dOffv2VUhIiKZPn64//vGPtgsjr776qiTp+PHj+vrrryt931atWtnWV5Hz589ryJAheu655/TZZ58pLy+vJpsJAKhFjs4SSWrRokWlOTF//ny731988UWtWbNGH330kW6++WYHbhkAoC45Mk+uuuoqjR071vaa9u3b689//jN3fAQAN+PI7MjOztYvv/yimTNnqm3btpKkGTNmqFu3bvrhhx90/fXX1+3GAQBqrK7PWaWmpmrLli367rvv1LJlS0kX7jYJAHAddX3t/P/+7/8UGxtr+8LwtddeqylTpujll19WfHy8LBZLrW0rAMAx6vraxs0332x3TbxDhw5atWqVPvvsM40ePbo2NxUAcIXqup/RtGlTvfbaa5KkL774otLv3n700UeaOXOm9uzZo2bNmumOO+7QBx984JBtBirDjCVAPfbLL78oNTVV8fHxdoFVpkWLFlW+fty4cTIMQ2vWrDH93r///e8VGBio22+/XR9++OEly2fOnKnAwECNHDnS9LoBAHWntrIkPj5eAQEB6tWrl5YsWSLDMCpdR2lpqU6dOmW7YA8AcD213Tc5fPiwVq1apTvvvNMR5QIA6gFHZ8eNN96oVq1a6a233lJJSYkKCwv11ltvqVOnTnwpGABckDPOWX344Ye65ZZbNHv2bF1zzTW64YYb9NRTT6mwsNAh2wQAqF3OuHZeXFwsHx8fu+d8fX31008/6Ycffqj2egAAzlEfrm3s3r1bW7du5foHANRTzvyOblXWrVunP/zhD3rggQe0e/dupaenq1evXg59D6AizFgC1GMHDhyQYRgKCwu7ote3bNlSgYGB+v7776v9mmbNmmnOnDnq06ePPDw89O9//1uxsbFavXq1fv/730uSPv/8c7311lvKysq6oroAAHWnNrJk5syZuueee9SkSRN9/PHH+vOf/6yCggL95S9/qXAdr7zyigoKCvTwww9fUQ0AAOerrb7J4MGDtWbNGhUWFurBBx/Um2++6YBqAQD1gaOzo3nz5tq8ebNiY2M1a9YsSVLHjh21YcMGNWrEaW4AcDXOOGf13Xff6fPPP5ePj48++OADnThxQn/+85/1888/6+2333bEZgEAapEzrp1HR0drwoQJeuyxx3T33XfrwIEDmjNnjiTpyJEjDHIHgHrOmdc22rRpo+PHj+vcuXN69tln9cQTT1xRDQCA2uWMfkZ1vPDCCxo0aJCee+4523Pdu3d36HsAFWHGEqAeq+ru72bWYWYK3oCAACUmJioiIkK33nqrXnrpJQ0dOtQ2beOpU6f06KOP6o033lBAQECN6wMA1K7ayJJp06apT58+uvnmmzV58mRNmjTJbnrf8lJSUvTcc89pxYoVCgwMrHEtAADnqK2+ybx587Rr1y6tWbNGBw8eVGJiYo3fBwBQPzg6OwoLCzVy5Ej16dNH27Zt0xdffKEuXbooJiaGO80DgAtyxjmr0tJSWSwWvffee+rVq5ceeOABzZ07V8uWLSNLAMAFOOPa+ahRo5SQkKD+/fvLy8tLvXv31qBBgyRJHh583QYA6jtnXtv47LPPtHPnTiUnJ2v+/Pn65z//WeNaAACO54x+RnVkZWXp3nvvdeg6gergVm5APdaxY0dZLBZlZ2df0et//vlnHT9+XKGhoTWqIyIiQmlpaZKkgwcP6vvvv9eDDz5oW15aWipJatSokXJycnTdddfV6P0AAI5TF1kSERGhWbNmqbi4WN7e3rbnly9frieeeEIrV65UVFTUFb0/AKB+qK08CQ4OVnBwsMLCwtSyZUvdcccdmjZtmkJCQhxRNgDAiRydHSkpKfr++++VkZFh+wJXSkqKrrrqKq1Zs8b25S4AgGtwxjmrkJAQXXPNNfL397e16dSpkwzD0E8//aSOHTteUS0AgLrhjGvnFotFL7/8sl588UVZrVZdffXVSk9PlyRde+21V1QHAKDuOPPaRtlrunbtqqNHj+rZZ5/V4MGDr3xjAAC1or58R/divr6+Dl0fUF3cQgGox1q2bKno6GgtWrRIp0+fvmR5Xl5ela9fsGCBPDw8FBsbW6M6srKybJ2fsLAw7dmzR1lZWbbH73//e919993KyspS27Zta/ReAADHqossycrK0lVXXWU3qOSf//ynRowYoX/+85+KiYm50vIBAPVEXeRJ2YD14uLimpQKAKgnHJ0dZ86ckYeHh91dv8p+L8sQAIDrcMY5qz59+ujw4cMqKCiwtfnvf/8rDw8PtWnT5oq2AwBQd5x57dzT01PXXHONvLy89M9//lORkZG6+uqrTa8HAFC36su1jdLSUq59AEA9VV++o3uxbt262Qa1A3WJGUuAem7RokXq06ePevXqpZkzZ6pbt246d+6c0tLS9Nprr2n//v2SpFOnTslqters2bM6dOiQ3n33Xb355ptKSkrS9ddfb1vfgQMHVFBQIKvVqsLCQmVlZUmSOnfuLC8vLy1btkxeXl66+eabJUmrVq3SkiVL9Oabb0qSfHx81KVLF7saW7RoIUmXPA8AqB8cmSUfffSRjh49qt69e8vHx0dpaWl68cUX9dRTT9neLyUlRcOHD9eCBQsUEREhq9Uq6cJo+vJ3hAQAuBZH5sn69et19OhR3XrrrWrWrJm++eYbTZw4UX369FGHDh2cuJUAAEdyZHb87ne/08SJExUfH68nn3xSpaWleumll9SoUSPdfffdztxMAMAVqutzVn/60580a9YsjRgxQs8995xOnDihiRMn6vHHH+cukADgIur62vmJEyf0r3/9S3fddZeKior09ttva+XKldqyZYszNh8AcAXq+trGokWL1K5dO4WFhUmSPv30U73yyiv6y1/+4pTtBwBcXl33MyRp3759Kikp0S+//KJTp07Z2oSHh0uSZsyYoXvvvVfXXXedBg0apHPnzmn9+vWaPHlyne0XNFAGgHrv8OHDRnx8vNG+fXvDy8vLuOaaa4zf//73xieffGIYhmG0b9/ekGRIMry8vIx27doZDz/8sLFp06ZL1nXnnXfa2pZ/HDp0yDAMw1i6dKnRqVMno0mTJoafn5/Rq1cvY+XKlVXWN3z4cOOhhx5y8FYDABzJUVnyn//8xwgPDzeaNWtmNG3a1OjevbuRnJxsnD9/3tamsqwZPnx4HW4xAKA2OCpPNm3aZERGRhr+/v6Gj4+P0bFjR2Py5MnGr7/+WvcbBQCoVY48r/Xxxx8bffr0Mfz9/Y2rrrrKuOeee4yMjIw63iIAgCPV5TkrwzCM/fv3G1FRUYavr6/Rpk0bIzEx0Thz5kxdbS4AwAHq8tr58ePHjd69extNmzY1mjRpYtx7773Gtm3b6nBrAQCOUJfXNl599VXjpptusn3v6uabbzYWL158Sd8EAFC/1GU/4+L1lX+U9+9//9sIDw83vLy8jICAACMuLq42dwFgGIZhWAzDMGpt1AoAAAAAAAAAAAAAAAAAAAAAAADqLQ9nFwAAAAAAAAAAAAAAAAAAAAAAAADnYGAJAAAAAAAAAAAAAAAAAAAAAABAA8XAEgAAAAAAAAAAAAAAAAAAAAAAgAaKgSUAAAAAAAAAAAAAAAAAAAAAAAANFANLAAAAAAAAAAAAAAAAAAAAAAAAGigGlgAAAAAAAAAAAAAAAAAAAAAAADRQDCwBAAAAAAAAAAAAAAAAAAAAAABooBhYAgAAAAAAAAAAAAAAAAAAAAAA0EAxsAQAAAAAAAAAAAAAAAAAAAAAAKCBYmAJAAAAAAAAAAAAAAAAAAAAAABAA8XAEgAAAAAAAAAAAAAAAAAAAAAAgAaqkbMLgL3S0lIdPnxYzZs3l8VicXY5AHBFDMPQqVOn1Lp1a3l4MIaxtpEdANwB2VG3yA4A7oDsqFtkBwB3QHbULbIDgDsgO+oW2QHAHZAddYvsAOAOyI66RXYAcAe1lR0MLKlnDh8+rLZt2zq7DABwiB9//FFt2rRxdhluj+wA4E7IjrpBdgBwJ2RH3SA7ALgTsqNukB0A3AnZUTfIDgDuhOyoG2QHAHdCdtQNsgOAO3F0djCwpJ5p3ry5pAt/0X5+fk6uBgCuTH5+vtq2bWs7pqF2kR0A3AHZUbfIDgDugOyoW2QHAHfgyOxISkrSqlWrlJ2dLV9fX9122216+eWXdeONN9raFBUV6a9//auWL1+u4uJiRUdHa/HixQoKCrK1yc3N1dixY/XJJ5+oWbNmGj58uJKSktSo0W+XbzZv3qzExER98803atu2raZOnarHHnvMrp5Fixbpb3/7m6xWq7p3766///3v6tWrV5XbsHLlSk2bNk3ff/+9OnbsqJdfflkPPPCAbblhGJoxY4beeOMN5eXlqU+fPnrttdfUsWPHau0jsgOAO6DfUbfIDgDugOyoW2QHAHdAdtQtsgOAO6it7GBgST1TNrWWn58foQXA5TFdYN0gOwC4E7KjbpAdANwJ2VE3yA4A7sQR2bFlyxbFx8fr1ltv1blz5/TMM8/ovvvu0759+9S0aVNJ0oQJE7Ru3TqtXLlS/v7+SkhIUFxcnL744gtJ0vnz5xUTE6Pg4GBt3bpVR44c0bBhw9S4cWO9+OKLkqRDhw4pJiZGY8aM0Xvvvaf09HQ98cQTCgkJUXR0tCTp/fffV2JiopKTkxUREaH58+crOjpaOTk5CgwMrLD+rVu3avDgwUpKSlL//v2VkpKi2NhY7dq1S126dJEkzZ49W6+++qqWLVum0NBQTZs2TdHR0dq3b598fHyqvZ/JDgDugH5H3SA7ALgTsqNukB0A3AnZUTfIDgDuxNHZYTEMw3DoGlEj+fn58vf318mTJwktAC6LY1ndYn8DcAccy+oW+xuAO+BYVrfY3wDcQW0ey44fP67AwEBt2bJFffv21cmTJ3X11VcrJSVFf/zjHyVJ2dnZ6tSpkzIyMtS7d2/95z//Uf/+/XX48GHbLCbJycmaPHmyjh8/Li8vL02ePFnr1q3T3r17be81aNAg5eXlKTU1VZIUERGhW2+9VQsXLpQklZaWqm3btnryySf19NNPV1jvI488otOnT2vt2rW253r37q3w8HAlJyfLMAy1bt1af/3rX/XUU09Jkk6ePKmgoCAtXbpUgwYNuuw+ITsAuAOOZXWL/Q3AHXAsq1vsbwDugGNZ3WJ/A3AHtXUsY8YSN5Kbm6sTJ05IkgICAtSuXTsnVwQAqO/IDgCAWWQHAMAssgNAQ3Dy5ElJUsuWLSVJmZmZOnv2rKKiomxtwsLC1K5dO9vAkoyMDHXt2tU2qESSoqOjNXbsWH3zzTe6+eablZGRYbeOsjbjx4+XJJWUlCgzM1NTpkyxLffw8FBUVJQyMjIqrTcjI0OJiYmXrHf16tWSLsyUYrVa7d7b399fERERysjIqHBgSXFxsYqLi22/5+fnV/r+ZpAjAIDqIC8AAGaRHQAAs8gOAO6OgSVuIjc3V2FhYSosLJQk+fr6Kjs7m+ACAFSK7AAAmEV2AADMIjsANASlpaUaP368+vTpoy5dukiSrFarvLy81KJFC7u2QUFBslqttjblB5WULS9bVlWb/Px8FRYW6tdff9X58+crbJOdnV1pzZWtt/z7lq+nojYXS0pK0nPPPVfpe14JcgQAUB3kBQDALLIDAGAW2QGgIfBwdgFwjBMnTqiwsFBxcXGKi4tTYWGhbWQkAAAVITsAAGaRHQAAs8gOAA1BfHy89u7dq+XLlzu7FKeaMmWKTp48aXv8+OOPNV4nOQIAqA7yAgBgFtkBADCL7ADQEDBjiZsJCAhwdgkAABdDdgAAzCI7AABmkR0A3FVCQoLWrl2rTz/9VG3atLE9HxwcrJKSEuXl5dnNWnL06FEFBwfb2uzYscNufUePHrUtK/uz7Lnybfz8/OTr6ytPT095enpW2KZsHRWpbL3l37fsuZCQELs24eHhFa7T29tb3t7elb5nTZAjAIDqIC8AAGaRHQAAs8gOAO6MGUsAAAAAAAAAAABMMAxDCQkJ+uCDD7Rp0yaFhobaLe/Zs6caN26s9PR023M5OTnKzc1VZGSkJCkyMlJ79uzRsWPHbG3S0tLk5+enzp0729qUX0dZm7J1eHl5qWfPnnZtSktLlZ6ebmtTkcutNzQ0VMHBwXZt8vPztX379irXCwAAAAAAAAAAXBMzlgAAAAAAAAAAAJgQHx+vlJQUrVmzRs2bN5fVapUk+fv7y9fXV/7+/ho5cqQSExPVsmVL+fn56cknn1RkZKR69+4tSbrvvvvUuXNnPfroo5o9e7asVqumTp2q+Ph428wfY8aM0cKFCzVp0iQ9/vjj2rRpk1asWKF169bZaklMTNTw4cN1yy23qFevXpo/f75Onz6tESNG2NoMGzZM11xzjZKSkiRJ48aN05133qk5c+YoJiZGy5cv186dO/X6669LkiwWi8aPH6/nn39eHTt2VGhoqKZNm6bWrVsrNja2LnYxAAAAAAAAAACoQwwsAQAAAAAAAAAAMOG1116TJN111112z7/99tt67LHHJEnz5s2Th4eHBgwYoOLiYkVHR2vx4sW2tp6enlq7dq3Gjh2ryMhINW3aVMOHD9fMmTNtbUJDQ7Vu3TpNmDBBCxYsUJs2bfTmm28qOjra1uaRRx7R8ePHNX36dFmtVoWHhys1NVVBQUG2Nrm5ufLw+G0S+9tuu00pKSmaOnWqnnnmGXXs2FGrV69Wly5dbG0mTZqk06dPa/To0crLy9Ptt9+u1NRU+fj4OGQfAgAAAAAAAACA+oOBJQAAAAAAAAAAACYYhnHZNj4+Plq0aJEWLVpUaZv27dtr/fr1Va7nrrvu0u7du6tsk5CQoISEhEqXb968+ZLnBg4cqIEDB1b6GovFopkzZ9oNdAEAAAAAAAAAAO6JgSUAAAAAAAAAAACoN3Jzc3XixAnt37/f2aUAAAAAAAAAANAgMLAEAAAAAAAAAAAA9UJubq7CwsJUWFjo7FIAAAAAAAAAAGgwPJxdAAAAAAAAAAAAACBJJ06cUGFhoeLi4nT33Xc7uxwAAAAAAAAAABoEZiwBAAAAAAAAAABAvRIQEODsEgAAAAAAAAAAaDCYsQQAAAAAAAAAAAAAAAAAAAAAAKCBYmAJAAAAAAAAAAAAAAAAAAAAAABAA9XI7Au++OILff/99zp//rztuWHDhjm0KACAeyE7AABmkR0AALPIDgCAWWQHAMAssgMAYBbZAQAwi+wAADiLqYElgwcPltVq1c033yxPT09JksViqZXCAADugewAAJhFdgAAzCI7AABmkR0AALPIDgCAWWQHAMAssgMA4EymBpZ89dVX2rdvX23VAgBwQ2QHAMAssgMAYBbZAQAwi+wAAJhFdgAAzCI7AABmkR0AAGfyMNO4V69eysnJqa1aAABuiOwAAJhFdgAAzKppdjz77LOyWCx2j7CwMNvyoqIixcfHq1WrVmrWrJkGDBigo0eP2q0jNzdXMTExatKkiQIDAzVx4kSdO3fOrs3mzZvVo0cPeXt76/rrr9fSpUsvqWXRokXq0KGDfHx8FBERoR07dly2/pUrVyosLEw+Pj7q2rWr1q9fb7fcMAxNnz5dISEh8vX1VVRUlL799lsTewgA3A/9DgCAWWQHAMAssgMAYBbZAQBwJlMzlmRlZal79+668cYb5e3tLcMwZLFYqnWBGwDQMJEdAACzyA4AgFmOyI6bbrpJGzdutP3eqNFvp80mTJigdevWaeXKlfL391dCQoLi4uL0xRdfSJLOnz+vmJgYBQcHa+vWrTpy5IiGDRumxo0b68UXX5QkHTp0SDExMRozZozee+89paen64knnlBISIiio6MlSe+//74SExOVnJysiIgIzZ8/X9HR0crJyVFgYGCFdW/dulWDBw9WUlKS+vfvr5SUFMXGxmrXrl3q0qWLJGn27Nl69dVXtWzZMoWGhmratGmKjo7Wvn375OPjY25nA4CboN/huvbv36+AgAC1a9fO2aUAaGDIDgCAWWQHAMAssgMA4EymBpasWbOmtuoAALgpsgMAYBbZAQAwyxHZ0ahRIwUHB1/y/MmTJ/XWW28pJSVF99xzjyTp7bffVqdOnbRt2zb17t1bH3/8sfbt26eNGzcqKChI4eHhmjVrliZPnqxnn31WXl5eSk5OVmhoqObMmSNJ6tSpkz7//HPNmzfPNrBk7ty5GjVqlEaMGCFJSk5O1rp167RkyRI9/fTTFda9YMEC9evXTxMnTpQkzZo1S2lpaVq4cKGSk5NlGIbmz5+vqVOn6qGHHpIkvfPOOwoKCtLq1as1aNCgGu87AHBF9DtcT0FBgSwWi4YOHSpfX19lZ2czuARAnSI7AABmkR0AALPIDgCAM3mYady+fXv98ssv+vDDD/Xhhx/q119/Vfv27WurNgCAGyA7AABmkR0AALMckR3ffvutWrdurWuvvVZDhgxRbm6uJCkzM1Nnz55VVFSUrW1YWJjatWunjIwMSVJGRoa6du2qoKAgW5vo6Gjl5+frm2++sbUpv46yNmXrKCkpUWZmpl0bDw8PRUVF2dpU5HLrPXTokKxWq10bf39/RUREVLne4uJi5efn2z0AwJ3Q73A9RUVFMgxDffv2VWFhoU6cOOHskgA0MGQHAMAssgMAYBbZAQBwJlMDS1555RU98cQTKigoUEFBgUaNGqW5c+fWVm0AADfgyOx46aWXZLFYNH78eNtzRUVFio+PV6tWrdSsWTMNGDBAR48etXtdbm6uYmJi1KRJEwUGBmrixIk6d+6cXZvNmzerR48e8vb21vXXX6+lS5de8v6LFi1Shw4d5OPjo4iIiGpNM7ly5UqFhYXJx8dHXbt21fr16+2WG4ah6dOnKyQkRL6+voqKitK3335b/Z0CAG6IfgcAwKyaZkdERISWLl2q1NRUvfbaazp06JDuuOMOnTp1SlarVV5eXmrRooXda4KCgmS1WiVJVqvVblBJ2fKyZVW1yc/Pt3059vz58xW2KVtHRSpbb/n3LV9PddeblJQkf39/26Nt27aVtgUAV0S/w3X5+/s7uwQADRTZAQAwi+wAAJhFdgAAnKmRmcbvvPOOvvzyS3l7e0uSEhMTdeuttyoxMbFWigMAuD5HZceXX36pf/zjH+rWrZvd8xMmTNC6deu0cuVK+fv7KyEhQXFxcfriiy8kSefPn1dMTIyCg4O1detWHTlyRMOGDVPjxo314osvSrpwB9+YmBiNGTNG7733ntLT0/XEE08oJCRE0dHRkqT3339fiYmJSk5OVkREhObPn6/o6Gjl5OQoMDCwwpq3bt2qwYMHKykpSf3791dKSopiY2O1a9cudenSRZI0e/Zsvfrqq1q2bJlCQ0M1bdo0RUdHa9++ffLx8TG1jwDAXdDvAACYVdPsuP/++20/d+vWTREREWrfvr1WrFghX1/fWqm5vpsyZYrd/svPz2dwCQC3Qr8DAGAW2QEAMIvsAACYRXYAAJzJ1Iwl0oU7w1f0MwAAlalpdhQUFGjIkCF64403dNVVV9meP3nypN566y3NnTtX99xzj3r27Km3335bW7du1bZt2yRJH3/8sfbt26d3331X4eHhuv/++zVr1iwtWrRIJSUlkqTk5GSFhoZqzpw56tSpkxISEvTHP/5R8+bNs73X3LlzNWrUKI0YMUKdO3dWcnKymjRpoiVLllRa94IFC9SvXz9NnDhRnTp10qxZs9SjRw8tXLhQ0oXZSubPn6+pU6fqoYceUrdu3fTOO+/o8OHDWr16ten9BADuhH4HAMAsR2ZHixYtdMMNN+jAgQMKDg5WSUmJ8vLy7NocPXpUwcHBkqTg4OBLZk4s+/1ybfz8/OTr66uAgAB5enpW2KZsHRWpbL3l37d8PdVdr7e3t/z8/OweAOBu6HcAAMwiOwAAZpEdAACzyA4AgLOYGlgyceJE9ezZU2PGjNH//M//6JZbbtGkSZNqqzYAgBtwRHbEx8crJiZGUVFRds9nZmbq7Nmzds+HhYWpXbt2ysjIkCRlZGSoa9euCgoKsrWJjo5Wfn6+vvnmG1ubi9cdHR1tW0dJSYkyMzPt2nh4eCgqKsrWpiKXW++hQ4dktVrt2vj7+ysiIqLK9RYXFys/P9/uAQDuhH4HAMAsR2dHQUGBDh48qJCQEPXs2VONGzdWenq6bXlOTo5yc3MVGRkpSYqMjNSePXt07NgxW5u0tDT5+fmpc+fOtjbl11HWpmwdXl5e6tmzp12b0tJSpaen29pU5HLrDQ0NVXBwsF2b/Px8bd++vcr1AoC7o98BADCL7AAAmEV2AADMqml2PPvss7JYLHaPsLAw2/KioiLFx8erVatWatasmQYMGHDJjalyc3MVExOjJk2aKDAwUBMnTtS5c+fs2mzevFk9evSQt7e3rr/+ei1duvSSWhYtWqQOHTrIx8dHERER2rFjx2XrX7lypcLCwuTj46OuXbtq/fr1dssNw9D06dMVEhIiX19fRUVF6dtvv632/gEAVK2RmcaPPvqo7r33Xn355ZeSLoRQSEhIrRQGAHAPNc2O5cuXa9euXbbXl2e1WuXl5aUWLVrYPR8UFCSr1WprU35QSdnysmVVtcnPz1dhYaF+/fVXnT9/vsI22dnZldZe2XrLv2/5eipqU5GkpCQ999xzlS4HAFdHvwMAYFZNs+Opp57Sgw8+qPbt2+vw4cOaMWOGPD09NXjwYPn7+2vkyJFKTExUy5Yt5efnpyeffFKRkZHq3bu3JOm+++5T586d9eijj2r27NmyWq2aOnWq4uPjbdPVjxkzRgsXLtSkSZP0+OOPa9OmTVqxYoXWrVtnqyMxMVHDhw/XLbfcol69emn+/Pk6ffq0RowYYWszbNgwXXPNNUpKSpIkjRs3TnfeeafmzJmjmJgYLV++XDt37tTrr78uSbJYLBo/fryef/55dezYUaGhoZo2bZpat26t2NjYGu13AHBl9DsAAGaRHQAAs8gOAIBZjsiOm266SRs3brT93qjRb18TnjBhgtatW6eVK1fK399fCQkJiouL0xdffCFJOn/+vGJiYhQcHKytW7fqyJEjGjZsmBo3bqwXX3xR0oUb6cbExGjMmDF67733lJ6erieeeEIhISGKjo6WJL3//vtKTExUcnKyIiIiNH/+fEVHRysnJ0eBgYEV1r1161YNHjxYSUlJ6t+/v1JSUhQbG6tdu3apS5cukqTZs2fr1Vdf1bJly2zXO6Kjo7Vv3z75+PiY2k8AgEtVa8aSQ4cOSZL27dunvLw8dezYUR07dtSvv/6qffv2XdEbv/TSS7YL22UYDQkA7qcm2fHjjz9q3Lhxeu+99/jwX86UKVN08uRJ2+PHH390dkkA4FCO7HcAABqGmmbHTz/9pMGDB+vGG2/Uww8/rFatWmnbtm26+uqrJUnz5s1T//79NWDAAPXt21fBwcFatWqV7fWenp5au3atPD09FRkZqaFDh2rYsGGaOXOmrU1oaKjWrVuntLQ0de/eXXPmzNGbb75pu8giSY888oheeeUVTZ8+XeHh4crKylJqaqrdYPTc3FwdOXLE9vttt92mlJQUvf766+revbv+9a9/afXq1baLLJI0adIkPfnkkxo9erRuvfVWFRQUKDU1lX4WgAaNfgcAwCyyAwBgFtkBADDLEdnRqFEjBQcH2x4BAQGSpJMnT+qtt97S3Llzdc8996hnz556++23tXXrVm3btk2S9PHHH2vfvn169913FR4ervvvv1+zZs3SokWLVFJSIklKTk5WaGio5syZo06dOikhIUF//OMfNW/ePFsNc+fO1ahRozRixAh17txZycnJatKkiZYsWVJp3QsWLFC/fv00ceJEderUSbNmzVKPHj20cOFCSRe+nzt//nxNnTpVDz30kLp166Z33nlHhw8f1urVq03tIwBAxao1Y0lSUpJef/11xcfHX7LMYrFo06ZNpt70yy+/1D/+8Q9169bN7nlGQwKA+6lJdmRmZurYsWPq0aOH7bnz58/r008/1cKFC7VhwwaVlJQoLy/PbtaSo0ePKjg4WJIUHBx8yeDBskGL5dtcPJDx6NGj8vPzk6+vrzw9PeXp6Vlhm7J1VKSy9ZZ/37Lnyt9d4OjRowoPD690vd7e3ra7HgOAO3JUvwMA0HDUNDuWL19e5XIfHx8tWrRIixYtqrRN+/btL7kJycXuuusu7d69u8o2CQkJSkhIqHT55s2bL3lu4MCBGjhwYKWvsVgsmjlzpt1AFwBo6Oh3AADMIjsAAGaRHQAAsxyRHd9++61at24tHx8fRUZGKikpSe3atVNmZqbOnj2rqKgoW9uwsDC1a9dOGRkZ6t27tzIyMtS1a1e7G15FR0dr7Nix+uabb3TzzTcrIyPDbh1lbcpuMl9SUqLMzExNmTLFttzDw0NRUVHKyMiotO6MjAwlJiZest6yQSOHDh2S1Wq1e29/f39FREQoIyNDgwYNqvY+AgBUrFozlrz++uuSpBUrVuiTTz6xe7z//vum3rCgoEBDhgzRG2+8oauuusr2PKMhAcA91SQ77r33Xu3Zs0dZWVm2xy233KIhQ4bYfm7cuLHS09Ntr8nJyVFubq4iIyMlSZGRkdqzZ4+OHTtma5OWliY/Pz917tzZ1qb8OsralK3Dy8tLPXv2tGtTWlqq9PR0W5uKXG69oaGhCg4OtmuTn5+v7du3V7leAHB3Ne13PPvss7JYLHaPsLAw23JmSgQA9+OIc1YAgIaF7AAAmEV2AADM4noH1zsAwKyaZkdERISWLl2q1NRUvfbaazp06JDuuOMOnTp1SlarVV5eXnY375WkoKAgWa1WSZLVarUbVFK2vGxZVW3y8/NVWFioEydO6Pz58xW2KVtHRSpbb/n3LV9PdddbXFys/Px8uwcAoGLVGlhSpmzGj8s9V5X4+HjFxMRcMmLxcqMhJVU6GjI/P1/ffPONrU1FoyHL1lE2GrJ8m+qOhqxqvZcbDVkZQguAu6tJdjRv3lxdunSxezRt2lStWrVSly5d5O/vr5EjRyoxMVGffPKJMjMzNWLECEVGRqp3796SpPvuu0+dO3fWo48+qq+++kobNmzQ1KlTFR8fb5v1Y8yYMfruu+80adIkZWdna/HixVqxYoUmTJhgqyUxMVFvvPGGli1bpv3792vs2LE6ffq0RowYYWszbNgwu9H248aNU2pqqubMmaPs7Gw9++yz2rlzp+3uwxaLRePHj9fzzz+vDz/8UHv27NGwYcPUunVrxcbGmt7XAOAuHNHvuOmmm3TkyBHb4/PPP7ctmzBhgj766COtXLlSW7Zs0eHDhxUXF2dbXjZTYklJibZu3aply5Zp6dKlmj59uq1N2UyJd999t7KysjR+/Hg98cQT2rBhg61N2UyJM2bM0K5du9S9e3dFR0fbDXa8WNlMiSNHjtTu3bsVGxur2NhY7d2719ambKbE5ORkbd++XU2bNlV0dLSKiopM7SMAcCeOyA4AQMNCdgAAzCI7AABmcb2D6x0AYFZNs+P+++/XwIED1a1bN0VHR2v9+vXKy8vTihUrHFmmS0lKSpK/v7/t0bZtW2eXBAD1VqPqNDpw4IBycnKUn59vN3o8Pz9fxcXF1X6z5cuXa9euXfryyy8vWVZXoyF//fXXSkdDZmdnV1p7bY2GTEpK0nPPPVfpcgBwZRs2bKhxdlzOvHnz5OHhoQEDBqi4uFjR0dFavHixbbmnp6fWrl2rsWPHKjIyUk2bNtXw4cM1c+ZMW5vQ0FCtW7dOEyZM0IIFC9SmTRu9+eabdh2zRx55RMePH9f06dNltVoVHh6u1NRUu+N+bm6uPDx+G7N52223KSUlRVOnTtUzzzyjjh07avXq1erSpYutzaRJk3T69GmNHj1aeXl5uv3225WamiofHx+H7SMAcCWOyo5GjRopODj4kufLZkpMSUnRPffcI0l6++231alTJ23btk29e/e2zZS4ceNGBQUFKTw8XLNmzdLkyZP17LPPysvLy26mREnq1KmTPv/8c82bN8+WH+VnSpQuzK64bt06LVmyRE8//XSFdZefKVGSZs2apbS0NC1cuFDJycmXzJQoSe+8846CgoK0evVqpvcF0CDVRb8DAOBeyA4AgFmOyI6kpCStWrVK2dnZ8vX11W233aaXX35ZN954o61NUVGR/vrXv2r58uV21zwuvhYxduxYffLJJ2rWrJmGDx+upKQkNWr026X/zZs3KzExUd98843atm2rqVOn6rHHHrOrZ9GiRfrb3/4mq9Wq7t276+9//7t69epV5TasXLlS06ZN0/fff6+OHTvq5Zdf1gMPPGBbbhiGZsyYoTfeeEN5eXnq06ePXnvtNXXs2LHa+wkA3AXXO7jeAQBm1cY5qxYtWuiGG27QgQMH9Lvf/U4lJSXKy8uz+57u0aNHbVkTHBx8yaxUZbNhlW9z8QxZR48elZ+fn3x9feXp6SlPT88K21SUaWUqW2/59y17LiQkxK5NeHh4peudMmWKEhMTbb/n5+czuAQAKlGtgSXffPONVq9erV9//VUrV660Pd+8eXO98cYb1XqjH3/8UePGjVNaWhpfli2H0ALgztasWVOj7KjI5s2b7X738fHRokWLtGjRokpf0759+0um1b3YXXfdpd27d1fZJiEhwTbbSHVqk6SBAwdq4MCBlb7GYrFo5syZdgNdAKAhc1R2fPvtt2rdurV8fHwUGRmppKQktWvX7rIzJfbu3bvSmRLHjh2rb775RjfffHOlMxqOHz9e0m8zJZafyaq6MyWW7x+UrXf16tWSLj9TYmUXWoqLi+1OODJTIgB3Uhv9DgCAeyM7AABmOSI7tmzZovj4eN166606d+6cnnnmGd13333at2+fmjZtKunCnefXrVunlStXyt/fXwkJCYqLi9MXX3wh6bc7zwcHB2vr1q06cuSIhg0bpsaNG+vFF1+U9Nud58eMGaP33ntP6enpeuKJJxQSEmL7gnDZneeTk5MVERGh+fPnKzo6Wjk5OQoMDKyw/rI7zyclJal///5KSUlRbGysdu3aZbuhVtmd55ctW6bQ0FBNmzZN0dHR2rdvH98RANDgcL2D6x0AYFZtnLMqKCjQwYMH9eijj6pnz55q3Lix0tPTNWDAAElSTk6OcnNzFRkZKUmKjIzUCy+8oGPHjtn6BmlpafLz81Pnzp1tbS7+HlZaWpptHV5eXurZs6fS09MVGxsrSSotLVV6enqV37uKjIxUenq6LYMuXm9oaKiCg4OVnp5uG0iSn5+v7du3a+zYsZWu19vbW97e3tXcYwDQsFVrYMlDDz2khx56SDt27LjsXUoqk5mZqWPHjqlHjx62586fP69PP/1UCxcu1IYNGxrkaEhCC4A7W7x4sbKzs684OwAADY8jsiMiIkJLly7VjTfeqCNHjui5557THXfcob179zJTIgC4IfodAACzyA4AgFmOyI7U1FS735cuXarAwEBlZmaqb9++3HkeANwM1zu43gEAZjkiO5566ik9+OCDat++vQ4fPqwZM2bI09NTgwcPlr+/v0aOHKnExES1bNlSfn5+evLJJxUZGanevXtLku677z517txZjz76qGbPni2r1aqpU6cqPj7e9j3XMWPGaOHChZo0aZIef/xxbdq0SStWrNC6detsdSQmJmr48OG65ZZb1KtXL82fP1+nT5+29UEkadiwYbrmmmuUlJQkSRo3bpzuvPNOzZkzRzExMVq+fLl27typ119/XdKFm/eOHz9ezz//vDp27GgbzN66dWvbABYAQM1Ua2BJmbCwMCUlJWnfvn12o79XrFhx2dfee++92rNnj91zI0aMUFhYmCZPnqy2bds2yNGQAODuapIdAICGqabZcf/999t+7tatmyIiItS+fXutWLFCvr6+Dq/XFTBTIgB3R78DAGAW2QEAMMvR2XHy5ElJUsuWLSWpQd55nrvOA3B3XO9wPK53AHB3Nc2On376SYMHD9bPP/+sq6++Wrfffru2bdumq6++WpI0b948eXh4aMCAASouLlZ0dLQWL15se72np6fWrl2rsWPHKjIyUk2bNtXw4cM1c+ZMW5vQ0FCtW7dOEyZM0IIFC9SmTRu9+eabtoHskvTII4/o+PHjmj59uqxWq8LDw5WammrXl8nNzZWHh4ft99tuu00pKSmaOnWqnnnmGXXs2FGrV6+2zZAoSZMmTdLp06c1evRo5eXl6fbbb1dqaiozJAKAg3hcvslvhgwZombNmmn79u0aPny4LBaL2rdvX63XNm/eXF26dLF7NG3aVK1atVKXLl3sRkN+8sknyszM1IgRIyodDfnVV19pw4YNFY6G/O677zRp0iRlZ2dr8eLFWrFihSZMmGCrJTExUW+88YaWLVum/fv3a+zYsRWOhix/Mm3cuHFKTU3VnDlzlJ2drWeffVY7d+60DUYpPxryww8/1J49ezRs2DBGQwJo8GqSHQCAhsnR2dGiRQvdcMMNOnDggIKDg20zJZZ38WyEFc1WWLasqjZlMyUGBATU+kyJZtbr7e0tPz8/uwcAuBP6HQAAs8gOAIBZjsyO0tJSjR8/Xn369LF9Saqu7jx/4sSJSu88X9Ud4mvjzvNJSUny9/e3PfhiMAB3w/UOrncAgFk1zY7ly5fr8OHDKi4u1k8//aTly5fruuuusy338fHRokWL9Msvv+j06dNatWrVJcfd9u3ba/369Tpz5oyOHz+uV155RY0a2d/D/q677tLu3btVXFysgwcP6rHHHrukloSEBP3www8qLi7W9u3bFRERYbd88+bNWrp0qd1zAwcOVE5OjoqLi7V371498MADdsstFotmzpwpq9WqoqIibdy4UTfccEO19w8AoGqmBpYcPnxYTz75pHx8fGxTTW3ZssVhxcybN0/9+/fXgAED1LdvXwUHB2vVqlW25WWjIT09PRUZGamhQ4dq2LBhFY6GTEtLU/fu3TVnzpwKR0O+8sormj59usLDw5WVlVXhaMgjR47Yfi8bDfn666+re/fu+te//lXhaMgnn3xSo0eP1q233qqCggJGQwJo8Go7OwAA7sfR2VFQUKCDBw8qJCREPXv2tM2UWKaimRL37NmjY8eO2dpUNFNi+XWUtalopsQyZTMllrWpyOXWW36mxDJlMyVWtV4AcHf0OwAAZpEdAACzHJkd8fHx2rt3r5YvX+7gKl3LlClTdPLkSdvjxx9/dHZJAOBQXO/gegcAmMU5KwCAMzW6fJNyjf//UYdBQUFKT09X69at9fPPP1/xm2/evNnu97LRkIsWLar0NWWjIatSNhqyKgkJCbbZRqpTm3RhNOTAgQMrfU3ZaMjyA10AoKFzdHYAANxfTbPjqaee0oMPPqj27dvr8OHDmjFjhjw9PTV48GC7mRJbtmwpPz8/Pfnkk5XOlDh79mxZrdYKZ0pcuHChJk2apMcff1ybNm3SihUrtG7dOlsdiYmJGj58uG655Rb16tVL8+fPr3CmxGuuuUZJSUmSLsyUeOedd2rOnDm2E4U7d+7U66+/Lsl+psSOHTsqNDRU06ZNY6ZEAA0e/Q4AgFlkBwDALEdlR0JCgtauXatPP/1Ubdq0sT1f/s7z5Wctufju7jt27LBbn9k7z3t6etb6nedDQkLs2oSHh1e4Tm9vb9v5NgBwR1zv4HoHAJjFOSsAgDOZGljyzDPP6OTJk5ozZ47+8pe/6NSpU5o7d25t1QYAcANkBwDArJpmx08//aTBgwfr559/1tVXX63bb79d27Zt09VXXy3pwkyJHh4eGjBggIqLixUdHa3FixfbXl82U+LYsWMVGRmppk2bavjw4RXOlDhhwgQtWLBAbdq0qXCmxOPHj2v69OmyWq0KDw+vcKZED4/fJpIsmylx6tSpeuaZZ9SxY8cKZ0o8ffq0Ro8erby8PN1+++3MlAigwaPfAQAwi+wAAJhV0+wwDENPPvmkPvjgA23evFmhoaF2y8vfeX7AgAGSKr7z/AsvvKBjx44pMDBQUsV3nr/4Ro2V3Xm+7Iu7ZXeer+rGjGV3nh8/fnyF6y1/5/mygSRld54fO3ZstfcTALgTrndwvQMAzOKcFQDAmUwNLHnooYckSd26datwRg8AAC5GdgAAzKppdixfvrzK5cyUCADuh34HAMAssgMAYFZNsyM+Pl4pKSlas2aNmjdvLqvVKkny9/eXr68vd54HADfE9Q6udwCAWZyzAgA4k6mBJQcPHtTChQv1/fff6/z587bnP/zwQ4cXBgBwD2QHAMAssgMAYBbZAQAwi+wAAJhV0+x47bXXJF348m55b7/9th577DFJ3HkeANwN/Q4AgFlkBwDAmUwNLPnDH/6ghIQEPfzww3YnkQAAqAzZAQAwi+wAAJhFdgAAzCI7AABm1TQ7DMO4bBvuPA8A7oV+BwDALLIDAOBMpgaWNGnSRKNHj66tWgAAbojsAACYRXYAAMwiOwAAZpEdAACzyA4AgFlkBwDALLIDAOBMpgaWTJkyRZMnT1ZUVJS8vb1tz/ft29fhhQEA3APZAQAwi+wAAJhFdgAAzCI7AABmkR2uZf/+/ZKkgIAAtWvXzsnVAGioyA4AgFlkBwDAmUwNLNmwYYM2b96sAwcO2KbZslgshBYAoFJkBwDALLIDAGAW2QEAMIvsAACYRXa4hoKCAlksFg0dOlSS5Ovrq+zsbAaXAHAKsgMAYBbZAQBwJlMDSzZu3KicnBxZLJbaqgcA4GbIDgCAWWQHAMAssgMAYBbZAQAwi+xwDUVFRTIMQ3FxcZKkVatW6cSJEwwsAeAUZAcAwCyyAwDgTB5mGvfq1UsHDx6srVoAAG6I7AAAmEV2AADMIjsAAGaRHQAAs8gO1xIQEKCAgABnlwGggSM7AABmkR0AAGcyNWPJ3r171aVLF914443y9vaWYRiyWCzasWNHbdUHAHBxZAcAwCyyAwBgFtkBADCL7AAAmEV2AADMIjsAAGaRHQAAZzI1sGTNmjW1VQcAwE2RHQAAs8gOAIBZZAcAwCyyAwBgFtkBADCL7AAAmEV2AACcyaM6jYqLiyVJV199dYUPAAAqQ3YAAMwiOwAAZpEdAACzapodn376qR588EG1bt1aFotFq1evtltuGIamT5+ukJAQ+fr6KioqSt9++61dm19++UVDhgyRn5+fWrRooZEjR6qgoMCuzddff6077rhDPj4+atu2rWbPnn1JLStXrlRYWJh8fHzUtWtXrV+//rL1b968WT169JC3t7euv/56LV269JI2ixYtUocOHeTj46OIiAjujAmgwaPfAQAwi+wAAJhFdgAAnKlaM5YMGDBAa9eu1U033SSLxWKbXqvsz++++6626wQAuCiyAwBgFtkBADCL7AAAmFXT7Dh9+rS6d++uxx9/XHFxcZcsnz17tl599VUtW7ZMoaGhmjZtmqKjo7Vv3z75+PhIkoYMGaIjR44oLS1NZ8+e1YgRIzR69GilpKRIkvLz83XfffcpKipKycnJ2rNnjx5//HG1aNFCo0ePliRt3bpVgwcPVlJSkvr376+UlBTFxsZq165d6tKlS4W1Hzp0SDExMRozZozee+89paen64knnlBISIiio6MlSe+//74SExOVnJysiIgIzZ8/X9HR0crJyVFgYKDp/Q0A7oB+BwDALLIDAGAW2QEAcKZqDSxZu3atpAsXGwAAMIPsAACYRXYAAMwiOwAAZtU0O+6//37df//9FS4zDEPz58/X1KlT9dBDD0mS3nnnHQUFBWn16tUaNGiQ9u/fr9TUVH355Ze65ZZbJEl///vf9cADD+iVV15R69at9d5776mkpERLliyRl5eXbrrpJmVlZWnu3Lm2gSULFixQv379NHHiREnSrFmzlJaWpoULFyo5ObnC+pKTkxUaGqo5c+ZIkjp16qTPP/9c8+bNsw0smTt3rkaNGqURI0bYXrNu3TotWbJETz/9dI32HQC4KvodAACzyA4AgFlkBwDAmTzMNO7Vq1e1ngMAoAzZAQAwi+wAAJhFdgAAzKrN7Dh06JCsVquioqJsz/n7+ysiIkIZGRmSpIyMDLVo0cI2qESSoqKi5OHhoe3bt9va9O3bV15eXrY2ZbOG/Prrr7Y25d+nrE3Z+1Tkcq8pKSlRZmamXRsPDw9FRUVVud7i4mLl5+fbPQDAndDvAACYRXYAAMwiOwAAzlStGUtOnDiho0ePqqCgQPv375dhGJLEhQEAQJX2799PdgAATCE7AABmkR0AALNqOzusVqskKSgoyO75oKAg2zKr1arAwEC75Y0aNVLLli3t2oSGhl6yjrJlV111laxWa5XvU1l9Fb0mPz9fhYWF+vXXX3X+/PkK22RnZ1e63qSkJD333HOVLgcAV0a/AwBgFtkBADCL7AAAOFu1BpasW7dOS5cu1Y8//qj4+HhbaDVv3lwvvvhirRYIAHBdEydOJDsAAKaQHQAAs8gOAIBZZEftmDJlihITE22/5+fnq23btk6sCAAch+wAAJhFdgAAzCI7AADOVq2BJcOHD9fw4cO1evVqxcbG1nJJAAB3sXbtWm3atInsAABUG9kBADCL7AAAmFXb2REcHCxJOnr0qEJCQmzPHz16VOHh4bY2x44ds3vduXPn9Msvv9heHxwcrKNHj9q1Kfv9cm3KlldWX0Wv8fPzk6+vrzw9PeXp6Wl6vd7e3vL29q50OQC4MvodAACzyA4AgFlkBwDA2TzMNN63b59OnTql8+fPa+DAgbrhhhu0evXqWioNAOAOyA4AgFlkBwDALLIDAGBWbWZHaGiogoODlZ6ebnsuPz9f27dvV2RkpCQpMjJSeXl5yszMtLXZtGmTSktLFRERYWvz6aef6uzZs7Y2aWlpuvHGG3XVVVfZ2pR/n7I2Ze9Tkcu9xsvLSz179rRrU1paqvT09CrXCwDujn4HAMAssgMAYBbZAQBwJlMDS1auXKnmzZtr7dq18vHx0eeff67nnnuutmoDALgBsgMAYBbZAQAwi+wAAJhV0+woKChQVlaWsrKyJEmHDh1SVlaWcnNzZbFYNH78eD3//PP68MMPtWfPHg0bNkytW7e23XGyU6dO6tevn0aNGqUdO3boiy++UEJCggYNGqTWrVtLkv70pz/Jy8tLI0eO1DfffKP3339fCxYsUGJioq2OcePGKTU1VXPmzFF2draeffZZ7dy5UwkJCbY2U6ZM0bBhw2y/jxkzRt99950mTZqk7OxsLV68WCtWrNCECRNsbRITE/XGG29o2bJl2r9/v8aOHavTp09rxIgRV7K7AcAt0O8AAJhFdgAAzCI7AADO1MhM48LCQknSmjVrNGjQIAUGBsowjFopDADgHsgOAIBZZAcAwCyyAwBgVk2zY+fOnbr77rttv5cN9hg+fLiWLl2qSZMm6fTp0xo9erTy8vJ0++23KzU1VT4+PrbXvPfee0pISNC9994rDw8PDRgwQK+++qptub+/vz7++GPFx8erZ8+eCggI0PTp0zV69Ghbm9tuu00pKSmaOnWqnnnmGXXs2FGrV69Wly5dbG2OHDmi3Nxc2++hoaFat26dJkyYoAULFqhNmzZ68803FR0dbWvzyCOP6Pjx45o+fbqsVqvCw8OVmpqqoKCgau8jAHA39DsAAGaRHQAAs8gOAIAzmZqx5MEHH1T79u2VmZmp++67T8ePH5e3t3dt1QYAcANkBwDALLIDAGBWTbMjKSlJt956q5o3b67AwEDFxsYqJyfHrs1dd90li8Vi9xgzZoxdm9zcXMXExKhJkyYKDAzUxIkTde7cObs2mzdvVo8ePeTt7a3rr79eS5cuvaSeRYsWqUOHDvLx8VFERIR27Nhx2W1YuXKlwsLC5OPjo65du2r9+vV2yw3D0PTp0xUSEiJfX19FRUXp22+/reYeAgD3U9PsuOuuu2QYxiWPsuO6xWLRzJkzZbVaVVRUpI0bN+qGG26wW0fLli2VkpKiU6dO6eTJk1qyZImaNWtm16Zbt2767LPPVFRUpJ9++kmTJ0++pJaBAwcqJydHxcXF2rt3rx544AG75UuXLtXmzZsvqX/37t0qLi7WwYMH9dhjj12y3oSEBP3www8qLi7W9u3bFRERUe39AwDuiHNWAACzyA4AgFlkBwDAmUwNLPnb3/6m3bt3a9euXWrcuLGaNGmiNWvW1FZtAAA3QHYAAMwiOwAAZtU0O7Zs2aL4+Hht27ZNaWlpOnv2rO677z6dPn3art2oUaN05MgR22P27Nm2ZefPn1dMTIxKSkq0detWLVu2TEuXLtX06dNtbQ4dOqSYmBjdfffdysrK0vjx4/XEE09ow4YNtjbvv/++EhMTNWPGDO3atUvdu3dXdHS0jh07Vmn9W7du1eDBgzVy5Ejt3r1bsbGxio2N1d69e21tZs+erVdffVXJycnavn27mjZtqujoaBUVFVV7PwGAO6HfAQAwi+wAAJhFdgAAzCI7AADOZGpgSV5enl566SU9+uijkqSffvpJn332Wa0UBgBwDzXNjurcObioqEjx8fFq1aqVmjVrpgEDBujo0aN2bbhzMAC4DvodAACzapodqampeuyxx3TTTTepe/fuWrp0qXJzc5WZmWnXrkmTJgoODrY9/Pz8bMs+/vhj7du3T++++67Cw8N1//33a9asWVq0aJFKSkokScnJyQoNDdWcOXPUqVMnJSQk6I9//KPmzZtnW8/cuXM1atQojRgxQp07d1ZycrKaNGmiJUuWVFr/ggUL1K9fP02cOFGdOnXSrFmz1KNHDy1cuFDShT7H/PnzNXXqVD300EPq1q2b3nnnHR0+fFirV6+u9n4CAHdCvwMAYBbZAQAwi+wAAJhFdgAAnMnUwJLhw4erU6dOtrsdhoaGatasWbVSGADAPdQ0O6pz5+AJEyboo48+0sqVK7VlyxYdPnxYcXFxtuXcORgAXAv9DgCAWY7OjpMnT0qSWrZsaff8e++9p4CAAHXp0kVTpkzRmTNnbMsyMjLUtWtXBQUF2Z6Ljo5Wfn6+vvnmG1ubqKgou3VGR0crIyNDklRSUqLMzEy7Nh4eHoqKirK1qcjl1nvo0CFZrVa7Nv7+/oqIiKh0vcXFxcrPz7d7AIA7od8BADCL7AAAmEV2AADMIjsAAM5kamDJ4cOHNWLECHl6ekqSvLy85OFhahUAgAamptlxuTsHnzx5Um+99Zbmzp2re+65Rz179tTbb7+trVu3atu2bZK4czAAuBr6HQAAsxyZHaWlpRo/frz69OmjLl262J7/05/+pHfffVeffPKJpkyZov/7v//T0KFDbcutVqvdoBJJtt+tVmuVbfLz81VYWKgTJ07o/PnzFbYpW0dFKltv+fctX0911puUlCR/f3/bo23btpW+PwC4IvodAACzyA4AgFlkBwDArJpmR1JSkm699VY1b95cgYGBio2NVU5Ojl2bu+66SxaLxe4xZswYuza5ubmKiYlRkyZNFBgYqIkTJ+rcuXN2bTZv3qwePXrI29tb119/vZYuXXpJPYsWLVKHDh3k4+OjiIgI7dix47LbsHLlSoWFhcnHx0ddu3bV+vXr7ZYbhqHp06crJCREvr6+ioqK0rffflvNPQQAqIqp3krTpk2Vl5cni8UiSdq1a5eaN29e7ddXJ7SKiooUHx+vVq1aqVmzZhowYICOHj1q14bQAgDXUdPsuNjFdw7OzMzU2bNn7e68GxYWpnbt2tnuvMudgwHAtTg6OwAA7s+R2REfH6+9e/dq+fLlds+PHj1a0dHR6tq1q4YMGaJ33nlHH3zwgQ4ePFjj+uujKVOm6OTJk7bHjz/+6OySAMCh6HcAAMwiOwAAZpEdAACzapodW7ZsUXx8vLZt26a0tDSdPXtW9913n06fPm3XbtSoUTpy5IjtMXv2bNuy8+fPKyYmRiUlJdq6dauWLVumpUuXavr06bY2hw4dUkxMjO6++25lZWVp/PjxeuKJJ7RhwwZbm/fff1+JiYmaMWOGdu3ape7duys6OlrHjh2rtP6tW7dq8ODBGjlypHbv3q3Y2FjFxsbaZnCRpNmzZ+vVV19VcnKytm/frqZNmyo6OlpFRUXV3k8AgIqZGlgyZ84cxcbG6tChQ7r33ns1aNAgvfrqq9V+fXVCa8KECfroo4+0cuVKbdmyRYcPH1ZcXJxtOaEFAK6lptlRXkV3DrZarfLy8lKLFi3s2l58d17uHAwArsOR2QEAaBgclR0JCQlau3atPvnkE7Vp06bKthEREZKkAwcOSJKCg4MvuTlK2e/BwcFVtvHz85Ovr68CAgLk6elZYZuydVSksvWWf9/y9VRnvd7e3vLz87N7AIA7od8BADCL7AAAmEV2AADMqml2pKam6rHHHtNNN92k7t27a+nSpcrNzVVmZqZduyZNmig4ONj2KH8N4OOPP9a+ffv07rvvKjw8XPfff79mzZqlRYsWqaSkRJKUnJys0NBQzZkzR506dVJCQoL++Mc/at68ebb1zJ07V6NGjdKIESPUuXNnJScnq0mTJlqyZEml9S9YsED9+vXTxIkT1alTJ82aNUs9evTQwoULJV248fv8+fM1depUPfTQQ+rWrZveeecdHT58WKtXr672fgIAVKyRmcY9e/bUxo0blZOTo9LSUoWFhalx48bVfn1qaqrd70uXLlVgYKAyMzPVt29fnTx5Um+99ZZSUlJ0zz33SJLefvttderUSdu2bVPv3r1tobVx40YFBQUpPDxcs2bN0uTJk/Xss8/Ky8vLLrQkqVOnTvr88881b948RUdHS7IPLelC0K1bt05LlizR008/XWH95UNLkmbNmqW0tDQtXLhQycnJl4SWJL3zzjsKCgrS6tWrNWjQIBN7GwDcQ02zo7yyOwd//vnnDq7StUyZMkWJiYm23/Pz8xlcAsCtODI7AAANQ02zwzAMPfnkk/rggw+0efNmhYaGXvY1WVlZkqSQkBBJUmRkpF544QUdO3ZMgYGBkqS0tDT5+fmpc+fOtjYXz36blpamyMhISRemtO/Zs6fS09MVGxsr6cIA+/T0dCUkJFRaS2RkpNLT0zV+/PgK1xsaGqrg4GClp6crPDxc0oV+xPbt2zV27NjLbisAuCP6HQAAs8gOAIBZZAcAwCxHZ8fJkyclSS1btrR7/r333tO7776r4OBgPfjgg5o2bZqaNGkiScrIyFDXrl3tbpIbHR2tsWPH6ptvvtHNN9+sjIwMRUVF2a0zOjradp2ipKREmZmZmjJlim25h4eHoqKilJGRUWm9GRkZdt+JKltv2aCRQ4cOyWq12r23v7+/IiIilJGRUeF3dIuLi1VcXGz7PT8/v9L3B4CGztTAEklq1KiRbrrpJoe8+cWhlZmZqbNnz9od9MPCwtSuXTtlZGSod+/ehBYAuCBHZEfZnYM//fRTuzsHBwcHq6SkRHl5eXazllx8d94dO3bYrc/snYM9PT1r/c7BZV9IK/u97AtfF/P29pa3t3el7wkA7sCR/Q4AQMNQk+yIj49XSkqK1qxZo+bNm9tmD/T395evr68OHjyolJQUPfDAA2rVqpW+/vprTZgwQX379lW3bt0kSffdd586d+6sRx99VLNnz5bVatXUqVMVHx9v+/w+ZswYLVy4UJMmTdLjjz+uTZs2acWKFVq3bp2tlsTERA0fPly33HKLevXqpfnz5+v06dO2m6NI0rBhw3TNNdcoKSlJkjRu3DjdeeedmjNnjmJiYrR8+XLt3LlTr7/+uiTJYrFo/Pjxev7559WxY0eFhoZq2rRpat26tW0ACwA0RPQ7AABmkR0AALPIDgCAWY7KjtLSUo0fP159+vRRly5dbM//6U9/Uvv27dW6dWt9/fXXmjx5snJycrRq1SpJktVqtft+riTb72XXTyprk5+fr8LCQv366686f/58hW2ys7Mrrbmy9ZZ/3/L1VNTmYklJSXruuecqfU8AwG88nPXGFYWW1WqVl5eX3ReDpUuDoaahdeLEiUpDq7JwqWq9NQ0tf39/24M7zgOAPcMwlJCQoA8++ECbNm265M7BPXv2VOPGjZWenm57LicnR7m5uba780ZGRmrPnj06duyYrU1Fdw4uv46yNhXdObhM2Z2Dy9pU5HLrLX/n4DJldw6uar0AAAAAHOe1117TyZMndddddykkJMT2eP/99yVd6A9s3LhR9913n8LCwvTXv/5VAwYM0EcffWRbh6enp9auXStPT09FRkZq6NChGjZsmGbOnGlrExoaqnXr1iktLU3du3fXnDlz9Oabb9pm2JWkRx55RK+88oqmT5+u8PBwZWVlKTU11e58U25uro4cOWL7/bbbblNKSopef/11de/eXf/617+0evVquwtFkyZN0pNPPqnRo0fr1ltvVUFBgVJTU+Xj41Mr+xQAAAAAAAAAADhPfHy89u7dq+XLl9s9P3r0aEVHR6tr164aMmSI3nnnHX3wwQc6ePCgkyqtXVOmTNHJkydtjx9//NHZJQFAvWV6xhJHKQutzz//3Fkl1AtTpkyxmwUlPz+fwSUAUM7l7hzs7++vkSNHKjExUS1btpSfn5+efPJJRUZGqnfv3pK4czAAAACAqhmGUeXytm3basuWLZddT/v27bV+/foq29x1113avXt3lW0SEhKUkJBQ6fLNmzdf8tzAgQM1cODASl9jsVg0c+ZMu4EuAAAAAAAAAADA/SQkJGjt2rX69NNP1aZNmyrbRkRESJIOHDig6667TsHBwdqxY4ddm6NHj0qSgoODbX+WPVe+jZ+fn3x9feXp6SlPT88K25StoyKVrbf8+5Y9FxISYtcmPDy8wnV6e3vbvh8GAKhatWYsWbBgge3nXbt21fhNy0Lrk08+sQut4OBglZSUKC8vz679xcFQUXCULauqTVloBQQE1HpoVXe93t7e8vPzs3sAgLupSXZc7s7BkjRv3jz1799fAwYMUN++fRUcHGybnlHizsEA4Ioc0e8AADQsZAcAwCyyAwBgFtkBADCL7AAAmFWT7DAMQwkJCfrggw+0adMmhYaGXvY1WVlZkmQbqBEZGak9e/bo2LFjtjZpaWny8/NT586dbW3S09Pt1pOWlqbIyEhJF2aC79mzp12b0tJSpaen29pU5HLrDQ0NVXBwsF2b/Px8bd++vcr1AgCqp1oDS5YtW2b7+YknnrjiN7tcaPXs2VONGze2O+jn5OQoNzfXdtAntADA9dQ0Oyp6PPbYY7Y2Pj4+WrRokX755RedPn1aq1atumRAX9mdg8+cOaPjx4/rlVdeUaNG9hN3ld05uLi4WAcPHrR7jzIJCQn64YcfVFxcrO3bt9tG7ZfZvHmzli5davfcwIEDlZOTo+LiYu3du1cPPPCA3fKyOwdbrVYVFRVp48aNuuGGG8zvLABwIzXJDgBAw0R2AADMIjsAAGaRHQAAs8gOAIBZNcmO+Ph4vfvuu0pJSVHz5s1ltVpltVpVWFgoSTp48KBmzZqlzMxMff/99/rwww81bNgw9e3bV926dZMk3XfffercubMeffRRffXVV9qwYYOmTp2q+Ph428wfY8aM0XfffadJkyYpOztbixcv1ooVKzRhwgRbLYmJiXrjjTe0bNky7d+/X2PHjtXp06c1YsQIW5thw4ZpypQptt/HjRun1NRUzZkzR9nZ2Xr22We1c+dO2yzvFotF48eP1/PPP68PP/xQe/bs0bBhw9S6dWvFxsZe8X4DAFzQ6PJNHCc+Pl4pKSlas2aNLbQkyd/fX76+vvL399fIkSOVmJioli1bys/PT08++aQiIyPVu3dvSfahNXv2bFmt1gpDa+HChZo0aZIef/xxbdq0SStWrNC6detstSQmJmr48OG65ZZb1KtXL82fP7/C0LrmmmuUlJQk6UJo3XnnnZozZ45iYmK0fPly7dy5U6+//rok+9Dq2LGjQkNDNW3aNEILAAAAAAAAAAAAAAAn2L9/vwICAtSuXTtnlwIAAADUqtdee03ShZvrlvf222/rsccek5eXlzZu3Gj7vmzbtm01YMAATZ061dbW09NTa9eu1dixYxUZGammTZtq+PDhmjlzpq1NaGio1q1bpwkTJmjBggVq06aN3nzzTUVHR9vaPPLIIzp+/LimT58uq9Wq8PBwpaamKigoyNYmNzdXHh6/3R//tttuU0pKiqZOnapnnnlGHTt21OrVq9WlSxdbm0mTJun06dMaPXq08vLydPvttys1NVU+Pj4O248A0FBVa2DJ8ePHtXjxYhmGYfu5vD//+c/VerPLhZYkzZs3Tx4eHhowYICKi4sVHR1t936EFgC4jjfeeEM+Pj41yg4AQMNCdgAAzCI7AABmkR3uYf/+/ZLEF4UB1AmywzUVFBTIYrFo6NCh8vX1VXZ2NpkBoM6QHQAAsxyRHYZhVLm8bdu22rJly2XX0759e61fv77KNnfddZd2795dZZuEhATbbCMV2bx58yXPDRw4UAMHDqz0NRaLRTNnzrT7zjAAwDGqNbDkiSee0PHjxy/52azLhZYk+fj4aNGiRVq0aFGlbQgtAHANP//8s7y9vWuUHQCAhoXsAACYRXYAAMwiO1zbmTNnbF8SlsQXhQHUCbLDNRUVFckwDPXt21effvqpTpw4QV4AqDNkBwDALLIDAOBs1RpYMmPGjNquAwDghp5++mn5+fk5uwwAgAshOwAAZpEdAACzyA7XVlJSIsMwFBcXJ0latWoVXxQGUOvIDtfm7+/v7BIANEBkBwDALLIDAOBs1RpYcrnZN6ZPn+6QYgAA7uXll1+Wt7d3hcvIDgBARcgOAIBZZAcAwCyywz0EBAQ4uwQADQjZAQAwi+wAAJhFdgAAnM2jOo1mzpypVatWSbpwor5Vq1Z2DwAAKvLRRx9JIjsAANVHdgAAzCI7AABmkR3uZ//+/dq1a5dyc3OdXQoAN0V2AADMIjsAAGaRHQAAZ6vWjCU//fST/vWvf+mDDz6Ql5eXBg4cqD/84Q+66qqrars+AIALGzZsmP7zn/+QHQCAaiM7AABmkR0AALPIDvdRUFAgi8WioUOHSpJ8fX2VnZ2tdu3aObkyAO6G7AAAmEV2AADMIjsAAM5WrRlLgoODlZCQoPT0dC1ZskQnT55Up06dtGzZstquDwDgwkaPHk12AABMITsAAGaRHQAAs8gO91FUVCTDMBQXF6e4uDgVFhbqxIkTzi4LgBsiOwAAZpEdAACzyA4AgLNVa8YSSTIMQ1u2bNH777+vHTt2aPDgwerTp09t1gYAcHGGYWjz5s1kBwCg2sgOAIBZZAcAwCyyw/0EBAQ4uwQAbo7sAACYRXYAAMwiOwAAzlatgSUJCQnatm2b7rjjDg0bNkyvvfZabdcFAHADd911l+666y6yAwBQbWQHAMAssgMAYBbZAQAwi+wAAJhFdgAAzCI7AADOVq2BJYsXL1bLli31ww8/6N1335XFYpF0YYSkxWLRsWPHarVIAIBrys3N1bvvvkt2AACqjewAAJhFdgAAzCI7AABmkR0AALPIDgCAWWQHAMDZqjWwpLS0tLbrAAC4oUOHDsnPz8/ZZQAAXAjZAQAwi+wAAJhFdgAAzCI7AABmkR0AALPIDgCAs1VrYElRUZGSk5N14MABdevWTY8//rgaNarWSwEADdjixYv1008/kR0AgGojOwAAZpEdAACzyA4AgFlkBwDALLIDAGAW2QEAcDaP6jQaPny4du7cqa5du2r9+vV66qmnarsuAIAb2L17N9kBADCF7AAAmEV2AADMIjsAAGaRHQAAs8gOAIBZZAcAwNmqNaRx37592rNnjyRp5MiR6tWrV60WBQBwD2+88Yb8/PzIDgBAtZEdAACzyA4AgFlkBwDALLIDAGAW2QEAMIvsAAA4W7UGljRu3Pi3FzC9FgDAJLLDdezfv1+SFBAQoHbt2jm5GgANGdkBADCL7AAAmEV2AADMIjsAAGaRHQAAs8gOAICzVCuBvv76awUGBkqSDMNQXl6eAgMDZRiGLBaLjh07VqtFAgBc03XXXSeLxUJ2uICCggJZLBYNHTpUkuTr66vs7GwGlwCoc2QHAMAssgMAYBbZ4d64cQqA2kB2AADMIjsAAGaRHQAAZ6vWwJJz587Vdh0AADd08OBB+fn5ObsMVENRUZEMw1BcXJwkadWqVTpx4gQX3wHUObIDAGAW2QEAMIvscE8X3zjF29tb//73vxUSEsIgEwA1Rna4BwYfAqhLZAcAwCyyAwDgbMyZBQAAbAICApxdAgAAAAAAAGBa+RunnDlzRhs2bFD//v0lMTsvADR0Z86cYdZ2AAAAAACAy/BwdgEAAAAAAAAAAACAIwQEBKhJkya2QSZxcXEqLCzUiRMnnF0aAMBJSkpKyAUAAAAAAIDLYMYSN8ZUvgAAAAAAAAAAoKFidl4AQHnkAgAAAAAAQOUYWOKGCgoKmMoXAAAAAAAAAAAAAAAAAAAAAABcFgNL3FBRUZFtKl9JWrVqlU6cOMHAEgAAAAAAAAAAAABAg7d//35JF2Yx4To6AAAAAAAAA0vcGlP5AgAAAAAAAAAAAABwQUFBgSwWi4YOHSpJ8vX1VXZ2NoNLAAAAAABAg+fh7AIAAAAAAAAAAAAAAABqW1FRkQzDUFxcnOLi4lRYWKjPPvtMu3btUm5urrPLAwAAAAAAcBpmLGkg9u/fzzS+AABTyA4AAAAAtWH//v2SRH8DAFCnONcFACgvICCA2UsAAAAAAADKYWCJmyt/Mszb21v//ve/FRISwsUTAEClymcHF1EAAAAAOApf2gIAOAPnugAAlSk/e4kkrVq1Sp999pk6derE9XQAAAAAANDgeDi7ANSuspNhvXr1UklJifr376+ePXsqLCyMqXwBABUqy46+ffuqsLBQJ06ccHZJAAAAANxA+S9txcXF0d8AANQJznUBAC4nICBAPj4+toGIXE8HAAAAAAANUYMfWLJo0SJ16NBBPj4+ioiI0I4dO6psv3LlSoWFhcnHx0ddu3bV+vXr7ZYbhqHp06crJCREvr6+ioqK0rffflubm1At3t7el1y4/+yzz7Rr1y5OiAGASQ0lO/z9/SVJ+/fvJy8AoIYaSnYAABzHnbMjICBAAQEBTnlvAHBn7pwdjsC5LgC4FNnxm4oGwn/22WfKyMjQrl27yA4A+P+RHQAAs9w5OzjPBMDdNOiBJe+//74SExM1Y8YM7dq1S927d1d0dLSOHTtWYfutW7dq8ODBGjlypHbv3q3Y2FjFxsZq7969tjazZ8/Wq6++quTkZG3fvl1NmzZVdHS0ioqK6mqzqlTR3VZuuOEGrVu3Trt27eLEGABcRkPKjjNnzlSaF2QEAFSfu2cHJ8sAwPHcPTvK279/PxkCAA7QkLLjSnGuCwDskR0Vu/h6ep8+fdSzZ88qr6tzjR1AQ+Hu2cH1DgBwPHfNjoKCAmY8BOCWGjm7AGeaO3euRo0apREjRkiSkpOTtW7dOi1ZskRPP/30Je0XLFigfv36aeLEiZKkWbNmKS0tTQsXLlRycrIMw9D8+fM1depUPfTQQ5Kkd955R0FBQVq9erUGDRpUdxtXhfJ3Wzlz5ow2bNig/v37S5IsFosMw5B0YZaTf//732rZsqW8vb0lXTiR1q5dO6fVDgDO1pCyo6SkpNK8KMuIkJAQFRcX23Li/2PvzuOyqvP//z8BZXEBU2Mxlygd0VzIDbEyS0Y0mq+M5phlmrl8dMCPSKNFY+ZSQ9m4NaKMmVvqx6UxKnUwQrExURO13EfLhpq8UEskTEHl/P7wx8krQTmyXheP++123eI653W9z/s64fXkfc71Pqfw5+uXkR0AqjtnzY7rD5ZJv2RD27Zt+dwHgFJy1uy43vU5cqvxxa9/LhxjZGZm6uzZs3bLAKC6qg7ZUVq3c6yLfAHgzMiO4hWeT7///vu1b9++W55Xv9U59luNc2419gGAqsJZs4PzHQBQfpw1O67/Dq4krV+/XmfPnrXLjevPYVgZEzAOAFCZqu3Ekvz8fGVkZCguLs5c5urqqrCwMKWnpxf5mvT0dMXGxtotCw8PV1JSkiTp5MmTstlsCgsLM9f7+PgoJCRE6enpRYZWXl6e8vLyzOfnz5+XJOXk5Fh6P7m5uZKkU6dOKTs7+4afC9u9ftnly5d14cIFGYahbt26KTc3V19++aW6deumvLw8ZWRkmAfGCnl4eOjdd9+Vn5+fXF1dVVBQIEnmz0UtK8nPVfl1VblvvCf2RUVsw9/fX/7+/rKi8DOs8CC6s6iu2fHrvCguI4pDdlTv11XlvvGeyI6K4OzZUVQ23Opzv7ifq9q/i4p+XVXuG/uC90R2VCxnz47rfzYMQ7/5zW/073//u8TjC+naGGPWrFmKjY01+1gdxx23+7qq3Dfek2P0rarsC7LjF9UpO65vt7j1ZXmsqzBfAgICqtS/i4p+XVXuG+/JMfpWVfYF2fELsqNkP1+9elXSzc+rl+Qc++1y5HFOVe4b74l9QXbcHmfPjso633G7r6vK/554T+wLR+tbWb8nsuMXzp4d0rWxQqGMjAz9/PPPKigoUFZWlp555hm77ZaUlfypav8uKvp1Vblv7Avek6NmR7WdWHL27FldvXpVfn5+dsv9/Px09OjRIl9js9mKrLfZbOb6wmXF1fxafHy8pk6desPyJk2alOyN/MpHH31U5M9ffvnlTdfv2LGjyJ9/LS8vT3/4wx9uq28Aqp+ffvpJPj4+ld2NMkN23DwjikN2ALCC7HC87Ph1NvC5D6CikR2Olx3X//zvf//bclt5eXmKioq6YRn5A6CkyA7Hzo5bne8oy2Nd5AuAQmQH2VGouPPqt3P+5FbIIcCxkR2Olx2c7wBQ2cgOx8uO638eNWrUbbX3a+QPACvKOjuq7cSSqiIuLs5uhmVBQYF+/PFHNWjQQC4uLiVuJycnR02aNNG3334rb2/v8uhqmXO0PjtafyX6XBEcrb9SxfTZMAz99NNPatSoUbm0X91V5+yoytifZYd9WbYcZX+SHeWL7Khc7Dfr2Ge3p7rtN7KjfJEdlY99d3vYb7evOuw7sqN8kR1VB/uw9NiHpecs+5DsKF9kR+Vgf1nD/rKG/UV2lDeyo2R4f47Lmd+bxPsrDtlRvsiOkuM9Ogfeo3O41Xssr+yothNLGjZsKDc3N2VlZdktz8rKKvZ2Mv7+/jetL/xvVlaWAgIC7GqCg4OLbNPDw0MeHh52y+rVq2flrdjx9vZ2uH8kjtZnR+uvRJ8rgqP1Vyr/PjvTDPpCZAdKgv1ZdtiXZcsR9ifZcQ3Z4bzYb9axz25PddpvZMc1ZIdzY9/dHvbb7XP2fUd2XEN2VA/sw9JjH5aeM+xDsuMassP5sL+sYX9ZU933F9lxDdlR+Xh/jsuZ35vE+ysK2XEN2VE18B6dA+/ROdzsPZZHdriWeYsOwt3dXR07dlRqaqq5rKCgQKmpqQoNDS3yNaGhoXb1kpSSkmLWBwYGyt/f364mJydHu3btKrZNAIDjIDsAAFaRHQAAq8gOAIBVZAcAwCqyAwBgFdkBALCK7AAAx1Nt71giSbGxsRo6dKg6deqkLl26aM6cObpw4YKGDRsmSRoyZIjuuusuxcfHS5LGjRunhx9+WDNnzlRERIRWr16tPXv2aOHChZIkFxcXxcTE6NVXX1WLFi0UGBiol19+WY0aNVJkZGRlvU0AQBkiOwAAVpEdAACryA4AgFVkBwDAKrIDAGAV2QEAsIrsAADHUq0nlgwcOFBnzpzR5MmTZbPZFBwcrOTkZPn5+UmSMjMz5er6y01dunXrplWrVmnSpEl66aWX1KJFCyUlJalNmzZmzcSJE3XhwgWNGjVK2dnZevDBB5WcnCxPT89yfS8eHh565ZVXbrhlV1XmaH12tP5K9LkiOFp/Jcfsc1VCdqA47M+yw74sW+zPykd2gP1mHfvs9rDfnAfZAYl9d7vYb7ePfefYyA5cj31YeuzD0mMfVn1kR/XF/rKG/WUN+8u5kR2Og/fnuJz5vUm8v+qI7HAsvEfnwHt0DpX1Hl0MwzAqdIsAAAAAAAAAAAAAAAAAAAAAAACoElxvXQIAAAAAAAAAAAAAAAAAAAAAAABnxMQSAAAAAAAAAAAAAAAAAAAAAACAaoqJJQAAAAAAAAAAAAAAAAAAAAAAANUUE0sAAAAAAAAAAAAAAAAAAAAAAACqKSaWOIGEhATdfffd8vT0VEhIiHbv3l1pfZkyZYpcXFzsHkFBQeb6S5cuKSoqSg0aNFCdOnXUv39/ZWVl2bWRmZmpiIgI1apVS76+vpowYYKuXLlSJv379NNP9bvf/U6NGjWSi4uLkpKS7NYbhqHJkycrICBAXl5eCgsL0/Hjx+1qfvzxRz399NPy9vZWvXr1NHz4cOXm5trVfPnll3rooYfk6empJk2aaMaMGeXW52efffaGfd67d+9K63N8fLw6d+6sunXrytfXV5GRkTp27JhdTVn9HqSlpalDhw7y8PBQ8+bNtXTp0nLrc48ePW7Yz6NHj660Pi9YsEDt2rWTt7e3vL29FRoaqn/+85/m+qq2j1H1VKXsqEocMSeqKkfMg6qMz31UBWTHL6r6uKeqIFdvj6ONAYFbIT/skSElQ4bcPnIEzoDsKF5FfT46q4o8XuWsKuoYFWAV2cFnXGm9/vrrcnFxUUxMjLmM/WXvv//9rwYPHqwGDRrIy8tLbdu21Z49e8z1/B0CR+OI2eHs4wFnzrLq9ne0s+Uqx3RRyBGzQ3LO3+HqcA6hOhzrrw7fLXPE7ybLgENbvXq14e7ubixevNg4dOiQMXLkSKNevXpGVlZWpfTnlVdeMe677z7j1KlT5uPMmTPm+tGjRxtNmjQxUlNTjT179hhdu3Y1unXrZq6/cuWK0aZNGyMsLMzYt2+fsWnTJqNhw4ZGXFxcmfRv06ZNxp///Gdj/fr1hiTj/ffft1v/+uuvGz4+PkZSUpLxxRdfGP/v//0/IzAw0Lh48aJZ07t3b6N9+/bGzp07jX/9619G8+bNjUGDBpnrz58/b/j5+RlPP/20cfDgQeP//u//DC8vL+Pvf/97ufR56NChRu/eve32+Y8//mhXU5F9Dg8PN5YsWWIcPHjQ2L9/v/HYY48ZTZs2NXJzc82asvg9+Prrr41atWoZsbGxxuHDh42//e1vhpubm5GcnFwufX744YeNkSNH2u3n8+fPV1qfP/zwQ2Pjxo3Gv//9b+PYsWPGSy+9ZNSsWdM4ePCgYRhVbx+jaqlq2VGVOGJOVFWOmAdVGZ/7qGxkh72qPu6pKsjV2+NoY0DgZsiPG5EhJUOG3D5yBI6O7Li5ivh8dGYVdbzKmVXEMSrAKrLjGj7jbt/u3buNu+++22jXrp0xbtw4czn76xc//vij0axZM+PZZ581du3aZXz99dfG5s2bjRMnTpg1/B0CR+Ko2eHs4wFnzrLq9He0M+Yqx3RhGI6bHYbhnL/D1eEcQnU41l8dvlvmiN9NZmKJg+vSpYsRFRVlPr969arRqFEjIz4+vlL688orrxjt27cvcl12drZRs2ZNY926deayI0eOGJKM9PR0wzCufRi6uroaNpvNrFmwYIHh7e1t5OXllWlff/1hW1BQYPj7+xtvvvmmXZ89PDyM//u//zMMwzAOHz5sSDI+//xzs+af//yn4eLiYvz3v/81DMMw5s+fb9xxxx12/X3hhReMli1blnmfDeNaQPTt27fY11R2n0+fPm1IMrZt22YYRtn9HkycONG477777LY1cOBAIzw8vMz7bBjXPryvH/D8WmX32TAM44477jAWLVrkEPsYlauqZUdV5Yg5UZU5Yh5UdXzuoyKRHfYcadxTVZCrt8cRx4DA9ciPG5Eh1pEht48cgSMiO0quvD4fq5PyOl5V3ZT1MSrAKrKjaHzGlcxPP/1ktGjRwkhJSbE7H8z+svfCCy8YDz74YLHr+TsEjsYZsqM6jAecPcuc8e9oZ81VjunCMBw7O5z9d7g6nEOoLsf6q8N3yxzhu8mut3efE1QF+fn5ysjIUFhYmLnM1dVVYWFhSk9Pr7R+HT9+XI0aNdI999yjp59+WpmZmZKkjIwMXb582a6/QUFBatq0qdnf9PR0tW3bVn5+fmZNeHi4cnJydOjQoXLt98mTJ2Wz2ez65+Pjo5CQELv+1atXT506dTJrwsLC5Orqql27dpk13bt3l7u7u917OHbsmM6dO1cufU9LS5Ovr69atmypMWPG6IcffjDXVXafz58/L0mqX7++pLL7PUhPT7dro7CmLH73f93nQitXrlTDhg3Vpk0bxcXF6eeffzbXVWafr169qtWrV+vChQsKDQ11iH2MylNVs8MROHJOVAWOmAdVFZ/7qGhkR9EcddxTVZCrpVOVx4BAIfKjeGRI6ZAhpUeOoKoiO0qnrD4fq5PyOl5VXZTXMSrACrKjeHzGlUxUVJQiIiJuODbO/rL34YcfqlOnThowYIB8fX11//336+233zbX83cIHImzZocz/jt01ixz5r+jnTlXOaZbvTlDdlSn3+HqdA7B2Y71V4fvljnCd5OZWOLAzp49q6tXr9r9skiSn5+fbDZbpfQpJCRES5cuVXJyshYsWKCTJ0/qoYce0k8//SSbzSZ3d3fVq1ev2P7abLYi30/huvJU2P7N9qfNZpOvr6/d+ho1aqh+/fqV9h569+6t5cuXKzU1VW+88Ya2bdumPn366OrVq5Xe54KCAsXExOiBBx5QmzZtzPbK4veguJqcnBxdvHixTPssSU899ZRWrFihrVu3Ki4uTu+++64GDx5srq+MPh84cEB16tSRh4eHRo8erffff1+tW7eu8vsYlasqZoejcNScqAocMQ+qIj73UVnIjhs58rinqiBXb19VHgMC1yM/ikaGlB4ZUjrkCKoysqN0yurzsbooz+NVzq68j1EBVpAdReMzrmRWr16tvXv3Kj4+/oZ17C97X3/9tRYsWKAWLVpo8+bNGjNmjP73f/9Xy5Ytk8TfIXAszpodzvbv0BmzzNn/jnbmXOWYLhw9O6rb73B1OYfgbMf6q8N3yxzlu8k1LFUDt9CnTx/z53bt2ikkJETNmjXT2rVr5eXlVYk9c15PPvmk+XPbtm3Vrl073XvvvUpLS1PPnj0rsWfXZqIfPHhQ27dvr9R+WFFcn0eNGmX+3LZtWwUEBKhnz5766quvdO+991Z0NyVJLVu21P79+3X+/Hm99957Gjp0qLZt21YpfQGAm3HEPKiK+NwHqg7GPahMVXkMCODWyBBUNnIEAK7heNXt4xgVUPXxGXdr3377rcaNG6eUlBR5enpWdneqvIKCAnXq1El/+ctfJEn333+/Dh48qMTERA0dOrSSewfAGTljljnz39HOnqsc04Wj43fYOTnbsX5nzP5fc5TvJnPHEgfWsGFDubm5KSsry255VlaW/P39K6lX9urVq6ff/OY3OnHihPz9/ZWfn6/s7Gy7muv76+/vX+T7KVxXngrbv9n+9Pf31+nTp+3WX7lyRT/++GOVeA+SdM8996hhw4Y6ceJEpfY5OjpaGzZs0NatW9W4cWNzeVn9HhRX4+3tfdt/8BTX56KEhIRIkt1+rug+u7u7q3nz5urYsaPi4+PVvn17zZ07t0rvY1Q+R8iOqspZcqKiOWIeVFV87qOykB235kjjnqqCXC07VWUMCPwa+VEyZIh1ZEjZIkdQlZAdpVNWn4/VQXkfr3J25X2MCrCC7LgRn3Elk5GRodOnT6tDhw6qUaOGatSooW3btumtt95SjRo15Ofnx/66TkBAgFq3bm23rFWrVsrMzJTE3yFwLM6aHc7079BZs8yZ/46ubrnKMd3qx9myw9l/h6vrOQRHPtZfHb5b5kjfTWZiiQNzd3dXx44dlZqaai4rKChQamqqQkNDK7Fnv8jNzdVXX32lgIAAdezYUTVr1rTr77Fjx5SZmWn2NzQ0VAcOHLD7QEtJSZG3t/cNByrKWmBgoPz9/e36l5OTo127dtn1Lzs7WxkZGWbNli1bVFBQYP5jDg0N1aeffqrLly/bvYeWLVvqjjvuKNf3IEnfffedfvjhBwUEBFRKnw3DUHR0tN5//31t2bJFgYGBduvL6vcgNDTUro3Cmtv53b9Vn4uyf/9+SbLbzxXZ56IUFBQoLy+vSu5jVB2OkB1VlbPkREVxxDxwNHzuo6KQHbfmSOOeqoJcLTuVPQYEikN+lAwZYh0ZUrbIEVQlZEfplNXnozOrqONV1U1ZH6MCrCA7fsFnnDU9e/bUgQMHtH//fvPRqVMnPf300+bP7K9fPPDAAzp27Jjdsn//+99q1qyZJP4OgWNx1uxwhn+H1S3LnOnv6OqWqxzTrX6cLTuc/Xe4up5DcMRj/dXhu2UO+d1kAw5t9erVhoeHh7F06VLj8OHDxqhRo4x69eoZNputUvrz/PPPG2lpacbJkyeNzz77zAgLCzMaNmxonD592jAMwxg9erTRtGlTY8uWLcaePXuM0NBQIzQ01Hz9lStXjDZt2hi9evUy9u/fbyQnJxt33nmnERcXVyb9++mnn4x9+/YZ+/btMyQZs2bNMvbt22f85z//MQzDMF5//XWjXr16xgcffGB8+eWXRt++fY3AwEDj4sWLZhu9e/c27r//fmPXrl3G9u3bjRYtWhiDBg0y12dnZxt+fn7GM888Yxw8eNBYvXq1UatWLePvf/97mff5p59+Mv70pz8Z6enpxsmTJ41PPvnE6NChg9GiRQvj0qVLldLnMWPGGD4+PkZaWppx6tQp8/Hzzz+bNWXxe/D1118btWrVMiZMmGAcOXLESEhIMNzc3Izk5OQy7/OJEyeMadOmGXv27DFOnjxpfPDBB8Y999xjdO/evdL6/OKLLxrbtm0zTp48aXz55ZfGiy++aLi4uBgff/xxldzHqFqqWnZUJY6YE1WVI+ZBVcbnPiob2WGvqo97qgpy9fY42hgQuBny40ZkSMmQIbePHIGjIzturiI+H51ZRR2vcmYVcYwKsIrsuIbPuNJ7+OGHjXHjxpnP2V+/2L17t1GjRg3jtddeM44fP26sXLnSqFWrlrFixQqzhr9D4EgcNTucfTzgzFlWHf+OdqZc5ZguDMNxs8MwnPN3uDqcQ6gOx/qrw3fLHPG7yUwscQJ/+9vfjKZNmxru7u5Gly5djJ07d1ZaXwYOHGgEBAQY7u7uxl133WUMHDjQOHHihLn+4sWLxh//+EfjjjvuMGrVqmX8/ve/N06dOmXXxjfffGP06dPH8PLyMho2bGg8//zzxuXLl8ukf1u3bjUk3fAYOnSoYRiGUVBQYLz88suGn5+f4eHhYfTs2dM4duyYXRs//PCDMWjQIKNOnTqGt7e3MWzYMOOnn36yq/niiy+MBx980PDw8DDuuusu4/XXXy+XPv/8889Gr169jDvvvNOoWbOm0axZM2PkyJE3/MFSkX0uqq+SjCVLlpg1ZfV7sHXrViM4ONhwd3c37rnnHrttlGWfMzMzje7duxv169c3PDw8jObNmxsTJkwwzp8/X2l9fu6554xmzZoZ7u7uxp133mn07NnTHHAaRtXbx6h6qlJ2VCWOmBNVlSPmQVXG5z6qArLjF1V93FNVkKu3x9HGgMCtkB/2yJCSIUNuHzkCZ0B2FK+iPh+dVUUer3JWFXWMCrCK7OAzriz8+guw7C97H330kdGmTRvDw8PDCAoKMhYuXGi3nr9D4GgcMTucfTzgzFlWHf+OdqZc5ZguCjlidhiGc/4OV4dzCNXhWH91+G6ZI3432eX/7zgAAAAAAAAAAAAAAAAAAAAAAACqGdfK7gAAAAAAAAAAAAAAAAAAAAAAAAAqBxNLAAAAAAAAAAAAAAAAAAAAAAAAqikmlgAAAAAAAAAAAAAAAAAAAAAAAFRTTCwBAAAAAAAAAAAAAAAAAAAAAACopphYAgAAAAAAAAAAAAAAAAAAAAAAUE0xsQQAAAAAAAAAAAAAAAAAAAAAAKCaYmIJAAAAAAAAAAAAAAAAAAAAAABANcXEEgAAAAAAAAAAAAAAAAAAAAAAgGqKiSUAAAAAAAAAAAAAAACABVOmTJGfn59cXFyUlJRU2d0BAAAAAKBUmFgCVLBnn31WkZGRNyxPS0uTi4uLsrOz7X6+lfDwcLm5uenzzz+31I+goCB5eHjIZrOVqM8uLi7mo0GDBurdu7e+/PLLEm3rH//4h3r06CEfHx/VqVNH7dq107Rp0/Tjjz9a6jMAoGg2m01jx47VPffcIw8PDzVp0kS/+93vlJqaKkm6++67zc9wLy8v3X333frDH/6gLVu2FNvmDz/8oMaNG9+QR4UZ9evH9XlyfW7UrFlTgYGBmjhxoi5dunTDdr777ju5u7urTZs2ZbdDAAC3pSzz5H//93/VsWNHeXh4KDg4+Ib1aWlp6tu3rwICAlS7dm0FBwdr5cqVdjXr169Xp06dVK9ePbPm3XffLZf3DgAoP2WVL0uXLi1yLOLi4qLTp09XxlsDANyGihx3SNKXX36phx56SJ6enmrSpIlmzJhht76ofPH09Czz9w0AKL2KPBciSQkJCWrVqpW8vLzUsmVLLV++3G79kSNHNHXqVP3973/XqVOn1KdPnzJ/zwCA21PR4461a9cqODhYtWrVUrNmzfTmm28W27fPPvtMNWrUKLYtAEDVVdFjEqAyMLEEcGCZmZnasWOHoqOjtXjx4hK/bvv27bp48aKeeOIJLVu2rESv6d27t06dOqVTp04pNTVVNWrU0OOPP37L1/35z3/WwIED1blzZ/3zn//UwYMHNXPmTH3xxRd8KQwAysA333yjjh07asuWLXrzzTd14MABJScn65FHHlFUVJRZN23aNJ06dUrHjh3T8uXLVa9ePYWFhem1114rst3hw4erXbt2xW732LFjZi6cOnVKvr6+dusLc+Prr7/W7Nmz9fe//12vvPLKDe0sXbpUf/jDH5STk6Ndu3bd5l4AAJRWeeTJc889p4EDBxa5vR07dqhdu3b6xz/+oS+//FLDhg3TkCFDtGHDBrOmfv36+vOf/6z09HSzZtiwYdq8eXPZ7wAAQLkoy3wZOHCg3Rjk1KlTCg8P18MPP3zDeAQAUDVV9LgjJydHvXr1UrNmzZSRkaE333xTU6ZM0cKFC+3qvL297fLlP//5T9m+cQBAqVX0uZAFCxYoLi5OU6ZM0aFDhzR16lRFRUXpo48+Mmu++uorSVLfvn3l7+8vDw+PMn7XAIDbUdHjjn/+8596+umnNXr0aB08eFDz58/X7NmzNW/evBtqs7OzNWTIEPXs2bPs3jAAoEJU1vezgIpWo7I7AOD2LVmyRI8//rjGjBmjrl27atasWfLy8rrl69555x099dRTevjhhzVu3Di98MILt3yNh4eH/P39JUn+/v568cUX9dBDD+nMmTO68847i3zN7t279Ze//EVz5szRuHHjzOV33323fvvb3zLDEgDKwB//+Ee5uLho9+7dql27trn8vvvu03PPPWc+r1u3rvk53rRpU3Xv3l0BAQGaPHmynnjiCbVs2dKsXbBggbKzszV58mT985//LHK7vr6+qlevXrH9uj43mjRporCwMKWkpOiNN94wawzD0JIlSzR//nw1btxY77zzjkJCQm5rPwAASqes8+Stt96SJJ05c6bIOx2+9NJLds/HjRunjz/+WOvXrzcnsPfo0eOGmmXLlmn79u0KDw8v/ZsGAJS7sswXLy8vu+NeZ86c0ZYtW/TOO+9U3BsCAJRKRY87Vq5cqfz8fC1evFju7u667777tH//fs2aNUujRo0y61xcXMztAQCqpoo+F/Luu+/qf/7nf8wvEd9zzz36/PPP9cYbb+h3v/udpkyZoqlTp0qSXF2vXc/VMIzyefMAAEsqetzx7rvvKjIyUqNHj5Z0LTPi4uL0xhtvKCoqSi4uLmbt6NGj9dRTT8nNzU1JSUll/t4BAOWnsr6fBVQ07lgCOKjCL+MOHjxYQUFBat68ud57771bvu6nn37SunXrNHjwYP32t7/V+fPn9a9//cvStnNzc7VixQo1b95cDRo0KLZu5cqVqlOnjv74xz8Wuf5mX0gGANzajz/+qOTkZEVFRdkNWgrd6nN23LhxMgxDH3zwgbns8OHDmjZtmpYvX26eDClKcHCwAgIC9Nvf/lafffbZTbdz8OBB7dixQ+7u7nbLt27dqp9//llhYWEaPHiwVq9erQsXLty0LQBA2SuPPLkd58+fV/369YtcZxiGUlNTdezYMXXv3r1U2wEAVIzyzpfly5erVq1aeuKJJ8qiuwCAclYZ44709HR1797d7phUeHi4jh07pnPnzpnLcnNz1axZMzVp0kR9+/bVoUOHSrwNAED5q4xzIXl5efL09LRb5uXlpd27d+vy5cv605/+pCVLlkiSeccrAEDlq4xxR3GZ8d1339ndDXHJkiX6+uuv9corr5S4bQBA1VCZ388CKhq/jUAl2LBhg+rUqWP36NOnj6U2PvnkE/3888/mlXoHDx5cois0rl69Wi1atNB9990nNzc3PfnkkyV63fV9rlu3rj788EOtWbPmpqF2/Phx3XPPPapZs2bJ3xgAoMROnDghwzAUFBR0W6+vX7++fH199c0330i6dtBr0KBBevPNN9W0adMiXxMQEKDExET94x//0D/+8Q81adJEPXr00N69e+3qCnPD09NTbdu21enTpzVhwgS7mnfeeUdPPvmk3Nzc1KZNG91zzz1at27dbb0XAMDtK+s8uR1r167V559/rmHDhtktP3/+vOrUqSN3d3dFRETob3/7m37729/e9nYAABWnvPOl8I68Jbl7LwCg8lXGuMNms8nPz89uWeFzm80mSWrZsqUWL16sDz74QCtWrFBBQYG6deum77777rb6CQAoe5VxLiQ8PFyLFi1SRkaGDMPQnj17tGjRIl2+fFlnz55VnTp1zC+P+fv7c+crAKgiKmPcER4ervXr1ys1NVUFBQX697//rZkzZ0qSOfHw+PHjevHFF7VixQrVqFHjtvoGAKg8lTEmASoLE0uASvDII49o//79do9FixZZamPx4sUaOHCgOeAYNGiQPvvsM3311VeSrt0+8fqJK9e/bvDgwebzwYMHa926dfrpp58kSX369DFfc9999xXZ5927dys8PFx9+vQxZ9cX9Tpu9wsA5assPmcNwzBvvxsXF6dWrVrZ5cSvtWzZUv/zP/+jjh07qlu3blq8eLG6deum2bNn29UV5sauXbs0dOhQDRs2TP379zfXZ2dna/369TdkUkkmOwIAylZZ54lVW7du1bBhw/T222/bjUGka7cK3r9/vz7//HO99tprio2NVVpaWqn7CwAof+WZL+np6Tpy5IiGDx9e6m0AACpGZY87ihMaGqohQ4YoODhYDz/8sNavX68777xTf//738t0OwCA21cZ50Jefvll9enTR127dlXNmjXVt29fDR06VJK4mjAAVGGVMe4YOXKkoqOj9fjjj8vd3V1du3bVk08+KelaZly9elVPPfWUpk6dqt/85jel7h8AoOJVxpgEqCyMeIFKULt2bTVv3tzucdddd5X49T/++KPef/99zZ8/XzVq1FCNGjV011136cqVK1q8eLEkadq0aXYTV6Rrt8/auXOnJk6caL6ua9eu+vnnn7V69WpJ0qJFi8zXbNq0qcg+d+7cWYsWLdKFCxf09ttvF/u63/zmN/r66691+fLlsthtAIBfadGihVxcXHT06NHbev0PP/ygM2fOKDAwUJK0ZcsWrVu3zsyInj17SpIaNmx401vydunSRSdOnLBbVpgb7du31+LFi7Vr1y67SSOrVq3SpUuXFBISYm7vhRde0Pbt2/Xvf//7tt4PAOD2lHWeWLFt2zb97ne/0+zZszVkyJAb1ru6uqp58+YKDg7W888/ryeeeELx8fG31U8AQMUqz3xZtGiRgoOD1bFjx9J2EwBQQSpj3OHv76+srCy7ZYXPi7uyfM2aNXX//fffcKwLAFB5KuNciJeXlxYvXqyff/5Z33zzjTIzM3X33Xerbt26uvPOO8vmjQEAylxljDtcXFz0xhtvKDc3V//5z39ks9nUpUsXSdI999yjn376SXv27FF0dLSZPdOmTdMXX3yhGjVqaMuWLbfVVwBAxakq388CKgITSwAHtHLlSjVu3FhffPGF3eSRmTNnaunSpbp69ap8fX3tJq5I0jvvvKPu3bvf8LrY2Fjzy7533XWX+ZpmzZoV2wcXFxe5urrq4sWLxb7uqaeeUm5urubPn19kG9nZ2WW4VwCg+qlfv77Cw8OVkJCgCxcu3LD+Vp+zc+fOlaurqyIjIyVJ//jHP+wyovBuWv/6178UFRVVbDv79+9XQEBAsetdXV310ksvadKkSWZuvPPOO3r++eft8uiLL77QQw89ZE6SBABUjLLOk5JKS0tTRESE3njjDY0aNapErykoKFBeXp6l7QAAKkd55Utubq7Wrl3L3UoAwMFUxrgjNDRUn376qd3Fr1JSUtSyZUvdcccdRb7m6tWrOnDgwE2PdQEAKlZlngupWbOmGjduLDc3N61evVqPP/44dywBgCqsss53SJKbm5vuuusuubu76//+7/8UGhqqO++8U97e3jpw4IDdefHRo0erZcuW2r9/v0JCQixvCwBQsarK97OAilCjsjsAoHgHDhxQ3bp1zecuLi5q37693nnnHT3xxBNq06aNXX2TJk0UFxen5ORkRURE2K27fPmy3n33XU2bNu2G140YMUKzZs3SoUOHdN999xXZl7y8PNlsNknSuXPnNG/ePOXm5up3v/tdsf0PCQnRxIkT9fzzz+u///2vfv/736tRo0Y6ceKEEhMT9eCDD2rcuHGW9gkAwF5CQoIeeOABdenSRdOmTVO7du105coVpaSkaMGCBTpy5Igk6aeffpLNZtPly5d18uRJrVixQosWLVJ8fLw5AfHee++1a/vs2bOSpFatWqlevXqSpDlz5igwMFD33XefLl26pEWLFmnLli36+OOPb9rPAQMGaMKECUpISFBYWJj27t2rlStXKigoyK5u0KBBmjZtml599VXVqMGfqgBQUcoyTyTpxIkTys3Nlc1m08WLF827KLZu3Vru7u7aunWrHn/8cY0bN079+/c3xxru7u6qX7++JCk+Pl6dOnXSvffeq7y8PG3atEnvvvuuFixYULE7BwBw28o6XyRpzZo1unLlCreIBwAHVNHjjqeeekpTp07V8OHD9cILL+jgwYOaO3euZs+ebbYxbdo0de3aVc2bN1d2drbefPNN/ec//9GIESMqdN8AAG6uos+F/Pvf/9bu3bsVEhKic+fOadasWTp48KCWLVtWcW8aAHBbKnrccfbsWb333nvq0aOHLl26pCVLlmjdunXatm2bpGsXYfz197R8fX3l6el5w3IAQNVV0WMSoNIYACrU0KFDjb59+96wfOvWrYYk49y5c+bPv364ubkZe/bsMSQZu3fvLrL9Pn36GL///e9vWP7ee+8Zrq6uhs1mK/J1rVq1MsaPH19sn6/vR926dY3OnTsb7733Xone85o1a4zu3bsbdevWNWrXrm20a9fOmDZtmnHu3LkSvR4AcHPff/+9ERUVZTRr1sxwd3c37rrrLuP//b//Z2zdutUwDMNo1qyZ+Rnu7u5uNG3a1PjDH/5gbNmy5abtXp9Nhd544w3j3nvvNTw9PY369esbPXr0uKGd4rIuPj7euPPOO40RI0YYrVu3LnKbp06dMlxdXY0PPvjA0j4AAJReWebJww8/XOSY5uTJk4Zh3DjGKHw8/PDDZht//vOfjebNmxuenp7GHXfcYYSGhhqrV6+ugD0BAChLZT1eCQ0NNZ566qkKfAcAgLJUkeMOwzCML774wnjwwQcNDw8P46677jJef/11uzZiYmKMpk2bGu7u7oafn5/x2GOPGXv37i3PXQAAuE0VeS7k8OHDRnBwsOHl5WV4e3sbffv2NY4ePWr3uvfff9/gKzcAUDVV5LjjzJkzRteuXY3atWsbtWrVMnr27Gns3Lnzpv175ZVXjPbt25fxuwYAlLeKHJMAlcXFMAyj7KerAAAAAAAAAAAAAAAAAAAAAAAAoKpzrewOAAAAAAAAAAAAAAAAAAAAAAAAoHIwsQQAAAAAAAAAAAAAAAAAAAAAAKCaYmIJAAAAAAAAAAAAAAAAAAAAAABANcXEEgAAAAAAAAAAAAAAAAAAAAAAgGqKiSUAAAAAAAAAAAAAAAAAAAAAAADVFBNLAAAAAAAAAAAAAAAAAAAAAAAAqikmlgAAAAAAAAAAAAAAAAAAAAAAAFRTTCwBAAAAAAAAAAAAAAAAAAAAAACopphYAgAAAAAAAAAAAAAAAAAAAAAAUE1V2sSS119/XS4uLoqJiTGXXbp0SVFRUWrQoIHq1Kmj/v37Kysry+51mZmZioiIUK1ateTr66sJEyboypUrdjVpaWnq0KGDPDw81Lx5cy1duvSG7SckJOjuu++Wp6enQkJCtHv37lv2ed26dQoKCpKnp6fatm2rTZs22a03DEOTJ09WQECAvLy8FBYWpuPHj5d8pwAAAAAAAAAAAAAAAAAAAAAAAFSgSplY8vnnn+vvf/+72rVrZ7d8/Pjx+uijj7Ru3Tpt27ZN33//vfr162euv3r1qiIiIpSfn68dO3Zo2bJlWrp0qSZPnmzWnDx5UhEREXrkkUe0f/9+xcTEaMSIEdq8ebNZs2bNGsXGxuqVV17R3r171b59e4WHh+v06dPF9nnHjh0aNGiQhg8frn379ikyMlKRkZE6ePCgWTNjxgy99dZbSkxM1K5du1S7dm2Fh4fr0qVLZbHbAAAAAAAAAAAAAAAAAAAAAAAAypSLYRhGRW4wNzdXHTp00Pz58/Xqq68qODhYc+bM0fnz53XnnXdq1apVeuKJJyRJR48eVatWrZSenq6uXbvqn//8px5//HF9//338vPzkyQlJibqhRde0JkzZ+Tu7q4XXnhBGzdutJvw8eSTTyo7O1vJycmSpJCQEHXu3Fnz5s2TJBUUFKhJkyYaO3asXnzxxSL7PXDgQF24cEEbNmwwl3Xt2lXBwcFKTEyUYRhq1KiRnn/+ef3pT3+SJJ0/f15+fn5aunSpnnzyyRLtn4KCAn3//feqW7euXFxcLO5dAKgaDMPQTz/9pEaNGsnVtdJujlVtkB0AnAHZUbHIDgDOgOyoWGQHAGdAdlQssgOAMyA7KhbZAcAZkB0Vi+wA4AzIjopFdgBwBuWVHTXKrKUSioqKUkREhMLCwvTqq6+ayzMyMnT58mWFhYWZy4KCgtS0aVNzYkl6erratm1rTiqRpPDwcI0ZM0aHDh3S/fffr/T0dLs2CmtiYmIkSfn5+crIyFBcXJy53tXVVWFhYUpPTy+23+np6YqNjb2h3aSkJEnX7pRis9nstu3j46OQkBClp6cXO7EkLy9PeXl55vP//ve/at26dbH9AABH8u2336px48aV3Q2n9/3336tJkyaV3Q0AKBNkR8UgOwA4E7KjYpAdAJwJ2VExyA4AzoTsqBhkBwBnQnZUDLIDgDMhOyoG2QHAmZR1dlToxJLVq1dr7969+vzzz29YZ7PZ5O7urnr16tkt9/Pzk81mM2uun1RSuL5w3c1qcnJydPHiRZ07d05Xr14tsubo0aPF9r24dq/f7vX9KaqmKPHx8Zo6deoNy7/99lt5e3sX+zoAqMpycnLUpEkT1a1bt7K7Ui0U7meyA4AjIzsqFtkBwBmQHRWL7ADgDMiOikV2AHAGZEfFIjsAOAOyo2KRHQCcAdlRscgOAM6gvLKjwiaWfPvttxo3bpxSUlLk6elZUZut8uLi4uzuhFL4P9rb25vQAuDwuF1gxSjcz2QHAGdAdlQMsgOAMyE7KgbZAcCZkB0Vg+wA4EzIjopBdgBwJmRHxSA7ADgTsqNikB0AnElZZ4drmbZ2ExkZGTp9+rQ6dOigGjVqqEaNGtq2bZveeust1ahRQ35+fsrPz1d2drbd67KysuTv7y9J8vf3V1ZW1g3rC9fdrMbb21teXl5q2LCh3NzciqwpbKMoxbV7/Xav709J2/Xw8DADiqACAAAAAAAAAAAAAAAAAAAAAAAVqcLuWNKzZ08dOHDAbtmwYcMUFBSkF154QU2aNFHNmjWVmpqq/v37S5KOHTumzMxMhYaGSpJCQ0P12muv6fTp0/L19ZUkpaSkyNvbW61btzZrNm3aZLedlJQUsw13d3d17NhRqampioyMlCQVFBQoNTVV0dHRxfY/NDRUqampiomJKbLdwMBA+fv7KzU1VcHBwZKu3X1k165dGjNmzG3sMesyMzN19uxZSVLDhg3VtGnTCtkuAMBxkR0AAKvIDgCAVWQHAMAqsgMAUBrkCACgJMgLAIBVZAcAZ1dhE0vq1q2rNm3a2C2rXbu2GjRoYC4fPny4YmNjVb9+fXl7e2vs2LEKDQ1V165dJUm9evVS69at9cwzz2jGjBmy2WyaNGmSoqKi5OHhIUkaPXq05s2bp4kTJ+q5557Tli1btHbtWm3cuNHcbmxsrIYOHapOnTqpS5cumjNnji5cuKBhw4aZNUOGDNFdd92l+Ph4SdK4ceP08MMPa+bMmYqIiNDq1au1Z88eLVy4UNK1W8nExMTo1VdfVYsWLRQYGKiXX35ZjRo1MiewlKfMzEwFBQXp4sWLkiQvLy8dPXqU4AIAFIvsAABYRXYAAKwiOwAAVpEdAIDSIEcAACVBXgAArCI7AFQHFTaxpCRmz54tV1dX9e/fX3l5eQoPD9f8+fPN9W5ubtqwYYPGjBmj0NBQ1a5dW0OHDtW0adPMmsDAQG3cuFHjx4/X3Llz1bhxYy1atEjh4eFmzcCBA3XmzBlNnjxZNptNwcHBSk5Olp+fn1mTmZkpV1dX83m3bt20atUqTZo0SS+99JJatGihpKQku8kyEydO1IULFzRq1ChlZ2frwQcfVHJysjw9Pctrl5nOnj2rixcvql+/fpKk9evX6+zZs4QWAKBYZAcAwCqyAwBgFdkBALCK7AAAlAY5AgAoCfICAGAV2QGgOqjUiSVpaWl2zz09PZWQkKCEhIRiX9OsWTNt2rTppu326NFD+/btu2lNdHS0oqOjS9w3SRowYIAGDBhQ7GtcXFw0bdo0u4kuFa1hw4aVtm0AgGMiOwAAVpEdAACryA4AgFVkBwCgNMgRAEBJkBcAAKvIDgDOzPXWJQAAAAAAAAAAAAAAAAAAAAAAAHBGTCwBAAAAAAAAAAAAAAAAAAAAAACopphYAgAAAAAAAAAAAAAAAAAAAAAAUE0xsQQAAAAAAAAAAAAAAAAAAAAAAKCaYmIJAAAAAAAAAAAAAAAAAAAAAABANcXEEgAAAAAAAAAAAAAAylF8fLw6d+6sunXrytfXV5GRkTp27JhdzaVLlxQVFaUGDRqoTp066t+/v7KysuxqMjMzFRERoVq1asnX11cTJkzQlStX7GrS0tLUoUMHeXh4qHnz5lq6dOkN/UlISNDdd98tT09PhYSEaPfu3bd8D+vWrVNQUJA8PT3Vtm1bbdq0yW69YRiaPHmyAgIC5OXlpbCwMB0/fryEewgAAAAAAACViYklAAAAAAAAAAAAAACUo23btikqKko7d+5USkqKLl++rF69eunChQtmzfjx4/XRRx9p3bp12rZtm77//nv169fPXH/16lVFREQoPz9fO3bs0LJly7R06VJNnjzZrDl58qQiIiL0yCOPaP/+/YqJidGIESO0efNms2bNmjWKjY3VK6+8or1796p9+/YKDw/X6dOni+3/jh07NGjQIA0fPlz79u1TZGSkIiMjdfDgQbNmxowZeuutt5SYmKhdu3apdu3aCg8P16VLl8pqNwIAAAAAAKCcMLEEAAAAAAAAAAAAAIBylJycrGeffVb33Xef2rdvr6VLlyozM1MZGRmSpPPnz+udd97RrFmz9Oijj6pjx45asmSJduzYoZ07d0qSPv74Yx0+fFgrVqxQcHCw+vTpo+nTpyshIUH5+fmSpMTERAUGBmrmzJlq1aqVoqOj9cQTT2j27NlmX2bNmqWRI0dq2LBhat26tRITE1WrVi0tXry42P7PnTtXvXv31oQJE9SqVStNnz5dHTp00Lx58yRdu1vJnDlzNGnSJPXt21ft2rXT8uXL9f333yspKamc9uovMjMztXfvXh05cqTctwUAAAAAAOCMmFgCAAAAAAAAAAAAAEAFOn/+vCSpfv36kqSMjAxdvnxZYWFhZk1QUJCaNm2q9PR0SVJ6erratm0rPz8/syY8PFw5OTk6dOiQWXN9G4U1hW3k5+crIyPDrsbV1VVhYWFmTVFu1e7Jkydls9nsanx8fBQSElJsu3l5ecrJybF73I7MzEwFBQWpY8eOGjx48G21AQAAAAAAUN3VsPqCzz77TN98842uXr1qLhsyZEiZdgoA4FzIDgCAVWQHAMAqsgMAYBXZAQCwqqyyo6CgQDExMXrggQfUpk0bSZLNZpO7u7vq1atnV+vn5yebzWbWXD+ppHB94bqb1eTk5OjixYs6d+6crl69WmTN0aNHi+1zce1ev93r+1NUza/Fx8dr6tSpxW6zpM6ePauLFy+qX79+OnfunLZu3VrqNgGgrDDuAABYRXYAACqLpYklgwYNks1m0/333y83NzdJkouLS7l0DADgHMgOAIBVZAcAwCqyAwBgFdkBALCqLLMjKipKBw8e1Pbt28uyiw4nLi5OsbGx5vOcnBw1adLktttr2LBhWXQLAMoM4w4AgFVkBwCgMlmaWPLFF1/o8OHD5dUXAIATIjsAAFaRHQAAq8gOAIBVZAcAwKqyyo7o6Ght2LBBn376qRo3bmwu9/f3V35+vrKzs+3uWpKVlSV/f3+zZvfu3XbtZWVlmesK/1u47Poab29veXl5yc3NTW5ubkXWFLZRlOLavX67hcsCAgLsaoKDg4ts08PDQx4eHsVuEwAcHeMOAIBVZAcAoDK5Winu0qWLjh07Vl59AQA4IbIDAGAV2QEAsIrsAABYVZbZ8frrr8vFxUUxMTHmskuXLikqKkoNGjRQnTp11L9//xu+jJuZmamIiAjVqlVLvr6+mjBhgq5cuWJXk5aWpg4dOsjDw0PNmzfX0qVLb9h+QkKC7r77bnl6eiokJOSGLxwXZd26dQoKCpKnp6fatm2rTZs22a03DEOTJ09WQECAvLy8FBYWpuPHj5d8pwCAEyptdhiGoejoaL3//vvasmWLAgMD7dZ37NhRNWvWVGpqqrns2LFjyszMVGhoqCQpNDRUBw4c0OnTp82alJQUeXt7q3Xr1mbN9W0U1hS24e7uro4dO9rVFBQUKDU11awpyq3aDQwMlL+/v11NTk6Odu3addN2AcCZccwKAGAV2QEAqEyW7liyf/9+tW/fXi1btpSHh4cMw5CLi0uJTlIAAKonsgMAYBXZAQCwiuwAAFhVVtnx+eef6+9//7vatWtnt3z8+PHauHGj1q1bJx8fH0VHR6tfv3767LPPJElXr15VRESE/P39tWPHDp06dUpDhgxRzZo19Ze//EWSdPLkSUVERGj06NFauXKlUlNTNWLECAUEBCg8PFyStGbNGsXGxioxMVEhISGaM2eOwsPDdezYMfn6+hbZ5x07dmjQoEGKj4/X448/rlWrVikyMlJ79+5VmzZtJEkzZszQW2+9pWXLlikwMFAvv/yywsPDdfjwYXl6elraRwDgLEqbHVFRUVq1apU++OAD1a1bVzabTZLk4+MjLy8v+fj4aPjw4YqNjVX9+vXl7e2tsWPHKjQ0VF27dpUk9erVS61bt9YzzzyjGTNmyGazadKkSYqKijLv/DF69GjNmzdPEydO1HPPPactW7Zo7dq12rhxo9mX2NhYDR06VJ06dVKXLl00Z84cXbhwQcOGDTNrhgwZorvuukvx8fGSpHHjxunhhx/WzJkzFRERodWrV2vPnj1auHChJJmTLF999VW1aNHCzI9GjRopMjKy1PsfABwRx6wAAFaRHQCAymRpYskHH3xQXv0AADgpsgMAYBXZAQCwiuwAAFhVFtmRm5urp59+Wm+//bZeffVVc/n58+f1zjvvaNWqVXr00UclSUuWLFGrVq20c+dOde3aVR9//LEOHz6sTz75RH5+fgoODtb06dP1wgsvaMqUKXJ3d1diYqICAwM1c+ZMSVKrVq20fft2zZ4925xYMmvWLI0cOdL8InBiYqI2btyoxYsX68UXXyyy33PnzlXv3r01YcIESdL06dOVkpKiefPmKTExUYZhaM6cOZo0aZL69u0rSVq+fLn8/PyUlJSkJ598stT7DgAcUWmzY8GCBZKkHj162C1fsmSJnn32WUnS7Nmz5erqqv79+ysvL0/h4eGaP3++Wevm5qYNGzZozJgxCg0NVe3atTV06FBNmzbNrAkMDNTGjRs1fvx4zZ07V40bN9aiRYvM7JCkgQMH6syZM5o8ebJsNpuCg4OVnJwsPz8/syYzM1Ourq7m827dumnVqlWaNGmSXnrpJbVo0UJJSUnmpERJmjhxoi5cuKBRo0YpOztbDz74oJKTk5mUCKDa4pgVAMAqsgMAUJksTSxp1qyZ9u3bp+3bt0uSHnroIQUHB5dHvwAAToLsAABYRXYAAKwiOwAAVpVFdkRFRSkiIkJhYWF2E0syMjJ0+fJlhYWFmcuCgoLUtGlTpaenq2vXrkpPT1fbtm3tvsAbHh6uMWPG6NChQ7r//vuVnp5u10ZhTUxMjCQpPz9fGRkZiouLM9e7uroqLCxM6enpxfY7PT1dsbGxN7SblJQk6dqdUmw2m922fXx8FBISovT09GInluTl5SkvL898npOTU2wfAMARlTY7DMO4ZY2np6cSEhKUkJBw035s2rTppu306NFD+/btu2lNdHS0oqOji12flpZ2w7IBAwZowIABxb7GxcVF06ZNs5voAgDVGcesAABWkR0AgMrkeuuSX/z1r3/ViBEjlJubq9zcXI0cOVKzZs0qr74BAJxAWWbH66+/bt5KvdClS5cUFRWlBg0aqE6dOurfv7+ysrLsXpeZmamIiAjVqlVLvr6+mjBhgq5cuWJXk5aWpg4dOsjDw0PNmzfX0qVLb9h+QkKC7r77bnl6eiokJKREt5lct26dgoKC5OnpqbZt295wsscwDE2ePFkBAQHy8vJSWFiYjh8/XvKdAgBOiHEHAMCq0mbHlClT5OLiYvcICgoy1zPuAADnU9rsWL16tfbu3av4+Pgb1tlsNrm7u6tevXp2y/38/GSz2cya6yeVFK4vXHezmpycHF28eFFnz57V1atXi6wpbKMoxbV7/Xav709J242Pj5ePj4/5aNKkSbG1AOCIOGYFALCK7AAAWEV2AAAqk6U7lixfvlyff/65PDw8JEmxsbHq3LnzDVe2AgCgUFllx+eff66///3vateund3y8ePHa+PGjVq3bp18fHwUHR2tfv366bPPPpMkXb16VREREfL399eOHTt06tQpDRkyRDVr1tRf/vIXSdeuwhgREaHRo0dr5cqVSk1N1YgRIxQQEGDeGn7NmjWKjY1VYmKiQkJCNGfOHIWHh+vYsWPy9fUtss87duzQoEGDFB8fr8cff1yrVq1SZGSk9u7da94afsaMGXrrrbe0bNkyBQYG6uWXX1Z4eLgOHz7MreEBVFuMOwAAVpVFdtx333365JNPzOc1avxy2IxxBwA4n9Jkx7fffqtx48YpJSWFz9HrxMXF2e2/nJwcJpcAcCocswIAWEV2AACsIjsAAJXJ0h1LpGtXaCzqZwAAilPa7MjNzdXTTz+tt99+W3fccYe5/Pz583rnnXc0a9YsPfroo+rYsaOWLFmiHTt2aOfOnZKkjz/+WIcPH9aKFSsUHBysPn36aPr06UpISFB+fr4kKTExUYGBgZo5c6ZatWql6OhoPfHEE5o9e7a5rVmzZmnkyJEaNmyYWrdurcTERNWqVUuLFy8utt9z585V7969NWHCBLVq1UrTp09Xhw4dNG/ePEnXrho8Z84cTZo0SX379lW7du20fPlyff/990pKSrK8nwDAmTDuAABYVdrsqFGjhvz9/c1Hw4YNJTHuAABndrvZkZGRodOnT6tDhw6qUaOGatSooW3btumtt95SjRo15Ofnp/z8fGVnZ9u9LisrS/7+/pIkf3//G+5+Vfj8VjXe3t7y8vJSw4YN5ebmVmRNYRtFKa7d67d7fX9K2q6Hh4e8vb3tHgDgbDhmBQCwiuwAAFhFdgAAKouliSUTJkxQx44dNXr0aP3P//yPOnXqpIkTJ5ZX3wAATqAssiMqKkoREREKCwuzW56RkaHLly/bLQ8KClLTpk2Vnp4uSUpPT1fbtm3l5+dn1oSHhysnJ0eHDh0ya37ddnh4uNlGfn6+MjIy7GpcXV0VFhZm1hTlVu2ePHlSNpvNrsbHx0chISE3bTcvL085OTl2DwBwJow7AABWlUV2HD9+XI0aNdI999yjp59+WpmZmZIYdzDuAOCsSpMdPXv21IEDB7R//37z0alTJz399NPmzzVr1lRqaqr5mmPHjikzM1OhoaGSpNDQUB04cECnT582a1JSUuTt7a3WrVubNde3UVhT2Ia7u7s6duxoV1NQUKDU1FSzpii3ajcwMFD+/v52NTk5Odq1a9dN2wUAZ8cxKwCAVWQHAMAqsgMAUJlqWCl+5pln1LNnT33++eeSpClTpiggIKBcOgYAcA6lzY7Vq1dr79695uuvZ7PZ5O7urnr16tkt9/Pzk81mM2uu/3JX4frCdTerycnJ0cWLF3Xu3DldvXq1yJqjR48W2/fi2r1+u9f3p6iaosTHx2vq1KnFrgcAR8e4AwBgVWmzIyQkREuXLlXLli116tQpTZ06VQ899JAOHjzIuAMAnFRpsqNu3bpq06aN3bLatWurQYMG5vLhw4crNjZW9evXl7e3t8aOHavQ0FB17dpVktSrVy+1bt1azzzzjGbMmCGbzaZJkyYpKipKHh4ekqTRo0dr3rx5mjhxop577jlt2bJFa9eu1caNG83txsbGaujQoerUqZO6dOmiOXPm6MKFCxo2bJhZM2TIEN11112Kj4+XJI0bN04PP/ywZs6cqYiICK1evVp79uzRwoULJUkuLi6KiYnRq6++qhYtWigwMFAvv/yyGjVqpMjIyNvY2wDgHDhmBQCwiuwAAFhFdgAAKlOJ7lhy8uRJSdLhw4eVnZ2tFi1aqEWLFjp37pwOHz5crh0EADi20mTHt99+q3HjxmnlypXy9PQs5546jri4OJ0/f958fPvtt5XdJQAoU4w7AABWlTY7+vTpowEDBqhdu3YKDw/Xpk2blJ2drbVr15Zjr6s2xh0AnF15jztmz56txx9/XP3791f37t3l7++v9evXm+vd3Ny0YcMGubm5KTQ0VIMHD9aQIUM0bdo0syYwMFAbN25USkqK2rdvr5kzZ2rRokUKDw83awYOHKi//vWvmjx5soKDg7V//34lJyfbTSjMzMzUqVOnzOfdunXTqlWrtHDhQrVv317vvfeekpKS7CbLTJw4UWPHjtWoUaPUuXNn5ebmKjk5mWN0AKo1jlkBAKwiOwAAVpU2O6ZMmSIXFxe7R1BQkLn+0qVLioqKUoMGDVSnTh31799fWVlZdm1kZmYqIiJCtWrVkq+vryZMmKArV67Y1aSlpalDhw7y8PBQ8+bNtXTp0hv6kpCQoLvvvluenp4KCQnR7t27b9n/devWKSgoSJ6enmrbtq02bdpkt94wDE2ePFkBAQHy8vJSWFiYjh8/XuL9AwC4uRLdsSQ+Pl4LFy5UVFTUDetcXFy0ZcuWMu8YAMA5lCY7MjIydPr0aXXo0MFcdvXqVX366aeaN2+eNm/erPz8fGVnZ9tdPTgrK0v+/v6SJH9//xsGJoUDoutrfj1IysrKkre3t7y8vOTm5iY3N7ciawrbKEpx7V6/3cJl119dICsrS8HBwcW26+HhYV65EgCcUWnHHVOmTLnhCustW7Y0r/Z+6dIlPf/881q9erXy8vIUHh6u+fPn3/DFqzFjxmjr1q2qU6eOhg4dqvj4eNWo8csQKi0tTbGxsTp06JCaNGmiSZMm6dlnn7XbbkJCgt58803ZbDa1b99ef/vb39SlS5eb9n/dunV6+eWX9c0336hFixZ644039Nhjj5nrDcPQK6+8orffflvZ2dl64IEHtGDBArVo0aJE+wcAnFFZH7OqV6+efvOb3+jEiRP67W9/y7gDAJxQWWdHWlqa3XNPT08lJCQoISGh2Nc0a9bshpPjv9ajRw/t27fvpjXR0dGKjo4ucd8kacCAARowYECxr3FxcdG0adPsJroAQHXHuXIAgFVkh2M5cuSIJKlhw4Zq2rRpJfcGQHVVFtlx33336ZNPPjGfX3+Oe/z48dq4caPWrVsnHx8fRUdHq1+/fvrss88kXfteVkREhPz9/bVjxw6dOnVKQ4YMUc2aNfWXv/xF0rUL1UdERGj06NFauXKlUlNTNWLECAUEBJgXRFmzZo1iY2OVmJiokJAQzZkzR+Hh4Tp27Jh8fX2L7PeOHTs0aNAgxcfH6/HHH9eqVasUGRmpvXv3mhdEmTFjht566y0tW7bMvMtueHi4Dh8+zAVRAKAMlGhiSeHtz9euXas777zTbt2ZM2fKvlcAAKdRmuzo2bOnDhw4YLds2LBhCgoK0gsvvKAmTZqoZs2aSk1NVf/+/SVJx44dU2ZmpkJDQyVJoaGheu2113T69GlzYJKSkiJvb2+1bt3arPn1SfyUlBSzDXd3d3Xs2FGpqamKjIyUJBUUFCg1NfWmJ+1DQ0OVmpqqmJiYItsNDAyUv7+/UlNTzS905eTkaNeuXRozZkyJ9hEAOKOyGHdwsAwAqpeyPmaVm5urr776Ss8884w6duzIuAMAnBDnOwAAVpEdAACryA7HkJubKxcXFw0ePFiS5OXlpaNHjzK5BEClKIvsqFGjRpEXrDp//rzeeecdrVq1So8++qgkacmSJWrVqpV27typrl276uOPP9bhw4f1ySefyM/PT8HBwZo+fbpeeOEFTZkyRe7u7kpMTFRgYKBmzpwpSWrVqpW2b9+u2bNnm+fKZ82apZEjR2rYsGGSpMTERG3cuFGLFy/Wiy++WGS/586dq969e2vChAmSpOnTpyslJUXz5s1TYmKiDMPQnDlzNGnSJPXt21eStHz5cvn5+SkpKUlPPvmkpf0EALiRq5Xi62+vfrNlAAAUKk121K1bV23atLF71K5dWw0aNFCbNm3k4+Oj4cOHKzY2Vlu3blVGRoaGDRum0NBQde3aVZLUq1cvtW7dWs8884y++OILbd68WZMmTVJUVJR59d3Ro0fr66+/1sSJE3X06FHNnz9fa9eu1fjx482+xMbG6u2339ayZct05MgRjRkzRhcuXDAHQJI0ZMgQxcXFmc/HjRun5ORkzZw5U0ePHtWUKVO0Z88e80thLi4uiomJ0auvvqoPP/xQBw4c0JAhQ9SoUSPzi2QAUB2Vxbij8GBZ4aNhw4aSfjlYNmvWLD366KPq2LGjlixZoh07dmjnzp2SZB4sW7FihYKDg9WnTx9Nnz5dCQkJys/PlyS7g2WtWrVSdHS0nnjiCc2ePdvsw/UHy1q3bq3ExETVqlVLixcvLrbf1x8sa9WqlaZPn64OHTpo3rx5knTDwbJ27dpp+fLl+v7775WUlGRpHwGAMyltdvzpT3/Stm3b9M0332jHjh36/e9/Lzc3Nw0aNIhxBwA4Kc53AACsIjsAAFaRHY7h0qVLMgxD/fr1U79+/XTx4kWdPXu2srsFoJoqi+w4fvy4GjVqpHvuuUdPP/20MjMzJUkZGRm6fPmywsLCzNqgoCA1bdpU6enpkqT09HS1bdtWfn5+dtvPycnRoUOHzJrr2yisKWwjPz9fGRkZdjWurq4KCwsza4pyq3ZPnjwpm81mV+Pj46OQkJCbtgsAKLkS3bHkxIkTOnbsmHJycuyurJiTk6O8vLxy6xwAwLFt3ry53LNj9uzZcnV1Vf/+/ZWXl6fw8HDNnz/fXO/m5qYNGzZozJgxCg0NVe3atTV06FBNmzbNrAkMDNTGjRs1fvx4zZ07V40bN9aiRYvsBmYDBw7UmTNnNHnyZNlsNgUHBys5OdluIJWZmSlX11/mbHbr1k2rVq3SpEmT9NJLL6lFixZKSkoyrzgvSRMnTtSFCxc0atQoZWdn68EHH1RycjJXnAdQbZVVdhQeLPP09FRoaKji4+PVtGnTWx4s69q1a7EHy8aMGaNDhw7p/vvvL/agVuHV4gsPll3/xd+SHiyLjY29od3CSSO3OlhW3FVY8vLy7PZhTk5OsX0AAEdTFtnx3XffadCgQfrhhx9055136sEHH9TOnTvNq4Ix7gAA51IRx6wAAM6F7AAAWEV2OJ7Ci5QBQGUpi+wICQnR0qVL1bJlS506dUpTp07VQw89pIMHD8pms8nd3V316tWze42fn59sNpskyWaz2Z2TKFxfuO5mNTk5Obp48aLOnTunq1evFllz9OjRYvteXLvXb/f6/hRVUxTOlQNAyZVoYsmhQ4eUlJSkc+fOad26debyunXr6u233y63zgEAHNsHH3xQ5tmRlpZm99zT01MJCQlKSEgo9jXNmjWzG3QVpUePHtq3b99Na6Kjo82r/pakb5I0YMAADRgwoNjXuLi4aNq0aXZfOAOA6qwssoODZTeKj4/X1KlTi10PAI6sLLJj9erVN13PuAMAnEt5HLMCADg3sgMAYBXZAQCwqiyyo0+fPubP7dq1U0hIiJo1a6a1a9fKy8urTPvrKDhXDgAlV6KJJX379lXfvn21e/dudenSpbz7BABwEvPnz9fRo0fJDgBAiZVFdnCw7EZxcXF2d0LJyclRkyZNKrFHAFB2GHcAAKwiOwAAVpEdAACryA4AgFXlkR316tXTb37zG504cUK//e1vlZ+fr+zsbLsLMWZlZcnf31+S5O/vr927d9u1kZWVZa4r/G/hsutrvL295eXlJTc3N7m5uRVZU9hGUYpr9/rtFi4LCAiwqwkODi62Xc6VA0DJlWhiSaGgoCDFx8fr8OHDdreGWrt2bZl3DADgHMgOAIBVZZ0dHCyTPDw85OHhUex6AHB0jDsAAFaRHQAAq8gOAIBVZAcAwKqyzo7c3Fx99dVXeuaZZ9SxY0fVrFlTqamp6t+/vyTp2LFjyszMVGhoqCQpNDRUr732mk6fPi1fX19JUkpKiry9vdW6dWuz5td3cE9JSTHbcHd3V8eOHZWamqrIyEhJUkFBgVJTU296x/bQ0FClpqYqJiamyHYDAwPl7++v1NRU89x4Tk6Odu3apTFjxhTbLufKAaDkXK0UP/3006pTp4527dqloUOHysXFRc2aNSuvvgEAnADZAQCwqqyzo/BgWUBAgN3BskJFHSw7cOCATp8+bdYUdbDs+jYKa4o6WFao8GBZYU1RbtXu9QfLChUeLLtZuwDg7Bh3AACsIjsAAFaRHQAAq0qbHfHx8ercubPq1q0rX19fRUZG6tixY3Y1ly5dUlRUlBo0aKA6deqof//+N1zAKjMzUxEREapVq5Z8fX01YcIEXblyxa4mLS1NHTp0kIeHh5o3b66lS5fe0J+EhATdfffd8vT0VEhIyA0X6SrKunXrFBQUJE9PT7Vt2/aGLyIbhqHJkycrICBAXl5eCgsL0/Hjx0u4hwDA+ZQ2O/70pz9p27Zt+uabb7Rjxw79/ve/l5ubmwYNGiQfHx8NHz5csbGx2rp1qzIyMjRs2DCFhoaqa9eukqRevXqpdevWeuaZZ/TFF19o8+bNmjRpkqKioszJGaNHj9bXX3+tiRMn6ujRo5o/f77Wrl2r8ePHm/2IjY3V22+/rWXLlunIkSMaM2aMLly4oGHDhpk1Q4YMUVxcnPl83LhxSk5O1syZM3X06FFNmTJFe/bsMSejuLi4KCYmRq+++qo+/PBDHThwQEOGDFGjRo3MCSwAgNKxNLHk+++/19ixY+Xp6amIiAitXr1a27ZtK6++AQCcANkBALCqtNnBwTIAqH4YdwAArCI7AABWkR0AAKtKmx3btm1TVFSUdu7cqZSUFF2+fFm9evXShQsXzJrx48fro48+0rp167Rt2zZ9//336tevn7n+6tWrioiIUH5+vnbs2KFly5Zp6dKlmjx5sllz8uRJRURE6JFHHtH+/fsVExOjESNGaPPmzWbNmjVrFBsbq1deeUV79+5V+/btFR4ebneRrl/bsWOHBg0apOHDh2vfvn2KjIxUZGSkDh48aNbMmDFDb731lhITE7Vr1y7Vrl1b4eHhunTpUon3EwA4k9Jmx3fffadBgwapZcuW+sMf/qAGDRpo586duvPOOyVJs2fP1uOPP67+/fure/fu8vf31/r1683Xu7m5acOGDXJzc1NoaKgGDx6sIUOGaNq0aWZNYGCgNm7cqJSUFLVv314zZ87UokWLFB4ebtYMHDhQf/3rXzV58mQFBwdr//79Sk5Olp+fn1mTmZmpU6dOmc+7deumVatWaeHChWrfvr3ee+89JSUlqU2bNmbNxIkTNXbsWI0aNUqdO3dWbm6ukpOT5enpaW1HAwCKVMNScY1r5X5+fkpNTVWjRo30ww8/lEvHAADOgewAAFhV2uwoPFj2ww8/6M4779SDDz54w8EyV1dX9e/fX3l5eQoPD9f8+fPN1xceLBszZoxCQ0NVu3ZtDR06tMiDZePHj9fcuXPVuHHjIg+WnTlzRpMnT5bNZlNwcHCRB8tcXX+Z7194sGzSpEl66aWX1KJFiyIPll24cEGjRo1Sdna2HnzwQQ6WAaj2GHcAAKwiOwAAVpEdAACrSpsdycnJds+XLl0qX19fZWRkqHv37jp//rzeeecdrVq1So8++qgkacmSJWrVqpV27typrl276uOPP9bhw4f1ySefyM/PT8HBwZo+fbpeeOEFTZkyRe7u7kpMTFRgYKBmzpwpSWrVqpW2b9+u2bNnm+c9Zs2apZEjR5oXz0pMTNTGjRu1ePFivfjii0X2f+7cuerdu7cmTJggSZo+fbpSUlI0b948JSYmyjAMzZkzR5MmTVLfvn0lScuXL5efn5+SkpL05JNPlnhfAYCzKG12rF69+qbrPT09lZCQoISEhGJrmjVrdsMdpn6tR48e2rdv301roqOjzQsoFiUtLe2GZQMGDNCAAQOKfY2Li4umTZtmd+4eAFB2LE0seemll3T+/HnNnDlT//u//6uffvpJs2bNKq++AQCcANkBALCqtNnBwTIAqH4YdwAArCI7AABWkR0AAKvKOjvOnz8vSapfv74kKSMjQ5cvX1ZYWJhZExQUpKZNmyo9PV1du3ZVenq62rZta3fRq/DwcI0ZM0aHDh3S/fffr/T0dLs2CmtiYmIkSfn5+crIyLC7A7urq6vCwsKUnp5ebH/T09MVGxt7Q7tJSUmSrt0pxWaz2W3bx8dHISEhSk9PL3JiSV5envLy8sznOTk5xW4fABwR4w4AQGWyNLGkcHZ4u3btivwCFAAAv0Z2AACsIjsAAFaRHQAAq8gOAIBVZAcAwKqyzI6CggLFxMTogQceMO9ybrPZ5O7urnr16tnV+vn5yWazmTXXTyopXF+47mY1OTk5unjxos6dO6erV68WWXP06NFi+1xcu9dv9/r+FFXza/Hx8Zo6dWqx2wQAR8e4AwBQmSxNLPnqq680b948ffPNN7p69aq5/MMPPyzzjgEAnAPZAQCwiuwAAFhFdgAArCI7AABWkR0AAKvKMjuioqJ08OBBbd++vSy76HDi4uLs7oKSk5OjJk2aVGKPAKBsMe4AAFQmSxNLfv/73ys6Olp/+MMf5OrqWl59AgA4EbIDAGAV2QEAsIrsAABYRXYAAKwiOwAAVpVVdkRHR2vDhg369NNP1bhxY3O5v7+/8vPzlZ2dbXfXkqysLPn7+5s1u3fvtmsvKyvLXFf438Jl19d4e3vLy8tLbm5ucnNzK7KmsI2iFNfu9dstXBYQEGBXExwcXGSbHh4e8vDwKHabAODoGHcAACqTpYkltWrV0qhRo8qrLwAAJ0R2AACsIjsAAFaRHQAAq8gOAIBVZAcAwKrSZodhGBo7dqzef/99paWlKTAw0G59x44dVbNmTaWmpqp///6SpGPHjikzM1OhoaGSpNDQUL322ms6ffq0fH19JUkpKSny9vZW69atzZpNmzbZtZ2SkmK24e7uro4dOyo1NVWRkZGSpIKCAqWmpio6OrrY/oeGhio1NVUxMTFFthsYGCh/f3+lpqaaE0lycnK0a9cujRkz5jb2GAA4PsYdAIDKZGliSVxcnF544QWFhYXZzf7u3r17mXcMAOAcyA4AgFVkBwDAKrIDAGAV2QEAsIrsAABYVdrsiIqK0qpVq/TBBx+obt26stlskiQfHx95eXnJx8dHw4cPV2xsrOrXry9vb2+NHTtWoaGh6tq1qySpV69eat26tZ555hnNmDFDNptNkyZNUlRUlNmn0aNHa968eZo4caKee+45bdmyRWvXrtXGjRvNvsTGxmro0KHq1KmTunTpojlz5ujChQsaNmyYWTNkyBDdddddio+PlySNGzdODz/8sGbOnKmIiAitXr1ae/bs0cKFCyVJLi4uiomJ0auvvqoWLVooMDBQL7/8sho1amROYAGA6oZxBwCgMlmaWLJ582alpaXpxIkT5m22XFxcCC0AQLHIDgCAVWQHAMAqsgMAYBXZAQCwiuwAAFhV2uxYsGCBJKlHjx52y5csWaJnn31WkjR79my5urqqf//+ysvLU3h4uObPn2/Wurm5acOGDRozZoxCQ0NVu3ZtDR06VNOmTTNrAgMDtXHjRo0fP15z585V48aNtWjRIoWHh5s1AwcO1JkzZzR58mTZbDYFBwcrOTlZfn5+Zk1mZqb5PiWpW7duWrVqlSZNmqSXXnpJLVq0UFJSktq0aWPWTJw4URcuXNCoUaOUnZ2tBx98UMnJyfL09CzRPgIAZ8O4AwBQmSxNLPnkk0907Ngxubi4lFd/AABOhuwAAFhFdgAArCI7AABWkR0AAKvIDgCAVaXNDsMwblnj6emphIQEJSQkFFvTrFkzbdq06abt9OjRQ/v27btpTXR0tKKjo4tdn5aWdsOyAQMGaMCAAcW+xsXFRdOmTbOb6AIA1RnjDgBAZXK9dckvunTpoq+++qq8+gIAcEJkBwDAKrIDAGAV2QEAsIrsAABYRXY4riNHjigzM7OyuwGgGiI7AABWkR0AgMpk6Y4lBw8eVJs2bdSyZUt5eHjIMAy5uLho9+7d5dU/AICDIzsAAFaRHQAAq8gOAIBVZAcAwCqyw/Hk5ubKxcVFgwcPlpeXl44ePaqmTZtWdrcAVCNkBwDAKrIDAFCZLE0s+eCDD0q1sfj4eK1fv15Hjx6Vl5eXunXrpjfeeEMtW7Y0ay5duqTnn39eq1evVl5ensLDwzV//nz5+fmZNZmZmRozZoy2bt2qOnXqaOjQoYqPj1eNGr+8nbS0NMXGxurQoUNq0qSJJk2apGeffdauPwkJCXrzzTdls9nUvn17/e1vf1OXLl1u+h7WrVunl19+Wd98841atGihN954Q4899pi53jAMvfLKK3r77beVnZ2tBx54QAsWLFCLFi1Kte8AwFGVNjsAANUP2QEAsIrsAABYRXYAAKwiOxzPpUuXZBiGunfvrk8//VRnz55lYgmACkV2AACsIjsAAJWpRBNL8vLy5OHhoTvvvLNUG9u2bZuioqLUuXNnXblyRS+99JJ69eqlw4cPq3bt2pKk8ePHa+PGjVq3bp18fHwUHR2tfv366bPPPpMkXb16VREREfL399eOHTt06tQpDRkyRDVr1tRf/vIXSdLJkycVERGh0aNHa+XKlUpNTdWIESMUEBCg8PBwSdKaNWsUGxurxMREhYSEaM6cOQoPD9exY8fk6+tbZP937NihQYMGKT4+Xo8//rhWrVqlyMhI7d27V23atJEkzZgxQ2+99ZaWLVumwMBAvfzyywoPD9fhw4fl6elZqv0HAI6otNkBAKh+yA4AgFVkBwDAKrIDAGAV2eG4fHx8KrsLAKopsgMAYBXZAQCoTCWaWNK/f39t2LBB9913n1xcXMzbaxX+9+uvvy7RxpKTk+2eL126VL6+vsrIyFD37t11/vx5vfPOO1q1apUeffRRSdKSJUvUqlUr7dy5U127dtXHH3+sw4cP65NPPpGfn5+Cg4M1ffp0vfDCC5oyZYrc3d2VmJiowMBAzZw5U5LUqlUrbd++XbNnzzYnlsyaNUsjR47UsGHDJEmJiYnauHGjFi9erBdffLHI/s+dO1e9e/fWhAkTJEnTp09XSkqK5s2bp8TERBmGoTlz5mjSpEnq27evJGn58uXy8/NTUlKSnnzyyRLtJwBwJqXNDgBA9UN2AACsIjsAAFaRHQAAq8gOAIBVZAcAwCqyAwBQmUo0sWTDhg2Srt0JpCydP39eklS/fn1JUkZGhi5fvqywsDCzJigoSE2bNlV6erq6du2q9PR0tW3bVn5+fmZNeHi4xowZo0OHDun+++9Xenq6XRuFNTExMZKk/Px8ZWRkKC4uzlzv6uqqsLAwpaenF9vf9PR0xcbG3tBuUlKSpGv7x2az2W3bx8dHISEhSk9PL3JiSV5envLy8sznOTk5xW4fABxRWWcHAMD5kR0AAKvIDgCAVWQHAMAqsgMAYBXZAQCwiuwAAFQmVyvFXbp0KdGykigoKFBMTIweeOABtWnTRpJks9nk7u6uevXq2dX6+fnJZrOZNddPKilcX7juZjU5OTm6ePGizp49q6tXrxZZU9hGUYpr9/rtXt+fkrQbHx8vHx8f89GkSZNitw8AjqgsswMAUD2QHQAAq8gOAIBVZAcAwCqyAwBgFdkBALCK7AAAVKYS3bHk7NmzysrKUm5uro4cOSLDMCRdu7vG7d5hIyoqSgcPHtT27dtv6/XOIi4uzu4uKDk5OUwuAeA0jhw5UqbZAQBwfmQHAMAqsgMAYBXZAQCwiuwAAFhFdgAArCI7AACVrUQTSzZu3KilS5fq22+/VVRUlBladevW1V/+8hfLG42OjtaGDRv06aefqnHjxuZyf39/5efnKzs72+6uJVlZWfL39zdrdu/ebddeVlaWua7wv4XLrq/x9vaWl5eX3Nzc5ObmVmRNYRtFKa7d67dbuCwgIMCuJjg4uMg2PTw85OHhUew2AcCRTZgwocyyAwBQPZAdAACryA4AgFVkBwDAKrIDAGAV2QEAsIrsAABUthJNLBk6dKiGDh2qpKQkRUZG3vbGDMPQ2LFj9f777ystLU2BgYF26zt27KiaNWsqNTVV/fv3lyQdO3ZMmZmZCg0NlSSFhobqtdde0+nTp+Xr6ytJSklJkbe3t1q3bm3WbNq0ya7tlJQUsw13d3d17NhRqamp5vspKChQamqqoqOji+1/aGioUlNTFRMTU2S7gYGB8vf3V2pqqjmRJCcnR7t27dKYMWNuY48BgGPbsGGDtmzZUqrsAABUL2QHAMAqsgMAYBXZAQCwiuwAAFhFdgAArCI7AACVzdVK8eHDh/XTTz/p6tWrGjBggH7zm98oKSmpxK+PiorSihUrtGrVKtWtW1c2m002m00XL16UJPn4+Gj48OGKjY3V1q1blZGRoWHDhik0NFRdu3aVJPXq1UutW7fWM888oy+++EKbN2/WpEmTFBUVZd75Y/To0fr66681ceJEHT16VPPnz9fatWs1fvx4sy+xsbF6++23tWzZMh05ckRjxozRhQsXNGzYMLNmyJAhiouLM5+PGzdOycnJmjlzpo4ePaopU6Zoz5495mQUFxcXxcTE6NVXX9WHH36oAwcOaMiQIWrUqBFhD6DaKm12AACqH7IDAGAV2QEAsIrsAABYVdrs+PTTT/W73/1OjRo1kouLyw2vNQxDkydPVkBAgLy8vBQWFqbjx4/b1fz44496+umn5e3trXr16mn48OHKzc21q/nyyy/10EMPydPTU02aNNGMGTNu6Mu6desUFBQkT09PtW3b9oaLNhYlLS1NHTp0kIeHh5o3b66lS5feUJOQkKC7775bnp6eCgkJ0e7du2+9YwDAiTHuAABYRXYAACqTpYkl69atU926dbVhwwZ5enpq+/btmjp1aolfv2DBAp0/f149evRQQECA+VizZo1ZM3v2bD3++OPq37+/unfvLn9/f61fv95c7+bmpg0bNsjNzU2hoaEaPHiwhgwZomnTppk1gYGB2rhxo1JSUtS+fXvNnDlTixYtUnh4uFkzcOBA/fWvf9XkyZMVHBys/fv3Kzk5WX5+fmZNZmamTp06ZT7v1q2bVq1apYULF6p9+/Z67733lJSUpDZt2pg1EydO1NixYzVq1Ch17txZubm5Sk5OlqenZ8l3NAA4kdJmBwCg+iE7AABWkR0AAKvIDgCAVaXNjgsXLqh9+/ZKSEgocv2MGTP01ltvKTExUbt27VLt2rUVHh6uS5cumTVPP/20Dh06pJSUFG3YsEGffvqpRo0aZa7PyclRr1691KxZM2VkZOjNN9/UlClTtHDhQrNmx44dGjRokIYPH659+/YpMjJSkZGROnjwYLF9P3nypCIiIvTII49o//79iomJ0YgRI7R582azZs2aNYqNjdUrr7yivXv3qn379goPD9fp06dLvI8AwNkw7gAAWEV2AAAqUw0rxYV3Fvnggw/05JNPytfXV4ZhlPj1Jan19PRUQkJCsQfUJKlZs2a3vGpKjx49tG/fvpvWREdHm3cbKUpaWtoNywYMGKABAwYU+xoXFxdNmzbNbqILAFRnpc0OAED1Q3YAAKwiOwAAVpEdAACrSpsdffr0UZ8+fYpcZxiG5syZo0mTJqlv376SpOXLl8vPz09JSUl68skndeTIESUnJ+vzzz9Xp06dJEl/+9vf9Nhjj+mvf/2rGjVqpJUrVyo/P1+LFy+Wu7u77rvvPu3fv1+zZs0yJ6DMnTtXvXv31oQJEyRJ06dPV0pKiubNm6fExMQi+5eYmKjAwEDNnDlTktSqVStt375ds2fPNi/uOGvWLI0cOVLDhg0zX7Nx40YtXrxYL774Yon3EwA4E8YdAACryA4AQGWydMeS3/3ud+bVTXr16qUzZ87Iw8OjvPoGAHACZAcAwCqyAwBgFdkBALCqtNkRHx+vzp07q27duvL19VVkZKSOHTtmV3Pp0iVFRUWpQYMGqlOnjvr376+srCy7mszMTEVERKhWrVry9fXVhAkTdOXKFbuatLQ0dejQQR4eHmrevLmWLl16Q38SEhJ09913y9PTUyEhIdq9e/ct38O6desUFBQkT09PtW3b9oYLehmGocmTJysgIEBeXl4KCwvT8ePHS7iHAMD5lOe44+TJk7LZbAoLCzOX+fj4KCQkROnp6ZKk9PR01atXz5xUIklhYWFydXXVrl27zJru3bvL3d3drAkPD9exY8d07tw5s+b67RTWFG6nKLd6TX5+vjIyMuxqXF1dFRYWdtN28/LylJOTY/cAAGfCMSsAgFVkBwCgMlmaWPLmm29q37592rt3r2rWrKlatWrpgw8+KK++AQCcANkBALCK7AAAWEV2AACsKm12bNu2TVFRUdq5c6dSUlJ0+fJl9erVSxcuXDBrxo8fr48++kjr1q3Ttm3b9P3336tfv37m+qtXryoiIkL5+fnasWOHli1bpqVLl2ry5MlmzcmTJxUREaFHHnlE+/fvV0xMjEaMGKHNmzebNWvWrFFsbKxeeeUV7d27V+3bt1d4eLhOnz5dbP937NihQYMGafjw4dq3b58iIyMVGRmpgwcPmjUzZszQW2+9pcTERO3atUu1a9dWeHi4Ll26VOL9BADOpDzHHTabTZLk5+dnt9zPz89cZ7PZ5Ovra7e+Ro0aql+/vl1NUW1cv43iagrXF9e/ol6Tk5Ojixcv6uzZs7p69arlduPj4+Xj42M+mjRpUmwtADgijlkBAKwiOwAAlcnSxJLs7Gy9/vrreuaZZyRJ3333nf71r3+VS8cAAM6htNnB1R8BoPph3AEAsKoixh09evSQi4uL3WP06NF2NYw7AMBxlDY7kpOT9eyzz+q+++5T+/bttXTpUmVmZiojI0OSdP78eb3zzjuaNWuWHn30UXXs2FFLlizRjh07tHPnTknSxx9/rMOHD2vFihUKDg5Wnz59NH36dCUkJCg/P1+SlJiYqMDAQM2cOVOtWrVSdHS0nnjiCc2ePdvsy6xZszRy5EgNGzZMrVu3VmJiomrVqqXFixcX2/+5c+eqd+/emjBhglq1aqXp06erQ4cOmjdvnqRruTFnzhxNmjRJffv2Vbt27bR8+XJ9//33SkpKsrSvAcBZcMyq7MXFxen8+fPm49tvv63sLgFAmSI7AABWkR0AgMpkaWLJ0KFD1apVK/OKVYGBgZo+fXq5dAwA4BxKmx1c/REAqh/GHQAAqypi3CFJI0eO1KlTp8zHjBkzzHWMOwDAsZT1uOP8+fOSpPr160uSMjIydPnyZYWFhZk1QUFBatq0qdLT0yVJ6enpatu2rd3V3cPDw5WTk6NDhw6ZNde3UVhT2EZ+fr4yMjLsalxdXRUWFmbWFOVW7Z48eVI2m82uxsfHRyEhITdtFwCcWXkes/L395ekGy6alZWVZa7z9/e/YVxw5coV/fjjj3Y1RbVx/TaKqylcX1z/inqNt7e3vLy81LBhQ7m5uVlu18PDQ97e3nYPAHAmnO8AAFhFdgAAKpOliSXff/+9hg0bJjc3N0mSu7u7XF0tNQEAqGZKmx1c/REAqh/GHQAAq8p73FGoVq1a8vf3Nx/Xf+mJcQcAOJayHHcUFBQoJiZGDzzwgNq0aSNJstlscnd3V7169exq/fz8ZLPZzJrrJ5UUri9cd7OanJwcXbx4UWfPntXVq1eLrClsoyjFtXv9dq/vT0nazcvLU05Ojt0DAJxJeR6zCgwMlL+/v1JTU81lOTk52rVrl0JDQyVJoaGhys7OthunbNmyRQUFBQoJCTFrPv30U12+fNmsSUlJUcuWLXXHHXeYNddvp7CmcDtFudVr3N3d1bFjR7uagoICpaam3rRdAHB2nO8AAFhFdgAAKpOlxKldu7ays7Pl4uIiSdq7d6/q1q1bLh0DADiHss4Orv7ISXoAzq+02REfH6/OnTurbt268vX1VWRkpI4dO2ZX06NHD7m4uNg9Ro8ebVeTmZmpiIgI1apVS76+vpowYYKuXLliV5OWlqYOHTrIw8NDzZs319KlS2/oT0JCgu6++255enoqJCREu3fvvuV7WLdunYKCguTp6am2bdtq06ZNdusNw9DkyZMVEBAgLy8vhYWF6fjx4yXcQwDgfMp73FFo5cqVatiwodq0aaO4uDj9/PPP5jpnG3cAgLMry+yIiorSwYMHtXr16rLsosOJj4+Xj4+P+WjSpElldwkAylRpsyM3N1f79+/X/v37JV37O33//v3KzMyUi4uLYmJi9Oqrr+rDDz/UgQMHNGTIEDVq1EiRkZGSpFatWql3794aOXKkdu/erc8++0zR0dF68skn1ahRI0nSU089JXd3dw0fPlyHDh3SmjVrNHfuXMXGxpr9GDdunJKTkzVz5kwdPXpUU6ZM0Z49exQdHW3WxMXFaciQIebz0aNH6+uvv9bEiRN19OhRzZ8/X2vXrtX48ePNmtjYWL399ttatmyZjhw5ojFjxujChQsaNmyY5X0NAM6C71kBAKziXDnnygGgMlmaWDJz5kxFRkbq5MmT6tmzp5588km99dZb5dU3AIATKMvs4OqP13CSHoCzK212bNu2TVFRUdq5c6dSUlJ0+fJl9erVSxcuXLCrGzlypE6dOmU+ZsyYYa67evWqIiIilJ+frx07dmjZsmVaunSpJk+ebNacPHlSEREReuSRR7R//37FxMRoxIgR2rx5s1mzZs0axcbG6pVXXtHevXvVvn17hYeH6/Tp08X2f8eOHRo0aJCGDx+uffv2KTIyUpGRkebtjiVpxowZeuutt5SYmKhdu3apdu3aCg8P16VLl0q8nwDAmZT3uEO69gWtFStWaOvWrYqLi9O7776rwYMHm+udbdzBhHYAzq6ssiM6OlobNmzQ1q1b1bhxY3O5v7+/8vPzlZ2dbVeflZUlf39/syYrK+uG9YXrblbj7e0tLy8vNWzYUG5ubkXWFLZRlOLavX671/enJO3GxcXp/Pnz5uPbb78tdvsA4IhKmx179uzR/fffr/vvv1/StYkY999/v3m8aeLEiRo7dqxGjRqlzp07Kzc3V8nJyfL09DTbWLlypYKCgtSzZ0899thjevDBB7Vw4UJzvY+Pjz7++GOdPHlSHTt21PPPP6/Jkydr1KhRZk23bt20atUqLVy4UO3bt9d7772npKQku/HPqVOnlJmZaT4PDAzUxo0blZKSovbt22vmzJlatGiRwsPDzZqBAwfqr3/9qyZPnqzg4GDt379fycnJN4xDAKA64XtWAACrOFfOuXIAqEw1rBR37NhRn3zyiY4dO6aCggIFBQWpZs2a5dU3AIATKMvsKLz64/bt28u4l44lLi7O7upiOTk5TC4B4FRKmx3Jycl2z5cuXSpfX19lZGSoe/fu5vJatWoV+4Wojz/+WIcPH9Ynn3wiPz8/BQcHa/r06XrhhRc0ZcoUubu7KzExUYGBgZo5c6aka1eN3L59u2bPnm2eVJ81a5ZGjhxpXpkxMTFRGzdu1OLFi/Xiiy8Wue25c+eqd+/emjBhgiRp+vTpSklJ0bx585SYmCjDMDRnzhxNmjRJffv2lSQtX75cfn5+SkpK0pNPPlnifQUAzqIixh3XfxGrbdu2CggIUM+ePfXVV1/p3nvvLVX/q6L4+HhNnTq1srsBAOWmtNlhGIbGjh2r999/X2lpaQoMDLyh/Zo1ayo1NVX9+/eXJB07dkyZmZkKDQ2VJIWGhuq1117T6dOn5evrK0lKSUmRt7e3Wrdubdb8+qqMKSkpZhvu7u7q2LGjUlNTzSvaFxQUKDU11e7K878WGhqq1NRUxcTEFNluYGCg/P39lZqaquDgYEnXjkHt2rVLY8aMKbJNDw8PeXh43GrXAYDDKm129OjRQ4ZhFLvexcVF06ZN07Rp04qtqV+/vlatWnXT7bRr107/+te/blozYMAADRgwoNj1RV1puEePHtq3b99N242Ojr5p/gBAdcP3rAAAVnGunHPlAFCZLN2xRJJq1Kih++67T23btmWwAwAokbLIDq7++AsPDw95e3vbPQDA2ZTluOP8+fOSrp14v97KlSvVsGFDtWnTRnFxcfr555/Ndenp6Wrbtq3dFRXDw8OVk5OjQ4cOmTVhYWF2bYaHhys9PV2SlJ+fr4yMDLsaV1dXhYWFmTVFuVW7J0+elM1ms6vx8fFRSEjITdsFAGdXnuOOooSEhEiSTpw4Icn5xh1cdR5AdVCa7IiKitKKFSu0atUq1a1bVzabTTabTRcvXpR07W/04cOHKzY2Vlu3blVGRoaGDRum0NBQde3aVZLUq1cvtW7dWs8884y++OILbd68WZMmTVJUVJQ5QWP06NH6+uuvNXHiRB09elTz58/X2rVrNX78eLMvsbGxevvtt7Vs2TIdOXJEY8aM0YULF8yT9pI0ZMgQxcXFmc/HjRun5ORkzZw5U0ePHtWUKVO0Z88e88vALi4uiomJ0auvvqoPP/xQBw4c0JAhQ9SoUSNzAgsAVEecKwcAWEV2AACs4lx52Z4r5w7tAFBylieWwHEcOXJEe/futbtNMQA4GsMwFB0drffff19btmy56dUfCxV19ccDBw7Y3UqxqKs/Xt9GYU1RV38sVHj1x8Kaotyq3euv/lio8OqPN2sXAFAyBQUFiomJ0QMPPKA2bdqYy5966imtWLFCW7duVVxcnN59910NHjzYXG+z2ewOlEkyn9tstpvW5OTk6OLFizp79qyuXr1aZE1hG0Uprt3rt3t9f0rSLgfLAODmbjXuKMr+/fslSQEBAZKcb9zBhHYAuLkFCxbo/Pnz6tGjhwICAszHmjVrzJrZs2fr8ccfV//+/dW9e3f5+/tr/fr15no3Nzdt2LBBbm5uCg0N1eDBgzVkyBC7K9UHBgZq48aNSklJUfv27TVz5kwtWrTIvPKjJA0cOFB//etfNXnyZAUHB2v//v1KTk62GzNkZmbq1KlT5vNu3bpp1apVWrhwodq3b6/33ntPSUlJduOmiRMnauzYsRo1apQ6d+6s3NxcJScny9PTs8z3JwAAAAAAAMoW58qviY+Pl4+Pj/lo0qRJsdsHgOquRmV3AGUvNzdXLi4uZth7eXnp6NGjatq0aSX3DACsi4qK0qpVq/TBBx+YV3+Urs029/Lysrv6Y/369eXt7a2xY8cWe/XHGTNmyGazFXn1x3nz5mnixIl67rnntGXLFq1du1YbN240+xIbG6uhQ4eqU6dO6tKli+bMmVPk1R/vuusuxcfHS7p29ceHH35YM2fOVEREhFavXq09e/Zo4cKFkuyv/tiiRQsFBgbq5Zdf5uqPAFBGoqKidPDgQW3fvt1u+ahRo8yf27Ztq4CAAPXs2VNfffWV7r333oruZrmLj4/X1KlTK7sbAFBl3Wrc8dVXX2nVqlV67LHH1KBBA3355ZcaP368unfvrnbt2kli3AEA1Y1hGLes8fT0VEJCghISEoqtadasmTZt2nTTdnr06KF9+/bdtCY6Otq820hR0tLSblg2YMAADRgwoNjXuLi4aNq0aXYTXQAAAAAAAOAYOFd+TVxcnGJjY83nOTk5TC4BgGKU6I4lc+fONX/eu3dvuXUGZePSpUsyDEP9+vVTv379zBmgAFBZSpMdXP0RAKqnshh3REdHa8OGDdq6dasaN25809qQkBBJ0okTJyRJ/v7+ysrKsqspfO7v73/TGm9vb3l5ealhw4Zyc3MrsqawjaIU1+71272+PyVpNy4uTufPnzcf3377bbHbBwBHVZ7jDnd3d33yySfq1auXgoKC9Pzzz6t///766KOPzDYYdwCA4+F8h+PgDu0AqgqyAwBgFdkBALCKc+Vle66cO7QDQMmV6I4ly5Yt07hx4yRJI0aMYNDjIBo2bFjZXQAASaXLDq7+CADVU2mzY+zYsXr//feVlpamwMDAW75m//79kqSAgABJUmhoqF577TWdPn1avr6+kqSUlBR5e3urdevWZs2vsyUlJUWhoaGSrn0JuWPHjkpNTTWvBl9QUKDU1NSbZkloaKhSU1MVExNTZLuBgYHy9/dXamqqgoODJV27qsquXbs0ZsyYItv08PAwr5YPAM6qPMcdTZo00bZt227ZDuMOAHAsnO+o+rhDO4CqhuwAAFhFdgAArOJcedmeKwcAlFyJJpYAAAAAgKOIiorSqlWr9MEHH6hu3bqy2WySJB8fH3l5eemrr77SqlWr9Nhjj6lBgwb68ssvNX78eHXv3l3t2rWTJPXq1UutW7fWM888oxkzZshms2nSpEmKiooyJ2iMHj1a8+bN08SJE/Xcc89py5YtWrt2rTZu3Gj2JTY2VkOHDlWnTp3UpUsXzZkzRxcuXNCwYcPMmiFDhuiuu+5SfHy8JGncuHF6+OGHNXPmTEVERGj16tXas2ePFi5cKOnaF4NjYmL06quvqkWLFgoMDNTLL7+sRo0amQflAAAAAMAZXH+Hdklav369zp49y8QSAAAAAACAInCuHABQGiWaWHLmzBnNnz9fhmGYP1/vj3/8Y7l0DgDg2N5++215enqSHQCAEiuL7FiwYIGka1eEv96SJUv07LPPyt3dXZ988ol54KpJkybq37+/Jk2aZNa6ublpw4YNGjNmjEJDQ1W7dm0NHTrU7irvgYGB2rhxo8aPH6+5c+eqcePGWrRokcLDw82agQMH6syZM5o8ebJsNpuCg4OVnJwsPz8/syYzM1Ourq7m827dumnVqlWaNGmSXnrpJbVo0UJJSUlq06aNWTNx4kRduHBBo0aNUnZ2th588EElJyfL09OzRPsIAJwJ4w4AgFVkh+PhDu0AKhvZAQCwiuxwbEeOHFHDhg2Z1A6gQnGunHPlAFDZSjSxZMSIETpz5swNPwMAcDM//PCDPDw8yA4AQImVRXYYhnHT9U2aNNG2bdtu2U6zZs1uuH3vr/Xo0UP79u27aU10dPRNb+eblpZ2w7IBAwZowIABxb7GxcVF06ZNszt4BwDVFeMOAIBVZAcAwCqyAwBgFdnhmHJzc+Xi4qLBgwfLy8tLR48eZXIJgArDufJrOFcOAJWnRBNLXnnllfLuBwDACb344ovy9vau7G4AABwI2QEAsIrsAABYRXYAAKwiOwAAVpEdjunSpUsyDEPdu3fXp59+qrNnzzKxBECFITsAAJWtRBNLbjWzb/LkyWXSGQCAc3njjTfk4eFR5DqyAwBQFLIDAGAV2QEAsIrsAABYRXYAAKwiOxybj49PZXcBQDVEdgAAKptrSYqmTZum9evXS5IaNmyoBg0a2D0AACjKRx99JInsAACUHNkBALCK7AAAWEV2AACsIjsAAFaRHQAAq8gOAEBlK9EdS7777ju99957ev/99+Xu7q4BAwbo97//ve64447y7h8AwIENGTJE//znP8kOAECJkR0AAKvIDgCAVWQHAMAqsgMAYBXZAQCwiuwAAFS2Et2xxN/fX9HR0UpNTdXixYt1/vx5tWrVSsuWLSvv/gEAHNioUaPIDgdz5MgR7d27V5mZmZXdFQDVFNkBALCK7AAAWEV2AACsIjucS2Zmpvbu3cv5EADliuwAAFhFdgAAKluJ7lgiSYZhaNu2bVqzZo12796tQYMG6YEHHijPvgEAHJxhGEpLSyM7HEBubq5cXFw0ePBgSZKXl5eOHj2qpk2bVnLPAFQ3ZAcAwCqyAwBgFdkBALCK7HAOR44c0alTp/TEE0/o0qVLkjgfAqD8kB0AAKvIDgBAZSvRxJLo6Gjt3LlTDz30kIYMGaIFCxaUd78AAE6gR48e6tGjB9nhAC5duiTDMNSvXz9J0vr163X27FlOpACocGQHAMAqsgMAYBXZAQCwiuxwbD///LPdxbUkcT4EQLkjOwAAVpEdAIDKVqKJJfPnz1f9+vX1n//8RytWrJCLi4ukazMkXVxcdPr06XLtJADAMWVmZmrFihVkhwNp2LBhZXcBQDVHdgAArCI7AABWkR0AAKvIDseWn59vXlzr3Llz2rp1K+dDAJQ7sgMAYBXZAQCobCWaWFJQUFDe/QAAOKGTJ0/K29u7srsBAHAgZAcAwCqyAwBgFdkBALCK7HAOTCYBUJHIDgCAVWQHAKCylWhiyaVLl5SYmKgTJ06oXbt2eu6551SjRoleCgCoxubPn6/vvvuO7AAAlBjZAQCwiuwAAFhFdgAArCI7AABWkR0AAKvIDgBAZXMtSdHQoUO1Z88etW3bVps2bdKf/vSn8u4XAMAJ7Nu3j+wAAFhCdgAArCI7AABWkR0AAKvIDgCAVWQHAMAqsgMAUNlKNKXx8OHDOnDggCRp+PDh6tKlS7l2CgDgHN5++215e3uTHQCAEiM7AABWkR0AAKvIDgCAVWQHAMAqssM5HDlyRJLUsGFDNW3atJJ7A8DZkR0AgMpWooklNWvW/OUF3F4LAGAR2QEAsIrsAABYRXYAAKwiOwAAVpEdAACryA7H9PPPP8vFxUWDBw+WJHl5eeno0aNMLgFQIcgOAEBlKVECffnll/L19ZUkGYah7Oxs+fr6yjAMubi46PTp0+XaSQCAY7r33nvl4uJCdgAASozsAABYRXYAAKwiOwAAVpEdAACryA7Hlp+fL8Mw1K9fP0nS+vXrdfbsWSaWAChXZAcAoLKVaGLJlStXyrsfKGdHjhzhtowAKtxXX30lb2/vyu4GAMCBkB0AAKvIDgCAVWQHAMAqsgMAYBXZ4RwaNmxY2V0AUI2QHQCAysY9s5xcbm6ueWtGbssIAAAAAAAAAAAAAMAvjhw5IklcqBEAAAAAAFRrrpXdAZSvS5cuyTAMde/e/f9j787jo6oO//+/J4EsLAlCJAkKISiyyCaxhLggSmpQbKFQVFxA1sInWCAKGL8ICLaxKJtlSV0AKVKEFlHBQkNYXAgggSh7AdFgISxqCCCE7f7+4JdrBhKSm2Qyc2dez8fjPkjuPXPnnENm3vfcO2euzp49qxMnTri7SgAAAAAAAAAAAAAAuFXhL2mMiYlR06ZNlZ2d7e5qAQAAAAAAuAUTS3xEaGiou6sAAAAAAAAAAAAAAIBHKPiSxu7du6t79+58USMAAAAAAPBpVdxdAQAAAAAAAAC+Y/fu3ZKksLAwNWjQwM21AQAAAODrwsLC3F0FAAAAAAAAt2NiCQAAKNLu3bv5oBcAAACACnP69Gk5HA499dRTkqTg4GDt2bOHMQcAAAAAAAAAAAAAuBkTSwAAgJPCH/big14AAAAAKsq5c+dkGIa6d+8uSVq6dKlOnDjBeAMAAACAx+AOiwCA4pARAAAA8HZMLAEAAE4KPuzVoUMHffrpp3zQCwAAAECFCgsLc3cVAAA2xl12AQCuwB0WAQDFISMAAADgK/zcXQFUrt27d2vr1q3Kzs52d1UAAB4uNDTU3VUAAAAAAAAAJDl/mKtp06Zc5wAAVKjCd1js3r27zp49qxMnTri7WgAAD0BGAAAAwFcwscRH/Pzzz+YFl5iYGC66AAAAAAAAAAAA2yh8l10+yAUAcJWwsDDusggAKBIZAQAAAG9Xxd0VQOU4f/68OXtekpYuXaoTJ05wW0YAQIl2794t6cqJMnIDAAAAAAAA7sRddgEAAAAAAAAAqHhMLPExhWfO80FhAMD1FL7blSQFBwdrz549ZAYAAAAAAAAAAPB6u3fv5lo6AKBIfOYKACCRBwC8j5+7K+BuM2fOVMOGDRUUFKTY2Fht3rz5uuWXLFmipk2bKigoSC1bttQnn3zitN0wDI0dO1aRkZEKDg5WfHy89u3b58omWHb69Gnzg8IxMTG67bbbtGLFCm3dulUZGRnaunWr089Frdu6dauys7Pd3RQAcAtfyY7Cd7vq3r27zp49qxMnTri7WgBgS96cHbt372Z8AAAu4M3ZUdju3bvJEACoIL6SHQUYiwBA+fladpRW4evpha+lkzkAQHZc/Zmrpk2bkg8AUAJvzA7yAIC38umJJe+//76SkpI0btw4bd26Va1bt1ZCQoKOHTtWZPkNGzaoV69e6t+/v7Zt26Zu3bqpW7du2rFjh1lm0qRJeuONN5SamqpNmzapevXqSkhI0Llz5yqrWSU6d+6c+UHhzp076/z583rkkUcUExOju+++WzExMU4/F7WuuAkpTEIB4O18MTvCwsLMO15xwR4ArPPW7OBkGQC4jrdmR2GFc4QMAYDy84XsKFD4LruMRQCg7HwpO6wquJ7erl07p2vpTDIB4OvIDufPXBV8OeNnn31GNgBAMbw1O4rKA76sF4A3qOLuCrjTlClTNHDgQPXt21eSlJqaqhUrVmjOnDl64YUXrik/ffp0de7cWSNHjpQkTZw4UWlpaZoxY4ZSU1NlGIamTZumMWPGqGvXrpKk+fPnKzw8XMuWLdPjjz9eeY0rhbCwMJ04ccIMuJ9++klr1651+vmOO+7Qtm3brtn+888/a9WqVXrkkUckSQ6HQ4ZhmP8WXidJgYGB+te//qXIyEjl5+crMDBQksyfi1pXmp9LU7bwbcays7N14sQJbj0GoMx8NTsKf+hLKv59nfdXALiWt2ZH4ZNlkrR06VJ99tlnatSoUYnH5QCA6/PW7CisIEc6dOigTz/9VJ999pmaNWtGdgBAGflCdhQofJdd6ZexyNU5UtI1BXIGgK/zpewoq8DAQDNzrr4+XtL176KuUUvkDwB7Izt+ERYWVuw19Nq1a1v6LBMAeDNvz46CL+qVrnxZL+/vAOzOZyeWnD9/XpmZmUpOTjbX+fn5KT4+XhkZGUU+JiMjQ0lJSU7rEhIStGzZMknSwYMHlZOTo/j4eHN7aGioYmNjlZGRUWRo5efnKz8/3/z95MmTkqS8vDxL7Tl9+rQk6ciRI8rNzb3m54L9Frf9woULunjx4jU/X7p0qcjtZ86ckWEYuuuuu3T69Gl9/fXXatSokb755hundXfddZfy8/OVmZlpnmSrbIGBgfr73/8uSXr66afNgdrf//53hYeHy8/PT5cvX5akIn8uabsdH+fJdaMvPK9NERERioiIkBUF72EFk8u8ha9nR8H7/vXe1wveXyMjIz3qdVHZj/PkutEXtInsqFy+kB0XLlzQ2bNnJcm8eFKUko7BPe11UdmP8+S60Re0ieyoXL6QHYV/PnPmjKSiM4TssMfr1xMe58l1o02u6wuy4xe+lh0F+y3tWKQ4rrpO4MmvJ9pkj7rRJrKjMvhqdhS3vTSZU/j6eGmufxd1jbrw+sL548mvp7I+zpPrRpvoC7KjbMiOon+2kg2FlTcPPPn1VNbHeXLd6AvaRHaUja9kR+HzU1bONxX+mdchbaIv7FW3im6TR2WH4aP+97//GZKMDRs2OK0fOXKk0a5duyIfU7VqVWPhwoVO62bOnGnUrVvXMAzD+OKLLwxJxuHDh53K9OzZ03j00UeL3Oe4ceMMSSwsLCxeuRw6dKisb9MeiexgYWFhcf1CdpAdLCwsLFYXsoPsYGFhYbG6kB1kBwsLC4vVhewgO1hYWFisLmQH2cHCwsJidSE7yA4WFhYWq0tFZ4fP3rHEUyQnJzvNsLx8+bJ+/PFH1alTRw6Ho9T7ycvLU/369XXo0CGFhIS4oqo+iX51DfrVNTypXw3D0KlTp1SvXj231sNbkR2Vi34qGX1UOvTT9ZEdrkV2XIu2eCba4pk8tS1kh2uRHaXnC22UfKOdvtBGyTfaWVwbyQ7XIjuceUs7JO9pC+3wLHZpB9nhWmRH+fhquyXfbTvttke7yQ7XIjtcj74pHn1TPPqmeKXpG7LDtcgOZ97SDsl72uIt7ZC8py12aIerssNnJ5aEhYXJ399fR48edVp/9OjRYm8nExERcd3yBf8ePXpUkZGRTmXatGlT5D4DAwMVGBjotK5WrVpWmuIkJCTEY/+I7Yx+dQ361TU8pV9DQ0PdXYUKR3b4NvqpZPRR6dBPxSM7riA7Khdt8Uy0xTN5YlvIjivIDs/gC22UfKOdvtBGyTfaWVQbyY4ryI7K4y3tkLynLbTDs9ihHWTHFWSH5/LVdku+23ba7fnIjivIDnujb4pH3xSPvileSX1DdlxBdlQeb2mH5D1t8ZZ2SN7TFk9vhyuyw6/C92gTAQEBiomJUXp6urnu8uXLSk9PV1xcXJGPiYuLcyovSWlpaWb56OhoRUREOJXJy8vTpk2bit0nAMA+yA4AgFVkBwDAKrIDAGAV2QEAsIrsAABYRXYAAKwiOwDAfnz2jiWSlJSUpD59+ujOO+9Uu3btNG3aNJ05c0Z9+/aVJPXu3Vs33XSTUlJSJEnDhg3Tfffdp8mTJ6tLly5atGiRtmzZojfffFOS5HA4NHz4cL3yyitq3LixoqOj9dJLL6levXrq1q2bu5oJAKhAZAcAwCqyAwBgFdkBALCK7AAAWEV2AACsIjsAAFaRHQBgLz49seSxxx7T8ePHNXbsWOXk5KhNmzZauXKlwsPDJUnZ2dny8/vlpi533XWXFi5cqDFjxujFF19U48aNtWzZMrVo0cIsM2rUKJ05c0aDBg1Sbm6u7rnnHq1cuVJBQUEubUtgYKDGjRt3zS27UD70q2vQr65Bv1YOssP30E8lo49Kh37yXWSHZ6Itnom2eCZvaotdkB324gttlHyjnb7QRsk32ukLbbwa2eF5vKUdkve0hXZ4Fm9ph52RHfbnq+2WfLfttNu32u2JyA7fQN8Uj74pHn1TPF/vG7LD83hLOyTvaYu3tEPynrZ4SzvKwmEYhuHuSgAAAAAAAAAAAAAAAAAAAAAAAKDy+ZVcBAAAAAAAAAAAAAAAAAAAAAAAAN6IiSUAAAAAAAAAAAAAAAAAAAAAAAA+ioklAAAAAAAAAAAAAAAAAAAAAAAAPoqJJQAAAAAAAAAAAAAAAAAAAAAAAD6KiSVeYObMmWrYsKGCgoIUGxurzZs3u7tKHm38+PFyOBxOS9OmTc3t586dU2JiourUqaMaNWqoR48eOnr0qNM+srOz1aVLF1WrVk1169bVyJEjdfHixcpuilt9+umn+s1vfqN69erJ4XBo2bJlTtsNw9DYsWMVGRmp4OBgxcfHa9++fU5lfvzxRz355JMKCQlRrVq11L9/f50+fdqpzNdff617771XQUFBql+/viZNmuTqprlVSf36zDPPXPP327lzZ6cy9CtKw9ezo7Lew+wsJSVFv/rVr1SzZk3VrVtX3bp10969e53KkJnS7Nmz1apVK4WEhCgkJERxcXH697//bW6nj+BN7JAdpXnv6tix4zXHU4MHD3Yq4wmvS28atzRs2PCatjgcDiUmJkry7P8Tbxr3XK8tFy5c0OjRo9WyZUtVr15d9erVU+/evXX48GGnfRT1f/nqq69WeltgL3bIj9KqiPdmT+MrY6PKOt/iTr4whvOmYz1cnydnhzf9HXrLmMOu4w1vGWswzoCn8OTsKAtfOU4vzBeOZ4vDdYYrXn31VTkcDg0fPtxc5ytth3t4W3aUxBezpbR8OYNKQkaVHjnmGzw5Ozhn5XmvLbues5I4b1WYT563MmBrixYtMgICAow5c+YYO3fuNAYOHGjUqlXLOHr0qLur5rHGjRtn3H777caRI0fM5fjx4+b2wYMHG/Xr1zfS09ONLVu2GO3btzfuuusuc/vFixeNFi1aGPHx8ca2bduMTz75xAgLCzOSk5Pd0Ry3+eSTT4z/9//+n7F06VJDkvHBBx84bX/11VeN0NBQY9myZcZXX31l/Pa3vzWio6ONs2fPmmU6d+5stG7d2ti4caPx2WefGbfeeqvRq1cvc/vJkyeN8PBw48knnzR27Nhh/OMf/zCCg4ONv/3tb5XVzEpXUr/26dPH6Ny5s9Pf748//uhUhn5FSciOynkPs7uEhARj7ty5xo4dO4ysrCzj4YcfNho0aGCcPn3aLENmGsZHH31krFixwvjvf/9r7N2713jxxReNqlWrGjt27DAMgz6C97BLdpTmveu+++4zBg4c6HQ8dfLkSXO7p7wuvWnccuzYMad2pKWlGZKMtWvXGobh2f8n3jTuuV5bcnNzjfj4eOP999839uzZY2RkZBjt2rUzYmJinPYRFRVlTJgwwen/qvDri7EGrmaX/Cit8r43eyJfGRtVxvkWd/OFMZw3HeuheJ6eHd70d+gtYw67jje8ZazBOAOewNOzoyx85Ti9MF84ni0O1xkMY/PmzUbDhg2NVq1aGcOGDTPX+0Lb4R7emB0l8cVsKS1fzqCSkFGlQ475Bk/PDs5Zed5ry67nrAyD81aF+eJ5KyaW2Fy7du2MxMRE8/dLly4Z9erVM1JSUtxYK882btw4o3Xr1kVuy83NNapWrWosWbLEXLd7925DkpGRkWEYxpU3Gz8/PyMnJ8csM3v2bCMkJMTIz893ad091dVvupcvXzYiIiKM1157zVyXm5trBAYGGv/4xz8MwzCMXbt2GZKML7/80izz73//23A4HMb//vc/wzAMY9asWcYNN9zg1K+jR482mjRp4uIWeYbiPujQtWvXYh9Dv6I0yA5nrnoP8zbHjh0zJBnr1683DIPMvJ4bbrjBePvtt+kjeBW7ZsfV712GceUETeGTulfzlNelN49bhg0bZtxyyy3G5cuXDcOwz/+JN417ihprXG3z5s2GJOO7774z10VFRRlTp04t9jGMNXA1u+ZHccr73uzpfGVs5KrzLZ7GF8Zwdj7WQ/Hslh12/jv01jGHHccb3jLWYJwBd7FbdljlK8fpV/OF49nr8aXrDKdOnTIaN25spKWlOeW2L7Qd7uPt2VESX82W0vL1DCqJL2VUaZBjvsNu2cE5K/e342p2PGdlGJy38sXzVn7lv+cJ3OX8+fPKzMxUfHy8uc7Pz0/x8fHKyMhwY8083759+1SvXj01atRITz75pLKzsyVJmZmZunDhglOfNm3aVA0aNDD7NCMjQy1btlR4eLhZJiEhQXl5edq5c2flNsRDHTx4UDk5OU79GBoaqtjYWKd+rFWrlu68806zTHx8vPz8/LRp0yazTIcOHRQQEGCWSUhI0N69e/XTTz9VUms8z7p161S3bl01adJEQ4YM0Q8//GBuo19RErKjZBX1HuZtTp48KUmqXbu2JDKzKJcuXdKiRYt05swZxcXF0UfwGnbOjqvfuwq89957CgsLU4sWLZScnKyff/7Z3OZJr0tvHLecP39eCxYsUL9+/eRwOMz1dvk/Kczbxz0nT56Uw+FQrVq1nNa/+uqrqlOnju644w699tprTrdb9tS2wD3snB/XU573ZrvxtbFRec+3eBpfGMPZ/VgP17Jjdtj979DbxhzeMt7w5rEG4wxUNDtmR3n5ynG6LxzPFsUXrzMkJiaqS5cuTm2UfOf/HJXPF7OjJL6SLaXlqxlUEl/MqNIgx3yDHbODc1ae0Y4C3nLOSuK8lS+ct6ri7gqg7E6cOKFLly45vXFIUnh4uPbs2eOmWnm+2NhYzZs3T02aNNGRI0f08ssv695779WOHTuUk5OjgICAa94YwsPDlZOTI0nKyckpss8LtuGXfiiqnwr3Y926dZ22V6lSRbVr13YqEx0dfc0+CrbdcMMNLqm/J+vcubO6d++u6OhoHThwQC+++KIeeughZWRkyN/fn35FiciOklXUe5g3uXz5soYPH667775bLVq0kCQys5Dt27crLi5O586dU40aNfTBBx+oefPmysrKoo/gFeyaHUW9d0nSE088oaioKNWrV09ff/21Ro8erb1792rp0qWSPOd16a3jlmXLlik3N1fPPPOMuc4u/ydX8+Zxz7lz5zR69Gj16tVLISEh5vo//vGPatu2rWrXrq0NGzYoOTlZR44c0ZQpU8z6elpb4D52zY/rKe97s9340tioIs63eBJfGMPZ/VgPRbNbdtj979AbxxzeMt7w1rEG4wy4gt2yoyL4wnG6LxzPXs1XrzMsWrRIW7du1ZdffnnNNm//P4f7+GJ2lMQXsqW0fDGDSuKrGVUa5JjvsFt2cM7KM9pRmLecsyr83Jy38t7zVkwsgc956KGHzJ9btWql2NhYRUVFafHixQoODnZjzYCSPf744+bPLVu2VKtWrXTLLbdo3bp16tSpkxtrBsCbJSYmaseOHfr888/dXRWP1KRJE2VlZenkyZP65z//qT59+mj9+vXurhbg84p77xo0aJD5c8uWLRUZGalOnTrpwIEDuuWWWyq7msXy1nHLO++8o4ceekj16tUz19nl/8RXXLhwQY8++qgMw9Ds2bOdtiUlJZk/t2rVSgEBAfrDH/6glJQUBQYGVnZVgUrnre/N8L7zLb4whrP7sR68g93/Dr0x1xhveC7GGQCs8IXj2av54nWGQ4cOadiwYUpLS1NQUJC7qwMAknwzg0riixlVGuQYPBnnrDwP56w8G+etnPm5uwIou7CwMPn7++vo0aNO648ePaqIiAg31cp+atWqpdtuu0379+9XRESEzp8/r9zcXKcyhfs0IiKiyD4v2IZf+uF6f5sRERE6duyY0/aLFy/qxx9/pK8taNSokcLCwrR//35J9CtKRnaUrKLew7zF0KFDtXz5cq1du1Y333yzuZ7M/EVAQIBuvfVWxcTEKCUlRa1bt9b06dPpI3gNO2ZHce9dRYmNjZUkp+MpT3xdesO45bvvvtPq1as1YMCA65azy/+JN457Ck6afffdd0pLS3P6NpaixMbG6uLFi/r2228leVZb4H52zA+rrL43240vj43Kcr7FU/jCGM4bj/VwhZ2ywxv/Du0+5vCm8Ya3jTUYZ8CV7JQdFcXbj9N94Xi2KL54nSEzM1PHjh1T27ZtVaVKFVWpUkXr16/XG2+8oSpVqig8PNxr2w738sXsKIm3Z0tp+WoGlcQXM6o0yDHfYqfs4JyV57XDm85ZFX5uzlt9K8lz2lGRmFhiYwEBAYqJiVF6erq57vLly0pPT1dcXJwba2Yvp0+f1oEDBxQZGamYmBhVrVrVqU/37t2r7Oxss0/j4uK0fft2pze+gjeU5s2bV3r9PVF0dLQiIiKc+jEvL0+bNm1y6sfc3FxlZmaaZdasWaPLly+bIRkXF6dPP/1UFy5cMMukpaWpSZMmtrxFlCt8//33+uGHHxQZGSmJfkXJyI6SVdR7mN0ZhqGhQ4fqgw8+0Jo1a665bR+ZWbzLly8rPz+fPoLXsFN2lPTeVZSsrCxJcjqe8sTXpTeMW+bOnau6deuqS5cu1y1nl/8Tbxv3FJw027dvn1avXq06deqU+JisrCz5+fmZtzL2lLbAM9gpP8rK6nuz3fjy2Kgs51vczRfGcN58rIcr7JAd3vx3aPcxhzeNN7xprME4A65mh+yoaN56nO4Lx7NW+MJ1hk6dOmn79u3KysoylzvvvFNPPvmk+bO3th3u5YvZURJvzZbSIoOs8YWMKg1yzLfYITs4Z+W5ry1vOmclcd7KJ85bGbC1RYsWGYGBgca8efOMXbt2GYMGDTJq1apl5OTkuLtqHuu5554z1q1bZxw8eND44osvjPj4eCMsLMw4duyYYRiGMXjwYKNBgwbGmjVrjC1bthhxcXFGXFyc+fiLFy8aLVq0MB588EEjKyvLWLlypXHjjTcaycnJ7mqSW5w6dcrYtm2bsW3bNkOSMWXKFGPbtm3Gd999ZxiGYbz66qtGrVq1jA8//ND4+uuvja5duxrR0dHG2bNnzX107tzZuOOOO4xNmzYZn3/+udG4cWOjV69e5vbc3FwjPDzcePrpp40dO3YYixYtMqpVq2b87W9/q/T2Vpbr9eupU6eM559/3sjIyDAOHjxorF692mjbtq3RuHFj49y5c+Y+6FeUhOyonPcwuxsyZIgRGhpqrFu3zjhy5Ii5/Pzzz2YZMtMwXnjhBWP9+vXGwYMHja+//tp44YUXDIfDYfznP/8xDIM+gvewS3aU9N61f/9+Y8KECcaWLVuMgwcPGh9++KHRqFEjo0OHDuY+POV16W3jlkuXLhkNGjQwRo8e7bTe0/9PvGncc722nD9/3vjtb39r3HzzzUZWVpbT6yc/P98wDMPYsGGDMXXqVCMrK8s4cOCAsWDBAuPGG280evfuXeltgX3YJT9Kq7zvzZ7IV8ZGlXG+xd18YQznTcd6KJ6nZ4c3/R1605jDjuMNbxlrMM6AJ2M1+qcAAQAASURBVPD07CgLXzlOL8wXjmeLw3WGX9x3333GsGHDzN99qe2oXN6YHSXxxWwpLV/OoJKQUdaQY97N07ODc1ae+dqy4zkrw+C8la+ft2JiiRf461//ajRo0MAICAgw2rVrZ2zcuNHdVfJojz32mBEZGWkEBAQYN910k/HYY48Z+/fvN7efPXvW+L//+z/jhhtuMKpVq2b87ne/M44cOeK0j2+//dZ46KGHjODgYCMsLMx47rnnjAsXLlR2U9xq7dq1hqRrlj59+hiGYRiXL182XnrpJSM8PNwIDAw0OnXqZOzdu9dpHz/88IPRq1cvo0aNGkZISIjRt29f49SpU05lvvrqK+Oee+4xAgMDjZtuusl49dVXK6uJbnG9fv3555+NBx980LjxxhuNqlWrGlFRUcbAgQOvOUClX1Eavp4dlfUeZmdF9Y8kY+7cuWYZMtMw+vXrZ0RFRRkBAQHGjTfeaHTq1Mk8kWYY9BG8ix2yo6T3ruzsbKNDhw5G7dq1jcDAQOPWW281Ro4caZw8edJpP57wuvS2ccuqVasMSdfkqaf/n3jTuOd6bTl48GCxr5+1a9cahmEYmZmZRmxsrBEaGmoEBQUZzZo1M/785z87fei6stoCe7FDfpRWRbw3expfGRtV1vkWd/KFMZw3Hevh+jw5O7zp79Cbxhx2HG94y1iDcQY8hSdnR1n4ynF6Yb5wPFscrjP84uoP5PpS21H5vC07SuKL2VJavpxBJSGjrCHHvJ8nZwfnrDzztWXHc1aGwXkrXz9v5TAMwxAAAAAAAAAAAAAAAAAAAAAAAAB8jp+7KwAAAAAAAAAAAAAAAAAAAAAAAAD3YGIJAAAAAAAAAAAAAAAAAAAAAACAj2JiCQAAAAAAAAAAAAAAAAAAAAAAgI9iYgkAAAAAAAAAAAAAAAAAAAAAAICPYmIJAAAAAAAAAAAAAAAAAAAAAACAj2JiCQAAAAAAAAAAAAAAAAAAAAAAgI9iYgkAAAAAAAAAAAAAAAAAAAAAAICPYmIJAAAAAAAAAAAAAAAAAAAAAACAj2JiCWBDOTk5evbZZ9WoUSMFBgaqfv36+s1vfqP09HRJUsOGDeVwOORwOBQcHKyGDRvq0Ucf1Zo1a4rd5w8//KCbb75ZDodDubm5RZb54osvVKVKFbVp08YFrQIAuFJFZscf//hHxcTEKDAwsMRM2L9/v2rWrKlatWq5oFUAAFeq7OwwDEOvv/66brvtNgUGBuqmm27Sn/70J1c2EQBQwSoqO7766iv16tVL9evXV3BwsJo1a6bp06c7lVm3bp25r8JLTk5OpbUXAFC8yryOUZpMeOaZZ8z1VatWVXR0tEaNGqVz585d8zzLly/Xfffdp5o1a6patWr61a9+pXnz5lVY3wAArKnMcUbhvCi83H777WaZU6dOafjw4YqKilJwcLDuuusuffnll67vCABAmRT1vl54GT9+vL799ls5HA5lZWU5PfZf//qXHnjgAd1www0KDg5WkyZN1K9fP23bts0sM2/ePPNaeMeOHa/7XB07dqy8hgMAyqUyxyHSlfNbbdu2VWBgoG699VbORcFtmFgC2My3336rmJgYrVmzRq+99pq2b9+ulStX6v7771diYqJZbsKECTpy5Ij27t2r+fPnq1atWoqPjy/2g1n9+/dXq1atin3e3Nxc9e7dW506darwNgEAXMsV2dGvXz899thj133eCxcuqFevXrr33nsrvE0AANdyR3YMGzZMb7/9tl5//XXt2bNHH330kdq1a+eS9gEAKl5FZkdmZqbq1q2rBQsWaOfOnfp//+//KTk5WTNmzLjmeffu3asjR46YS926dSulvQCA4rnrOkZJmdC5c2cdOXJE33zzjaZOnaq//e1vGjdunFOZv/71r+ratavuvvtubdq0SV9//bUef/xxDR48WM8//3w5egUAUBaVPc6YPn26U5YcOnRItWvXVs+ePc0yAwYMUFpamv7+979r+/btevDBBxUfH6///e9/ldMpAABLCr+vT5s2TSEhIU7rijvOHz16tB577DG1adNGH330kfbu3auFCxeqUaNGSk5OLvIxS5cuNfe7efNmSdLq1avNdUuXLnVZOwEAFaeyxyEHDx5Uly5ddP/99ysrK0vDhw/XgAEDtGrVqkptNyBJVdxdAQDW/N///Z8cDoc2b96s6tWrm+tvv/129evXz/y9Zs2aioiIkCQ1aNBAHTp0UGRkpMaOHavf//73atKkiVl29uzZys3N1dixY/Xvf/+7yOcdPHiwnnjiCfn7+2vZsmWuaRwAwCUqOjveeOMNSdLx48f19ddfF/u8Y8aMUdOmTdWpUydt2LDBFU0DALhIZWfH7t27NXv2bO3YscN8THR0tMvaBwCoeBWZHYXLS1KjRo2UkZGhpUuXaujQoU7b6tatyx0SAcDDuOs6RkmZEBgYaD5f/fr1FR8fr7S0NP3lL3+RJB06dEjPPfechg8frj//+c/m45577jkFBAToj3/8o3r27KnY2FjrnQIAKJPKHmeEhoYqNDTULLNs2TL99NNP6tu3ryTp7Nmz+te//qUPP/xQHTp0kCSNHz9eH3/8sWbPnq1XXnnFNR0BACizgnyQrrzPOxwOp3WSdOLECaffN27cqEmTJmn69On64x//aK5v0KCBYmJiZBhGkc9Vu3Zt8+eCuyPWqVPnmucDAHi2yh6HpKamKjo6WpMnT5YkNWvWTJ9//rmmTp2qhIQEVzcXcMIdSwAb+fHHH7Vy5UolJiY6BVaBki6iDxs2TIZh6MMPPzTX7dq1SxMmTND8+fPl51f0W8LcuXP1zTffXPPNXQAAz+eK7CiNNWvWaMmSJZo5c6alxwEA3M8d2fHxxx+rUaNGWr58uaKjo9WwYUMNGDBAP/74o9XqAwDcoDKy4+TJk04X5wu0adNGkZGR+vWvf60vvvjCct0BABXLXdcxJGuZsGPHDm3YsEEBAQHmun/+85+6cOFCkd9Y/Ic//EE1atTQP/7xj+vuFwBQcdw5zijwzjvvKD4+XlFRUZKkixcv6tKlSwoKCnIqFxwcrM8///y69QEA2Mc//vEP1ahRQ//3f/9X5HaHw1HJNQIAVBZ3jEMyMjIUHx/vVCYhIUEZGRnWKg9UACaWADayf/9+GYahpk2blunxtWvXVt26dfXtt99KkvLz89WrVy+99tpratCgQZGP2bdvn1544QUtWLBAVapwkyMAsJuKzo7S+OGHH/TMM89o3rx5CgkJKdPzAgDcxx3Z8c033+i7777TkiVLNH/+fM2bN0+ZmZn6/e9/X6Y6AAAql6uzY8OGDXr//fc1aNAgc11kZKRSU1P1r3/9S//6179Uv359dezYUVu3bi1THQAAFcMd1zFKmwnLly9XjRo1FBQUpJYtW+rYsWMaOXKkuf2///2vQkNDFRkZec1zBAQEqFGjRvrvf/9bpnYBAKxzxzijsMOHD+vf//63BgwYYK6rWbOm4uLiNHHiRB0+fFiXLl3SggULlJGRoSNHjpSpngAAz/Pf//5XjRo1cvqc1JQpU1SjRg1zOXnypBtrCABwFXeMQ3JychQeHu5ULjw8XHl5eTp79myZ6gGUFZ8SB2ykuFspWt1Hwcz55ORkNWvWTE899VSRZS9duqQnnnhCL7/8sm677bZyPzcAoPJVdHaUxsCBA/XEE0+Yt4EHANiLO7Lj8uXLys/P1/z5882xxzvvvKOYmBjt3btXTZo0KXedAACu48rs2LFjh7p27apx48bpwQcfNNc3adLEKR/uuusuHThwQFOnTtXf//73ctcHAFA2lX0dQyp9Jtx///2aPXu2zpw5o6lTp6pKlSrq0aNHuesLAHANd4wzCnv33XdVq1YtdevWzWn93//+d/Xr10833XST/P391bZtW/Xq1UuZmZnlri8AwHP169dPv/3tb7Vp0yY99dRTFZJTAADP4+5xCOBu3LEEsJHGjRvL4XBoz549ZXr8Dz/8oOPHjys6OlqStGbNGi1ZskRVqlRRlSpV1KlTJ0lSWFiYxo0bp1OnTmnLli0aOnSoWWbChAn66quvVKVKFa1Zs6bC2gYAcI2Kzo7SWLNmjV5//XUzO/r376+TJ0+qSpUqmjNnTpnqAQCoPO7IjsjISFWpUsVpQnuzZs0kSdnZ2WWqBwCg8rgqO3bt2qVOnTpp0KBBGjNmTIn7adeunfbv31+mOgAAKkZlX8coTlGZUL16dd16661q3bq15syZo02bNumdd94xt9922206efKkDh8+fM3+zp8/rwMHDvAlXABQidw5zjAMQ3PmzNHTTz+tgIAAp2233HKL1q9fr9OnT+vQoUPavHmzLly4oEaNGpWpngAAz9O4cWN98803unDhgrmuVq1auvXWW3XTTTe5sWYAAFdzxzgkIiJCR48edVp39OhRhYSEKDg4uEz1AMqKiSWAjdSuXVsJCQmaOXOmzpw5c8323Nzc6z5++vTp8vPzM79V5V//+pe++uorZWVlKSsrS2+//bYk6bPPPlNiYqJCQkK0fft2c3tWVpYGDx6sJk2aKCsrS7GxsRXdRABABavo7CiNjIwMp+yYMGGCatasqaysLP3ud7+z2AIAQGVzR3bcfffdunjxog4cOGCu++9//ytJioqKKvV+AADu4Yrs2Llzp+6//3716dNHf/rTn0pVj6ysLEVGRlqpOgCgglX2dYzilJQJfn5+evHFFzVmzBidPXtWktSjRw9VrVpVkydPvqZ8amqqzpw5o169el23/gCAiuPOccb69eu1f/9+9e/fv9gy1atXV2RkpH766SetWrVKXbt2LbFNAAB76NWrl06fPq1Zs2a5uyoAgErmjnFIXFyc0tPTndalpaUpLi6uTG0AyqOKuysAwJqZM2fq7rvvVrt27TRhwgS1atVKFy9eVFpammbPnq3du3dLkk6dOqWcnBxduHBBBw8e1IIFC/T2228rJSVFt956q6Qr36ZS2IkTJyRd+WbgWrVqSZJatGjhVKZu3boKCgq6Zj0AwHNVZHZI0v79+3X69Gnl5OTo7NmzysrKkiQ1b95cAQEB5jfMF9iyZYv8/PzIDgCwkcrOjvj4eLVt21b9+vXTtGnTdPnyZSUmJurXv/413wgMADZRkdmxY8cOPfDAA0pISFBSUpJycnIkSf7+/rrxxhslSdOmTVN0dLRuv/12nTt3Tm+//bbWrFmj//znP+7pAACAqbKvY5Q1E3r27KmRI0dq5syZev7559WgQQNNmjRJzz33nIKCgvT000+ratWq+vDDD/Xiiy/queee4wu3AKCSVfY4o8A777yj2NjYIq9rrFq1SoZhqEmTJtq/f79Gjhyppk2bqm/fvi7uDQBAZYmLi9Nzzz2n5557Tt999526d++u+vXr68iRI3rnnXfkcDjk58f3eQOAt6rsccjgwYM1Y8YMjRo1Sv369dOaNWu0ePFirVixwj0dAN9mALCdw4cPG4mJiUZUVJQREBBg3HTTTcZvf/tbY+3atYZhGEZUVJQhyZBkBAQEGA0aNDAeffRRY82aNdfd79q1aw1Jxk8//VRsmXHjxhmtW7euuMYAACpFRWbHfffdZ5YtvBw8eLDI5547d64RGhrqusYBAFyisrPjf//7n9G9e3ejRo0aRnh4uPHMM88YP/zwQyW1FgBQESoqO8aNG1dkbkRFRZll/vKXvxi33HKLERQUZNSuXdvo2LFjiee+AACVpzKvY5QmE/r06WN07dr1mv2lpKQYN954o3H69Glz3Ycffmjce++9RvXq1Y2goCAjJibGmDNnTpn7AgBQPpU5zjAMw8jNzTWCg4ONN998s8j6vP/++0ajRo2MgIAAIyIiwkhMTDRyc3Nd0XQAQAUr7rr1wYMHDUnGtm3bnNa///77RseOHY3Q0FCjatWqxs0332w88cQTxsaNG8u8TwCAPVT2OGTt2rVGmzZtjICAAKNRo0bG3LlzK6ehwFUchmEYLpqzAgAAAAAAAAAAAAAAAAAAAAAAAA/GPdkAAAAAAAAAAAAAAAAAAAAAAAB8FBNLAAAAAAAAAAAAAAAAAAAAAAAAfBQTSwAAAAAAAAAAAAAAAAAAAAAAAHwUE0sAAAAAAAAAAAAAAAAAAAAAAAB8FBNLAAAAAAAAAAAAAAAAAAAAAAAAfBQTSwAAAAAAAAAAAAAAAAAAAAAAAHwUE0sAAAAAAAAAAAAAAAAAAAAAAAB8FBNLAAAAAAAAAAAAAAAAAAAAAAAAfBQTSwAAAAAAAAAAAAAAAAAAAAAAAHwUE0sAAAAAAAAAAAAAAAAAAAAAAAB8FBNLAAAAAAAAAAAAAAAAAAAAAAAAfBQTSwAAAAAAAAAAAAAAAAAAAAAAAHxUFXdXAM4uX76sw4cPq2bNmnI4HO6uDgCUiWEYOnXqlOrVqyc/P+YwuhrZAcAbkB2Vi+wA4A3IjspFdgDwBmRH5SI7AHgDsqNykR0AvAHZUbnIDgDegOyoXGQHAG/gquxgYomHOXz4sOrXr+/uagBAhTh06JBuvvlmd1fD65EdALwJ2VE5yA4A3oTsqBxkBwBvQnZUDrIDgDchOyoH2QHAm5AdlYPsAOBNyI7KQXYA8CYVnR1MLPEwNWvWlHTlPzokJMTNtQGAssnLy1P9+vXN9zS4FtkBwBuQHZWL7ADgDciOykV2APAGZEflIjsAeAOyo3KRHQC8AdlRucgOAN6A7KhcZAcAb+Cq7GBiiYcpuLVWSEgIoQXA9rhdYOUgOwB4E7KjcpAdALwJ2VE5yA4A3oTsqBxkBwBvQnZUDrIDgDchOyoH2QHAm5AdlYPsAOBNKjo7/Cp0bwAAAAAAAAAAAAAAAAAAAAAAALAN7ljiRbKzs3XixAlJUlhYmBo0aODmGgEAPB3ZAQCwiuwAAFhFdgAArCI7AABWkR0AAKvIDgCAVWQHAG/HxBIvkZ2draZNm+rs2bOSpODgYO3Zs4fgAgAUi+wAAFhFdgAArCI7AABWkR0AAKvIDgCAVWQHAMAqsgOAL/BzdwVQMU6cOKGzZ8+qe/fu6t69u86ePWvOjAQAoChkBwDAKrIDAGAV2QEAsIrsAABYRXYAAKwiOwAAVpEdAHwBdyzxMmFhYe6uAgDAZsgOAIBVZAcAwCqyAwBgFdkBALCK7AAAWEV2AACsIjsAeDPuWAIAAAAAAAAAAAAAAAAAAAAAAOCjmFgCAAAAAAAAAAAAAAAAAAAAAADgo5hYAgAAAAAAAAAAAAAAAAAAAAAA4KOYWAIAAAAAAAAAAAAAAAAAAAAAAOCjmFgCAAAAAAAAAAAAAAAAAAAAAADgo5hYAgAAAAAAAAAAAAAAAAAAAAAA4KOYWAIAAAAAAAAAAAAAAAAAAAAAAOCjmFgCAAAAAAAAAAAAAAAAAAAAAADgo5hYAgAAAAAAAAAAAAAAAAAAAAAA4KOqWH3AF198oW+//VaXLl0y1/Xu3btCKwUA8C5kBwDAKrIDAGAV2QEAsIrsAABYRXYAAKwiOwAAVpEdAAB3sTSxpFevXsrJydEdd9whf39/SZLD4XBJxQAA3oHsAABYRXYAAKwiOwAAVpEdAACryA4AgFVkBwDAqvJmx/jx4/Xyyy87rWvSpIn27NkjSTp37pyee+45LVq0SPn5+UpISNCsWbMUHh5uls/OztaQIUO0du1a1ahRQ3369FFKSoqqVPnl48br1q1TUlKSdu7cqfr162vMmDF65plnnJ535syZeu2115STk6PWrVvrr3/9q9q1a3fd+i9ZskQvvfSSvv32WzVu3Fh/+ctf9PDDD5vbDcPQuHHj9NZbbyk3N1d33323Zs+ercaNG5e6jwAAxbM0seSrr77Srl27XFUXAIAXKm92MOABAN/DuAMAYBXZAQCwiuwAAFjF9Q6udwCAVYw7AABWVUR23H777Vq9erX5e+HxwogRI7RixQotWbJEoaGhGjp0qLp3764vvvhCknTp0iV16dJFERER2rBhg44cOaLevXuratWq+vOf/yxJOnjwoLp06aLBgwfrvffeU3p6ugYMGKDIyEglJCRIkt5//30lJSUpNTVVsbGxmjZtmhISErR3717VrVu3yHpv2LBBvXr1UkpKih555BEtXLhQ3bp109atW9WiRQtJ0qRJk/TGG2/o3XffVXR0tF566SUlJCRo165dCgoKKle/AQAkPyuF27Vrp71797qqLgAAL1QR2XH77bfryJEj5vL555+b20aMGKGPP/5YS5Ys0fr163X48GF1797d3F4w4Dl//rw2bNigd999V/PmzdPYsWPNMgUDnvvvv19ZWVkaPny4BgwYoFWrVpllCgY848aN09atW9W6dWslJCTo2LFjxda7YMDTv39/bdu2Td26dVO3bt20Y8cOs0zBgCc1NVWbNm1S9erVlZCQoHPnzpWrzwDAzhh3AACsIjsAAFaRHQAAq7jewfUOALCKcQcAwKqKyI4qVaooIiLCXMLCwiRJJ0+e1DvvvKMpU6bogQceUExMjObOnasNGzZo48aNkqT//Oc/2rVrlxYsWKA2bdrooYce0sSJEzVz5kydP39ekpSamqro6GhNnjxZzZo109ChQ/X73/9eU6dONeswZcoUDRw4UH379lXz5s2VmpqqatWqac6cOcXWe/r06ercubNGjhypZs2aaeLEiWrbtq1mzJgh6cpk9mnTpmnMmDHq2rWrWrVqpfnz5+vw4cNatmxZufoMAHCFpTuWZGVlqXXr1mrSpIkCAwNlGIYcDoc2b97sqvoBAGyuIrKjYMBztYIBz8KFC/XAAw9IkubOnatmzZpp48aNat++vTngWb16tcLDw9WmTRtNnDhRo0eP1vjx4xUQEOA04JGkZs2a6fPPP9fUqVPNmfSFBzzSlUHSihUrNGfOHL3wwgtF1rvwgEeSJk6cqLS0NM2YMUOpqanXDHgkaf78+QoPD9eyZcv0+OOPl7qPAMCbMO4AAFhFdgAArCI7AABWcb2D6x0AYBXjDgCAVRWRHfv27VO9evUUFBSkuLg4paSkqEGDBsrMzNSFCxcUHx9vlm3atKkaNGigjIwMtW/fXhkZGWrZsqXTnRMTEhI0ZMgQ7dy5U3fccYcyMjKc9lFQZvjw4ZKk8+fPKzMzU8nJyeZ2Pz8/xcfHKyMjo9h6Z2RkKCkp6Zr9FkwaOXjwoHJycpyeOzQ0VLGxscrIyCh23JGfn6/8/Hzz97y8vGLrAAC+ztLEkg8//NBV9QAAeKmKyA4GPM4Y8ADwdow7AABWkR0AAKvIDgCAVVzvqPjrHQDg7Rh3AACsKm92xMbGat68eWrSpImOHDmil19+Wffee6927NihnJwcBQQEqFatWk6PCQ8PV05OjiQpJyfHacxRsL1g2/XK5OXl6ezZs/rpp5906dKlIsvs2bOn2LoXt9/Cz1u4PkWVKUpKSopefvnlYrcDAH5haWJJVFSUtm3bZt6S995771WbNm1cUS8AgJcob3Yw4LkWAx4A3o5xBwDAKrIDAGAV2QEAsIrrHRV/vYMv0gLg7Rh3AACsKm92PPTQQ+bPrVq1UmxsrKKiorR48WIFBwdXdHVtITk52WmifF5enurXr+/GGgGA5/KzUvj111/XgAEDdPr0aZ0+fVoDBw7UlClTXFU3AIAXKG92PPTQQ+rZs6datWqlhIQEffLJJ8rNzdXixYtdWGvPlpycrJMnT5rLoUOH3F0lAKhQjDsAAFaRHQAAq8gOAIBVXO+oeCkpKQoNDTUXPtwFwNtU5Ljj1VdflcPhMO9CJUnnzp1TYmKi6tSpoxo1aqhHjx46evSo0+Oys7PVpUsXVatWTXXr1tXIkSN18eJFpzLr1q1T27ZtFRgYqFtvvVXz5s275vlnzpyphg0bKigoSLGxsdq8eXOJdV6yZImaNm2qoKAgtWzZUp988onTdsMwNHbsWEVGRio4OFjx8fHat29f6TsFALxQRZ+zqlWrlm677Tbt379fEREROn/+vHJzc53KHD16VBEREZKkiIiIa7Kk4PeSyoSEhCg4OFhhYWHy9/cvskzBPopS3H4LP2/h+pR2v4GBgQoJCXFaAABFszSxZP78+dqwYYOSk5OVnJyszz//vMjBBAAABSo6OxjwMOAB4P0YdwAArCI7AABWkR0AAKu43lHx1zv4Ii0A3q6isuPLL7/U3/72N7Vq1cpp/YgRI/Txxx9ryZIlWr9+vQ4fPqzu3bub2y9duqQuXbro/Pnz2rBhg959913NmzdPY8eONcscPHhQXbp00f3336+srCwNHz5cAwYM0KpVq8wy77//vpKSkjRu3Dht3bpVrVu3VkJCgo4dO1ZsnTds2KBevXqpf//+2rZtm7p166Zu3bppx44dZplJkybpjTfeUGpqqjZt2qTq1asrISFB586ds9xHAOAtKnrccfr0aR04cECRkZGKiYlR1apVlZ6ebm7fu3evsrOzFRcXJ0mKi4vT9u3bnd7j09LSFBISoubNm5tlCu+joEzBPgICAhQTE+NU5vLly0pPTzfLFKWk/UZHRysiIsKpTF5enjZt2nTd/QIASs/SxBJJTgfvHMgDAEqjIrODAQ8A+AbGHQAAq8gOAIBVZAcAwCqudxS937Je7+CLtAD4gvJmx+nTp/Xkk0/qrbfe0g033GCuP3nypN555x1NmTJFDzzwgGJiYjR37lxt2LBBGzdulCT95z//0a5du7RgwQK1adNGDz30kCZOnKiZM2fq/PnzkqTU1FRFR0dr8uTJatasmYYOHarf//73mjp1qvlcU6ZM0cCBA9W3b181b95cqampqlatmubMmVNsvadPn67OnTtr5MiRatasmSZOnKi2bdtqxowZkq7crWTatGkaM2aMunbtqlatWmn+/Pk6fPiwli1bZrmfAMCblCc7nn/+ea1fv17ffvutNmzYoN/97nfy9/dXr169FBoaqv79+yspKUlr165VZmam+vbtq7i4OLVv316S9OCDD6p58+Z6+umn9dVXX2nVqlUaM2aMEhMTFRgYKEkaPHiwvvnmG40aNUp79uzRrFmztHjxYo0YMcKsR1JSkt566y29++672r17t4YMGaIzZ86ob9++ZpnevXsrOTnZ/H3YsGFauXKlJk+erD179mj8+PHasmWLhg4dKknmnbteeeUVffTRR9q+fbt69+6tevXqqVu3bpb7GQBwrSpWCo8cOVIxMTGKj4+XYRhas2aNxo0b56q6AQC8QHmz4/nnn9dvfvMbRUVF6fDhwxo3blyRA57atWsrJCREzz77bLEDnkmTJiknJ6fIAc+MGTM0atQo9evXT2vWrNHixYu1YsUKsx5JSUnq06eP7rzzTrVr107Tpk0rcsBz0003KSUlRdKVAc99992nyZMnq0uXLlq0aJG2bNmiN998U5LzgKdx48aKjo7WSy+9xIAHgM9j3AEAsIrsAABYRXYAAKziegfXOwDAqooYdyQmJqpLly6Kj4/XK6+8Yq7PzMzUhQsXFB8fb65r2rSpGjRooIyMDLVv314ZGRlq2bKlwsPDzTIJCQkaMmSIdu7cqTvuuEMZGRlO+ygoM3z4cEnS+fPnlZmZ6fTBXz8/P8XHxysjI6PYemdkZCgpKema/RZMGjl48KBycnKcnjs0NFSxsbHKyMjQ448/XuR+8/PzlZ+fb/6el5dXbB0AwI7Kmx3ff/+9evXqpR9++EE33nij7rnnHm3cuFE33nijJGnq1Kny8/NTjx49lJ+fr4SEBM2aNct8vL+/v5YvX64hQ4YoLi5O1atXV58+fTRhwgSzTHR0tFasWKERI0Zo+vTpuvnmm/X2228rISHBLPPYY4/p+PHjGjt2rHJyctSmTRutXLnSKZOys7Pl5/fLd+PfddddWrhwocaMGaMXX3xRjRs31rJly9SiRQuzzKhRo3TmzBkNGjRIubm5uueee7Ry5UoFBQVZ62gAQJEsTSx5+umn1alTJ3355ZeSpPHjxysyMrJMT/zqq68qOTlZw4YN07Rp0yRdmV353HPPadGiRU6hdXWYDBkyRGvXrlWNGjXUp08fpaSkqEqVX5qybt06JSUlaefOnapfv77GjBmjZ555xun5Z86cqddee005OTlq3bq1/vrXv6pdu3bXrfOSJUv00ksv6dtvv1Xjxo31l7/8RQ8//LC53TAMjRs3Tm+99ZZyc3N19913a/bs2WrcuHGZ+ggAvEF5s4MBDwD4noocdwAAfAPZAQCwiuwAAFjF9Q6udwCAVeXNjkWLFmnr1q3m4wvLyclRQECAatWq5bQ+PDxcOTk5ZpnC7+8F2wu2Xa9MXl6ezp49q59++kmXLl0qssyePXuKrXtx+y38vIXrU1SZoqSkpOjll18udjsA2F1FZMf1BAUFaebMmZo5c2axZaKiovTJJ59cdz8dO3bUtm3brltm6NCh5t1GirJu3bpr1vXs2VM9e/Ys9jEOh0MTJkxwGgcBACqOX8lFrswSl6Rdu3YpNzdXjRs3VuPGjfXTTz9p165dlp/0yy+/1N/+9je1atXKaf2IESP08ccfa8mSJVq/fr0OHz6s7t27m9svXbqkLl266Pz589qwYYPeffddzZs3T2PHjnWqa5cuXXT//fcrKytLw4cP14ABA7Rq1SqzzPvvv6+kpCSNGzdOW7duVevWrZWQkOB02+CrbdiwQb169VL//v21bds2devWTd26ddOOHTvMMpMmTdIbb7yh1NRUbdq0SdWrV1dCQkK5b4MMAHZW3uxYtGiRDh8+rPz8fH3//fdatGiRbrnlFnN7wYDnxx9/1JkzZ7R06VJFREQ47aNgwPPzzz/r+PHjev31150mJEq/DHjy8/N14MCBayYkSlcGPN99953y8/O1adMmxcbGOm1ft26d5s2b57SuZ8+e2rt3r/Lz87Vjxw6nCYnSLwOenJwcnTt3TqtXr9Ztt91W6v4BAG9U3uwYP368HA6H09K0aVNz+7lz55SYmKg6deqoRo0a6tGjh44ePeq0j+zsbHXp0kXVqlVT3bp1NXLkSF28eNGpzLp169S2bVsFBgbq1ltvvSYDpCsT2hs2bKigoCDFxsZq8+bNJdZ/yZIlatq0qYKCgtSyZctrTtoZhqGxY8cqMjJSwcHBio+P1759+0rdPwDgjSrqnBUAwHeQHQAAq7jewfUOALCqPNlx6NAhDRs2TO+99x6T9ApJTk7WyZMnzeXQoUPurhIAVCjOWQEA3KlUdyxJSUnRm2++qcTExGu2ORwOrVmzptRPePr0aT355JN66623nG7RePLkSb3zzjtauHChHnjgAUnS3Llz1axZM23cuFHt27fXf/7zH+3atUurV69WeHi42rRpo4kTJ2r06NEaP368AgIClJqaqujoaE2ePFmS1KxZM33++eeaOnWq+U0sU6ZM0cCBA83b+aampmrFihWaM2eOXnjhhSLrPX36dHXu3FkjR46UJE2cOFFpaWmaMWOGUlNTZRiGpk2bpjFjxqhr166SpPnz5ys8PFzLli0r9haNAODtKiI7AAC+pSKy4/bbb9fq1avN3wtfYB8xYoRWrFihJUuWKDQ0VEOHDlX37t31xRdfSPplQntERIQ2bNigI0eOqHfv3qpatar+/Oc/S/plQvvgwYP13nvvKT09XQMGDFBkZKQ57iiY0J6amqrY2FhNmzZNCQkJ2rt3r+rWrVtkvQsmtKekpOiRRx7RwoUL1a1bN23dutX8BsiCCe3vvvuuoqOj9dJLLykhIUG7du3i4hIAn8W4AwBgFdkBALCK7AAAWFWe7MjMzNSxY8fUtm1bc92lS5f06aefasaMGVq1apXOnz+v3Nxcp7uWHD161JyYGBERcc0XXhV80VbhMld/+dbRo0cVEhKi4OBg+fv7y9/fv8gyV0+ALKy4/RZ+3oJ1hb+J/+jRo2rTpk2x+w0MDFRgYGCx2wHA7hh3AADcqVQTS958801J0uLFi81b8RY4fvy4pSdMTExUly5dFB8f7zSxJDMzUxcuXFB8fLy5rmnTpmrQoIEyMjLUvn17ZWRkqGXLlk63QUxISNCQIUO0c+dO3XHHHcrIyHDaR0GZ4cOHS5LOnz+vzMxMJScnm9v9/PwUHx+vjIyMYuudkZGhpKSka/a7bNkySVc+WJaTk+P03KGhoYqNjVVGRkaxE0vy8/OVn59v/p6Xl1dsHQDAjioiOwAAvqUisqNKlSpFXtBgQjsAeCfGHQAAq8gOAIBVZAcAwKryZEenTp20fft2p3V9+/ZV06ZNNXr0aNWvX19Vq1ZVenq6evToIUnau3evsrOzFRcXJ0mKi4vTn/70Jx07dsz8wqu0tDSFhISoefPmZpmr75yelpZm7iMgIEAxMTFKT09Xt27dJEmXL19Wenq6hg4dWmz94+LilJ6ebn5e6+r9RkdHKyIiQunp6eZEkry8PG3atElDhgwpVR8BgDdi3AEAcCc/K4ULPiBV0rriLFq0SFu3blVKSso123JychQQEOA0i16SwsPDlZOTY5YpPKmkYHvBtuuVycvL09mzZ3XixAldunSpyDIF+yhKcfst/LyF61Pa/aakpCg0NNRc6tevX2xZALCj8mYHAMD3VER27Nu3T/Xq1VOjRo305JNPKjs7W1LJE9olFTuhPS8vTzt37jTLFDWhvWAfBRPaC5cp7YT26+23pAntxcnPz1deXp7TAgDehHEHAMAqsgMAYBXZAQCwqjzZUbNmTbVo0cJpqV69uurUqaMWLVooNDRU/fv3V1JSktauXavMzEz17dtXcXFxat++vSTpwQcfVPPmzfX000/rq6++0qpVqzRmzBglJiaad/0YPHiwvvnmG40aNUp79uzRrFmztHjxYo0YMcKsS1JSkt566y29++672r17t4YMGaIzZ86YX6wlSb1793b6kt9hw4Zp5cqVmjx5svbs2aPx48dry5Yt5mQUh8Oh4cOH65VXXtFHH32k7du3q3fv3qpXr545gQUAfBHjDgCAO5VqYsn+/fu1YsUK5eXl6ZNPPjGXRYsWOd1t43oOHTqkYcOG6b333lNQUFC5Ku1NkpOTdfLkSXM5dOiQu6sEABVm1apV5coOAIDvqYjsiI2N1bx587Ry5UrNnj1bBw8e1L333qtTp04xoZ0J7QC8UEVkx/jx4+VwOJyWpk2bmtvPnTunxMRE1alTRzVq1FCPHj109OhRp31kZ2erS5cuqlatmurWrauRI0fq4sWLTmXWrVuntm3bKjAwULfeeqvmzZt3TV1mzpyphg0bKigoSLGxsdq8eXOJ9V+yZImaNm2qoKAgtWzZ8ppvmTQMQ2PHjlVkZKSCg4MVHx+vffv2lbp/AMDbkB1kBwBYxfUOAIBVlZEdU6dO1SOPPKIePXqoQ4cOioiI0NKlS83t/v7+Wr58ufz9/RUXF6ennnpKvXv31oQJE8wy0dHRWrFihdLS0tS6dWtNnjxZb7/9ttOHmB977DG9/vrrGjt2rNq0aaOsrCytXLnS6VpFdna2jhw5Yv5+1113aeHChXrzzTfVunVr/fOf/9SyZcvUokULs8yoUaP07LPPatCgQfrVr36l06dPa+XKlXyuDIDPYtwBAHC3KqUptHPnTi1btkw//fSTlixZYq6vWbOm3nrrrVI9UWZmpo4dO6a2bdua6y5duqRPP/1UM2bM0KpVq3T+/Hnl5uY6fcjr6NGjioiIkCRFRERcc0Gk4EJM4TJXX5w5evSoQkJCFBwcLH9/f/n7+xdZpmAfRSluv4Wft2BdZGSkU5mCWzYWJTAw0PwWAADwNh9++GG5sgMA4HsqIjseeugh8+dWrVopNjZWUVFRWrx4sYKDgyu0vnaRnJyspKQk8/e8vDwmlwDwGhU17rj99tu1evVq8/cqVX45bTZixAitWLFCS5YsUWhoqIYOHaru3bvriy++kHTlHFeXLl0UERGhDRs26MiRI+rdu7eqVq2qP//5z5Ku3HWqS5cuGjx4sN577z2lp6drwIABioyMNC/Uv//++0pKSlJqaqpiY2M1bdo0JSQkaO/evapbt26R9d6wYYN69eqllJQUPfLII1q4cKG6deumrVu3mhfqJ02apDfeeEPvvvuuoqOj9dJLLykhIUG7du3iQj0An0R2kB0AYBXXOwAAVrkiO9atW+f0e1BQkGbOnKmZM2cW+5ioqKhrJpJfrWPHjtq2bdt1ywwdOtS820hp6iZJPXv2VM+ePYt9jMPh0IQJE5wmugCAL2PcAQBwt1JNLOnatau6du2qzZs3q127dmV6ok6dOmn79u1O6/r27aumTZtq9OjRql+/vqpWrar09HT16NFDkrR3715lZ2crLi5OkhQXF6c//elPOnbsmHlBJC0tTSEhIWrevLlZ5uoBUVpamrmPgIAAxcTEKD093bx14uXLl5Wenn7dAVBcXJzS09M1fPjwIvcbHR2tiIgIpaenmxNJ8vLytGnTJg0ZMqQMPQYA9jdr1izt2bOnzNkBAPA9rsiOWrVq6bbbbtP+/fv161//mgntAOBlKio7qlSpUuR79MmTJ/XOO+9o4cKFeuCBByRJc+fOVbNmzbRx40a1b99e//nPf7Rr1y6tXr1a4eHhatOmjSZOnKjRo0dr/PjxCggIUGpqqqKjozV58mRJUrNmzfT5559r6tSp5oeDp0yZooEDB6pv376SpNTUVK1YsUJz5szRCy+8UGS9p0+frs6dO2vkyJGSpIkTJyotLU0zZsxQamqqDMPQtGnTNGbMGHXt2lWSNH/+fIWHh2vZsmV6/PHHy9VvAGBHZAfZAQBWcb0DAGAV2QEAsIrsAAC4W6kmlhRo2rSpUlJStGvXLqfbay1evLjEx9asWdPpdoaSVL16ddWpU8dc379/fyUlJal27doKCQnRs88+q7i4OLVv316S9OCDD6p58+Z6+umnNWnSJOXk5GjMmDFKTEw0PyQ1ePBgzZgxQ6NGjVK/fv20Zs0aLV68WCtWrDCfNykpSX369NGdd96pdu3aadq0aTpz5ox54UWSevfurZtuukkpKSmSpGHDhum+++7T5MmT1aVLFy1atEhbtmzRm2++KenKLPrhw4frlVdeUePGjc1v8KpXr545gQUAfFF5sgMA4JsqOjtOnz6tAwcO6Omnn1ZMTAwT2gHAC1VEduzbt0/16tVTUFCQ4uLilJKSogYNGigzM1MXLlxQfHy80/M1aNBAGRkZat++vTIyMtSyZUuFh4ebZRISEjRkyBDt3LlTd9xxhzIyMpz2UVCm4D3//PnzyszMVHJysrndz89P8fHxysjIKLbeGRkZTnelKtjvsmXLJF35tvucnByn5w4NDVVsbKwyMjKK/XBwfn6+U1/m5eUVWwcAsCOyg+wAAKu43gEAsIrsAABYRXYAANzJz0rhJ598UjVq1NCmTZvUp08fORwORUVFVVhlpk6dqkceeUQ9evRQhw4dFBERoaVLl5rb/f39tXz5cvn7+ysuLk5PPfWUevfu7XRLxOjoaK1YsUJpaWlq3bq1Jk+erLffftv89i5Jeuyxx/T6669r7NixatOmjbKysrRy5UqnCzjZ2dk6cuSI+ftdd92lhQsX6s0331Tr1q31z3/+U8uWLXOaLDNq1Cg9++yzGjRokH71q1/p9OnTWrlyJbeFB+DTXJ0dAADvU97seP7557V+/Xp9++232rBhg373u9/J399fvXr1UmhoqDmhfe3atcrMzFTfvn2LndD+1VdfadWqVUVOaP/mm280atQo7dmzR7NmzdLixYs1YsQIsx5JSUl666239O6772r37t0aMmRIkRPaC38IbNiwYVq5cqUmT56sPXv2aPz48dqyZYs5GaXwhPaPPvpI27dvV+/evZnQDsDnlTc7YmNjNW/ePK1cuVKzZ8/WwYMHde+99+rUqVPKyclRQECA052uJCk8PFw5OTmSpJycHKfzSgXbC7Zdr0xeXp7Onj2rEydO6NKlS0WWKdhHUYrbb+HnLVyf0u43JSVFoaGh5lK/fv1iywKAHZEdZAcAWMX1DgCAVWQHAMAqsgMA4E6W7lhy+PBhPfvss3rrrbfUpUsXPfzww4qNjS3zk69bt87p96CgIM2cOVMzZ84s9jFRUVHXfDPw1Tp27Kht27Zdt8zQoUOv+03BV9dNknr27KmePXsW+xiHw6EJEyY4TXQBAF9X0dkBAPB+5c2O77//Xr169dIPP/ygG2+8Uffcc482btyoG2+8UdKVCe1+fn7q0aOH8vPzlZCQoFmzZpmPL5jQPmTIEMXFxal69erq06dPkRPaR4wYoenTp+vmm28uckL78ePHNXbsWOXk5KhNmzZFTmj38/tlvn/BhPYxY8boxRdfVOPGjYuc0H7mzBkNGjRIubm5uueee5jQDsDnlTc7HnroIfPnVq1aKTY2VlFRUVq8eLGCg4NdUWWPl5yc7PRt9nl5eXxAGIBXITsqHtkBwNtxvQMAYBXZAQCwiuwAALiTpYklVapcKR4eHq709HTVq1dPP/zwg0sqBgDwDmQHAMCq8mbHokWLrrudCe0A4H0qetxRq1Yt3Xbbbdq/f79+/etf6/z588rNzXX65vmjR48qIiJCkhQREaHNmzc77ePo0aPmtoJ/C9YVLhMSEqLg4GD5+/vL39+/yDIF+yhKcfst/LwF6yIjI53KtGnTptj9BgYGmnfqAgBvRHaQHQBgFdc7AABWkR0AAKvIDgCAO/mVXOQXL774ok6ePKnJkydr4sSJeuqppzRlyhRX1Q0A4AXIDgCAVWQHAMCqis6O06dP68CBA4qMjFRMTIyqVq2q9PR0c/vevXuVnZ2tuLg4SVJcXJy2b9+uY8eOmWXS0tIUEhKi5s2bm2UK76OgTME+AgICFBMT41Tm8uXLSk9PN8sUpaT9RkdHKyIiwqlMXl6eNm3adN39AoC3IzvIDgCwinNWAACryA4AgFVkBwDAnSzdsaRr166SrtzWvahv1gUA4GpkBwDAKrIDAGBVebPj+eef129+8xtFRUXp8OHDGjdunPz9/dWrVy+Fhoaqf//+SkpKUu3atRUSEqJnn31WcXFxat++vSTpwQcfVPPmzfX0009r0qRJysnJ0ZgxY5SYmGh+c/vgwYM1Y8YMjRo1Sv369dOaNWu0ePFirVixwqxHUlKS+vTpozvvvFPt2rXTtGnTdObMGfXt29cs07t3b910001KSUmRJA0bNkz33XefJk+erC5dumjRokXasmWL3nzzTUlX7nQ1fPhwvfLKK2rcuLGio6P10ksvqV69eurWrVtZuhsAvALZQXYAgFWcswIAWEV2AACsIjsAAO5kaWLJgQMHNGPGDH377be6dOmSuf6jjz6q8IoBALwD2QEAsIrsAABYVd7s+P7779WrVy/98MMPuvHGG3XPPfdo48aNuvHGGyVJU6dOlZ+fn3r06KH8/HwlJCRo1qxZ5uP9/f21fPlyDRkyRHFxcapevbr69OmjCRMmmGWio6O1YsUKjRgxQtOnT9fNN9+st99+WwkJCWaZxx57TMePH9fYsWOVk5OjNm3aaOXKlQoPDzfLZGdny8/vl5sQ33XXXVq4cKHGjBmjF198UY0bN9ayZcvUokULs8yoUaN05swZDRo0SLm5ubrnnnu0cuVKBQUFWehlAPAuZAfZAQBWcc4KAGAV2QEAsIrsAAC4k6WJJb/73e80dOhQPfroo04XIQAAKA7ZAQCwiuwAAFhV3uxYtGjRdbcHBQVp5syZmjlzZrFloqKi9Mknn1x3Px07dtS2bduuW2bo0KEaOnRosduL+oaynj17qmfPnsU+xuFwaMKECU4fVgYAX0d2kB0AYBXnrAAAVpEdAACryA4AgDtZmlhSrVo1DRo0yFV1AQB4IbIDAGAV2QEAsIrsAABYRXYAAKwiOwAAVpEdAACryA4AgDtZmliSnJys0aNHKz4+XoGBgeb6Dh06VHjFAADegewAAFhFdgAArCI7AABWkR0AAKvIDgCAVWQHAMAqsgMA4E6WJpasWrVK69at0/79+83bbDkcDkILAFAssgMAYBXZAQCwiuwAAFhFdgAArCI7AABWkR0AAKvIDgCAO1maWLJ69Wrt3btXDofDVfUBAHgZsgMAYBXZAQCwiuwAAFhFdgAArCI7AABWkR0AAKvIDgCAO/lZKdyuXTsdOHDAVXUBAHghsgMAYBXZAQCwiuwAAFhFdgAArCI7AABWkR0AAKvIDgCAO1m6Y8mOHTvUokULNWnSRIGBgTIMQw6HQ5s3b3ZV/QAANkd2AACsIjsAAFaRHQAAq8gOAIBVZAcAwCqyAwBgFdkBAHAnSxNLPvzwQ1fVAwDgpcgOAIBVZAcAwCqyAwBgFdkBALCK7AAAWEV2AACsIjsAAO5Uqokl+fn5CgwM1I033ujq+gAAvAzZAQCwiuwAAFhFdgAArCI7AABWkR0AAKvIDgCAVWQHAMCdSjWxpEePHlq+fLluv/12ORwO8/ZaBf9+8803rq4nAMCmyA4AgFVkBwDAKrIDAGAV2QEAsIrsAABYRXYAAKwiOwAA7lSqiSXLly+XJB08eNCllQEAeB+yAwBgFdkBALCK7AAAWEV2AACsIjsAAFaRHQAAq8gOAIA7+Vkp3K5du1KtAwCgANkBALCK7AAAWEV2AACsIjsAAFaRHQAAq8gOAIBVZAcAwJ1KdceSEydO6OjRozp9+rR2794twzAkSXl5ecrLy3NpBQEA9rV7926yAwBgCdkBALCK7AAAWEV2AACsIjsAAFaRHQAAq8gOAIC7lWpiyYoVKzRv3jwdOnRIiYmJZmjVrFlTf/7zn11aQQCAfY0cOZLsAABYQnYAAKwiOwAAVpEdAACryA4AgFVkBwDAKrIDAOBupZpY0qdPH/Xp00fLli1Tt27dXFwlAIC3WL58udasWUN2AABKjewAAFhFdgAArCI7AABWkR0AAKvIDgCAVWQHAMDd/KwU3rVrl06dOqVLly6pZ8+euu2227Rs2TIXVQ0A4A3IDgCAVWQHAMAqsgMAYBXZAQCwiuwAAFhFdgAArCI7AADuZGliyZIlS1SzZk0tX75cQUFB+vzzz/Xyyy+7qm4AAC9AdgAArCI7AABWkR0AAKvIDgCAVWQHAMAqsgMAYBXZAQBwJ0sTS86ePStJ+vDDD/X444+rbt26MgzDJRUDAHgHsgMAYBXZAQCwiuwAAFhFdgAArCI7AABWkR0AAKvKmx0pKSn61a9+pZo1a6pu3brq1q2b9u7d61SmY8eOcjgcTsvgwYOdymRnZ6tLly6qVq2a6tatq5EjR+rixYtOZdatW6e2bdsqMDBQt956q+bNm3dNfWbOnKmGDRsqKChIsbGx2rx5c4ltWLJkiZo2baqgoCC1bNlSn3zyidN2wzA0duxYRUZGKjg4WPHx8dq3b18pewgAcD2WJpb85je/UVRUlDIzM/Xggw/q+PHjCgwMdFXdAABeoLzZwYAHAHwP4w4AgFVkBwDAKrIDAGAV1zu43gEAVjHuAABYVd7sWL9+vRITE7Vx40alpaXpwoULevDBB3XmzBmncgMHDtSRI0fMZdKkSea2S5cuqUuXLjp//rw2bNigd999V/PmzdPYsWPNMgcPHlSXLl10//33KysrS8OHD9eAAQO0atUqs8z777+vpKQkjRs3Tlu3blXr1q2VkJCgY8eOFVv/DRs2qFevXurfv7+2bdumbt26qVu3btqxY4dZZtKkSXrjjTeUmpqqTZs2qXr16kpISNC5c+dK3U8AgKJZmljy2muvadu2bdq6dauqVq2qatWq6cMPP3RV3QAAXqC82cGABwB8D+MOAIBVZAcAwCqyAwBgFdc7uN4BAFYx7gAAWFXe7Fi5cqWeeeYZ3X777WrdurXmzZun7OxsZWZmOpWrVq2aIiIizCUkJMTc9p///Ee7du3SggUL1KZNGz300EOaOHGiZs6cqfPnz0uSUlNTFR0drcmTJ6tZs2YaOnSofv/732vq1KnmfqZMmaKBAweqb9++at68uVJTU1WtWjXNmTOn2PpPnz5dnTt31siRI9WsWTNNnDhRbdu21YwZMyRdmcw+bdo0jRkzRl27dlWrVq00f/58HT58WMuWLSt1PwEAimZpYklubq5effVVPf3005Kk77//Xp999plLKgYA8A7lzQ4GPADgexh3AACsIjsAAFaRHQAAq7jewfUOALCqvNlRmrtdnTt3TomJiapTp45q1KihHj166OjRo05luNsVANhHRZ+zOnnypCSpdu3aTuvfe+89hYWFqUWLFkpOTtbPP/9sbsvIyFDLli0VHh5urktISFBeXp527txplomPj3faZ0JCgjIyMiRJ58+fV2ZmplMZPz8/xcfHm2WKUtJ+Dx48qJycHKcyoaGhio2NLXa/+fn5ysvLc1oAAEWzNLGkT58+atasmfmtI9HR0Zo4caJLKgYA8A4VnR0MeBjwAPB+jDsAAFaRHQAAq8gOAIBVXO/gegcAWFXe7CjN3a5GjBihjz/+WEuWLNH69et1+PBhde/e3dzO3a4AwF4qctxx+fJlDR8+XHfffbdatGhhrn/iiSe0YMECrV27VsnJyfr73/+up556ytyek5PjNOaQZP6ek5Nz3TJ5eXk6e/asTpw4oUuXLhVZpmAfRSluv4Wft3B9SrPflJQUhYaGmkv9+vWLfX4A8HWWJpYcPnxYffv2lb+/vyQpICBAfn6l3wUz6QHA95Q3OwpjwHMFAx4A3q4iswMA4BvIDgCAVWQHAMAqrndwvQMArCpvdpR0t6uTJ0/qnXfe0ZQpU/TAAw8oJiZGc+fO1YYNG7Rx40ZJ3O0KAOymIscdiYmJ2rFjhxYtWuS0ftCgQUpISFDLli315JNPav78+frggw904MCBctffEyUnJ+vkyZPmcujQIXdXCQA8lqXEqV69unJzc+VwOCRJW7duVc2aNUv9eGbSA4DvKW92FMaA5woGPAC8XXmzozQT2jt27CiHw+G0DB482KkME9oBwD4qctwBAPANZAcAwCqud1Q8rncA8HYVPe64+m5XmZmZunDhgtPdopo2baoGDRqYd4viblcAYC8VlR1Dhw7V8uXLtXbtWt18883XLRsbGytJ2r9/vyQpIiLimi+DL/g9IiLiumVCQkIUHByssLAw+fv7F1mmYB9FKW6/hZ+3cH1Ks9/AwECFhIQ4LQCAolmaWDJ58mR169ZNBw8eVKdOnfT444/rjTfeKPXjmUkPAL6nvNlRgAHPLxjwAPB25c2O0kxol6SBAwfqyJEj5jJp0iRzGxPaAcBeKmrcAQDwHWQHAMAqrndwvQMArKrIcUdRd7vKyclRQECAatWq5VT26jtKcbcrALCP8maHYRgaOnSoPvjgA61Zs0bR0dElPiYrK0uSFBkZKUmKi4vT9u3bna5pp6WlKSQkRM2bNzfLpKenO+0nLS1NcXFxkq7caSUmJsapzOXLl5Wenm6WKUpJ+42OjlZERIRTmby8PG3atOm6+wUAlE4VK4VjYmK0evVq7d27V5cvX1bTpk1VtWrVMj+51Zn07du3L3Ym/ZAhQ7Rz507dcccdxc54Hz58uKRfZtInJyeb20s7kz4pKema/RZMGilpJv3jjz9+zT7z8/OVn59v/s5MegDeprzZYRiGnn32WX3wwQdat25dmQc8f/rTn3Ts2DHVrVtXUtEDnqu/Db64AU+3bt0k/TLgGTp0aLF1KRjwFGTQ1fstPOBp06aNpF8GPEOGDCmxrQDgjcqbHStXrnT6fd68eapbt64yMzPVoUMHc321atWKvahdMKF99erVCg8PV5s2bTRx4kSNHj1a48ePV0BAgNOEdklq1qyZPv/8c02dOlUJCQmSnCe0S1cmwa9YsUJz5szRCy+8UORzF57QLkkTJ05UWlqaZsyYodTU1GsmtEvS/PnzFR4ermXLlhU57gAAb1fR56wAAN6P7AAAWMX1Dq53AIBVFTnuKLjb1eeff17BtbSX5ORkp89u5eXlMbkEgFcpb3YkJiZq4cKF+vDDD1WzZk1zol5oaKiCg4N14MABLVy4UA8//LDq1Kmjr7/+WiNGjFCHDh3UqlUrSdKDDz6o5s2b6+mnn9akSZOUk5OjMWPGKDExUYGBgZKkwYMHa8aMGRo1apT69eunNWvWaPHixVqxYoVZl6SkJPXp00d33nmn2rVrp2nTpunMmTPmtXNJ6t27t2666SalpKRIkoYNG6b77rtPkydPVpcuXbRo0SJt2bJFb775piTJ4XBo+PDheuWVV9S4cWNFR0frpZdeUr169czxDQCg7CxNLJGkKlWq6Pbbby/3E7tzJv1PP/1U7Ez6PXv2FFtnV82kf/nll4t9TgDwBuXJDgY8AOCbKmrcIV07ob3Ae++9pwULFigiIkK/+c1v9NJLL6latWqSir81PBPaAcBzVWR2AAB8A9kBALCK6x1c7wAAqypi3FFwt6tPP/3U6W5XEREROn/+vHJzc50+a3X1HaU2b97stD+rd7vy9/d3+d2uCiZRFvxeMEnxaoGBgWbmAYC3Kk92zJ49W5LUsWNHp/Vz587VM888o4CAAK1evdocA9SvX189evTQmDFjzLL+/v5avny5hgwZori4OFWvXl19+vTRhAkTzDLR0dFasWKFRowYoenTp+vmm2/W22+/bX4BoyQ99thjOn78uMaOHaucnBy1adNGK1eudLoGn52dLT8/P/P3u+66SwsXLtSYMWP04osvqnHjxlq2bJn5GWNJGjVqlM6cOaNBgwYpNzdX99xzj1auXKmgoKAy9RkA4BeWJ5ZUFGbSX8FMegC4PgY8AIDyKGpCuyQ98cQTioqKUr169fT1119r9OjR2rt3r5YuXSqJCe0AAAAAAACoWFzvAABYVdLdrmJiYlS1alWlp6erR48ekqS9e/cqOzvbvKMUd7sCAN9iGMZ1t9evX1/r168vcT9RUVHXZMPVOnbsqG3btl23zNChQ6+bFevWrbtmXc+ePdWzZ89iH+NwODRhwgSncRAAoGK4ZWIJM+l/wUx6ALg+BjwAgPIobkL7oEGDzJ9btmypyMhIderUSQcOHNAtt9xS2dV0OSa0AwAAAAAAuBfXOwAAVpV0t6vQ0FD1799fSUlJql27tkJCQvTss88qLi5O7du3l8TdrgAAAACUnl/JRaTp06ebP2/durXMT2YYhoYOHaoPPvhAa9asue5M+gJFzaTfvn27jh07ZpYpaiZ94X0UlClqJn2Bgpn0BWWKUtJ+C8+kL1Awk/56+wUAb1ee7AAA+KaKyI6CCe1r1651mtBelNjYWEnS/v37JRU/qbxg2/XKFExoDwsLc/mE9tLuNzAwUCEhIU4LAHgbxh0AAKvIDgCAVWQHAMCq8mTH7NmzdfLkSXXs2FGRkZHm8v7775tlpk6dqkceeUQ9evRQhw4dFBERYd6dXfrlblf+/v6Ki4vTU089pd69exd5t6u0tDS1bt1akydPLvJuV6+//rrGjh2rNm3aKCsrq8i7XR05csT8veBuV2+++aZat26tf/7zn0Xe7erZZ5/VoEGD9Ktf/UqnT5/mblcAfB7jDgCAu5RqYsm7775r/jxgwIAyP1liYqIWLFighQsXmjPpc3JydPbsWUlymkm/du1aZWZmqm/fvsXOpP/qq6+0atWqImfSf/PNNxo1apT27NmjWbNmafHixRoxYoRZl6SkJL311lt69913tXv3bg0ZMqTImfTJycnm78OGDdPKlSs1efJk7dmzR+PHj9eWLVvMb3IpPJP+o48+0vbt29W7d29m0gPweeXJDgCAbypPdpQ0ob0oWVlZkmTeeZAJ7QBgP4w7AABWkR0AAKvIDgCAVeW93lHU8swzz5hlgoKCNHPmTP344486c+aMli5des2XUBXc7ernn3/W8ePH9frrr6tKlSpOZQrudpWfn68DBw44PUeBoUOH6rvvvlN+fr42bdpkfmlXgXXr1mnevHlO63r27Km9e/cqPz9fO3bs0MMPP+y0veBuVzk5OTp37pxWr16t2267zXpnAYAXYdwBAHCXKiUXqTizZ8+WdGUwUtjcuXPNAcnUqVPl5+enHj16KD8/XwkJCZo1a5ZZtmAm/ZAhQxQXF6fq1aurT58+Rc6kHzFihKZPn66bb765yJn0x48f19ixY5WTk6M2bdoUOZPez++XuTcFM+nHjBmjF198UY0bNy5yJv2ZM2c0aNAg5ebm6p577mEmPQAAAFCJSro1/IEDB7Rw4UI9/PDDqlOnjr7++muNGDFCHTp0UKtWrSRxa3gAAAAAAAAAAABfsnv3bklSWFiYGjRo4ObaAAAAAJWvVBNLjh8/rlmzZskwDPPnwv7v//6vVE9mGEaJZQpm0s+cObPYMgUz6a+nYCb99QwdOtS820hR1q1bd826nj17qmfPnsU+pmAmfeGJLgDgq9566y0FBQWVKzsAAL6lIrKjpAntAQEBWr16tTnJo379+urRo4fGjBljlmVCOwDYB+MOAIBVZAcAwCqyAwBgFdlhH6dPn5bD4dBTTz0lSQoODtaePXuYXAKg0pEdAAB3K9XEkgEDBuj48ePX/AwAwPX88MMPCgwMJDsAAKVWEdlR0oT2+vXra/369SXuhwntAGAPjDsAAFaRHQAAq8gOAIBVZId9nDt3ToZhqHv37pKkpUuX6sSJE0wsAVDpyA4AgLuVamLJuHHjXF0PuAC3aATgbi+88IJCQkLcXQ0AgI2QHQAAq8gOAIBVZAcAwCqyAwBgFdlhP2FhYe6uAgAfR3YAANytVBNLSvoW3LFjx1ZIZVAxuEUjAE/xl7/8RYGBgUVuIzsAAEUhOwAAVpEdAACryA4AgFVkBwDAKrIDAGAV2QEAcDe/0hSaMGGCli5dKunK7Ow6deo4LfAshW/R2L17d509e1YnTpxwd7UA+KCPP/5YEtkBACg9sgMAYBXZAQCwiuwAAFhFdgAArCI7AABWkR0AAHcr1R1Lvv/+e/3zn//UBx98oICAAPXs2VO/+93vdMMNN7i6figHbtEIwN169+6tf//732QHAKDUyA4AgFVkBwDAKrIDAGAV2QEAsIrsAABYRXYAANytVHcsiYiI0NChQ5Wenq45c+bo5MmTatasmd59911X1w8AYGODBg0iOwAAlpAdAACryA4AgFVkBwDAKrIDAGAV2QEAsIrsAAC4W6nuWCJJhmFo/fr1ev/997V582b16tVLd999tyvrBgCwOcMwtG7dOrIDAFBqZAcAwCqyAwBgFdkBALCK7AAAWEV2AACsIjsAAO5WqoklQ4cO1caNG3Xvvfeqd+/emj17tqvrBQDwAh07dlTHjh3JDgBAqZEdAACryA4AgFVkBwDAKrIDAGAV2QEAsIrsAAC4W6kmlsyaNUu1a9fWd999pwULFsjhcEi6MkPS4XDo2LFjLq0kAMCesrOztWDBArIDAFBqZAcAwCqyAwBgFdkBALCK7AAAWEV2AACsIjsAAO5Wqoklly9fdnU9AABe6ODBgwoJCXF3NQAANkJ2AACsIjsAAFaRHQAAq8gOAIBVZAcAwCqyAwDgbqWaWHLu3DmlpqZq//79atWqlfr166cqVUr1UACAD5s1a5a+//57sgMAUGpkBwDAKrIDAGAV2QEAsIrsAABYRXYAAKwiOwAA7uZXmkJ9+vTRli1b1LJlS33yySd6/vnnXV0vAIAX2LZtG9kBALCE7AAAWEV2AACsIjsAAFaRHQAAq8gOAIBVZAcAwN1KNaVx165d2r59uySpf//+ateunUsrBQDwDm+99ZZCQkLIDgBAqZEdAACryA4AgFVkBwDAKrIDAGAV2QEAsIrsAAC4W6nuWFK1alXzZ26vBQCwiuwAAFhFdgAArCI7AABWkR0AAKvIDgCAVWQHAMAqsgMA4C6lSqCvv/5adevWlSQZhqHc3FzVrVtXhmHI4XDo2LFjLq0kAMCebrnlFjkcDrIDAFBqZAcAwCqyAwBgFdkBALCK7AAAWEV2AACsIjsAAO5WqoklFy9edHU9AABe6MCBAwoJCXF3NQAANkJ2AACsIjsAAFaRHQAAq8gOAIBVZAcAwCqyAwDgbn7urgAAAAAAAAAAAAAAAAAAAAAAAADco1R3LAEAAL5h9+7dkqSwsDA1aNDAzbUBAAAAAAAAAAAAAAAAAM/D56wAeBsmlgAAAJ0+fVoOh0NPPfWUJCk4OFh79uxh0AMAAAAAAAAAAAAAAAAA/z8+ZwXAW/m5uwIAAMD9zp07J8Mw1L17d3Xv3l1nz57ViRMn3F0tAAAAAAAAAAAAAAAAAPAYfM4KgLfijiUAAMAUFhbm7ioAAAAAAAAAAAAAAAAAgEfjc1YAvA13LAEAAAAAAAAAAAAAAAAAAAAAAPBR3LEEAAAAAFBmu3fvlnTl21gaNGjg5toAAAAAAAAAAAAAAAAAsIqJJQAAAAAAy06fPi2Hw6GnnnpKkhQcHKw9e/YwuQQAAAAAAABux5ehAADKY/fu3WQIAAAAfI6fuyuAyrF7925lZ2e7uxoAAAAAvMS5c+dkGIa6d++u7t276+zZszpx4oS7qwUAAAAAAAAfVvjLUGJiYtS0aVOukwMASq1wjpAhAAAA8DVMLPFyDHgAAAAAuFJYWJjCwsLcXQ0AAAAAAACAL0MBAJRLQY506NCBDAEAAIDP8fmJJTNnzlTDhg0VFBSk2NhYbd68+brllyxZoqZNmyooKEgtW7bUJ5984rTdMAyNHTtWkZGRCg4OVnx8vPbt2+fKJlwXAx4AqHjenh0FuNsVAFQcX8kOAEDFITsAAFaRHQAAq7w5O/gyFABwDW/OjsJCQ0PdXQUA8Bq+kh18zgqAN/DpiSXvv/++kpKSNG7cOG3dulWtW7dWQkKCjh07VmT5DRs2qFevXurfv7+2bdumbt26qVu3btqxY4dZZtKkSXrjjTeUmpqqTZs2qXr16kpISNC5c+cqq1lFYsADABXDF7KDu10BQMXyhewAAFQssgMAYBXZAQCwypeygw94AUDF8KXsKLB7925t3bqVHAGAMvKF7OBzVgC8iU9PLJkyZYoGDhyovn37qnnz5kpNTVW1atU0Z86cIstPnz5dnTt31siRI9WsWTNNnDhRbdu21YwZMyRdmQk5bdo0jRkzRl27dlWrVq00f/58HT58WMuWLavElhWPAQ8AlI8vZMfVd7v67LPPyA4AKAdfyA4AQMXy9uzg/BQAVDxvzw4AQMXzhewo/AGv2267TStWrGAsAgDl4AvZUeDnn382MyQmJoYcAYAy8oXs4HNWALxJFXdXwF3Onz+vzMxMJScnm+v8/PwUHx+vjIyMIh+TkZGhpKQkp3UJCQlmIB08eFA5OTmKj483t4eGhio2NlYZGRl6/PHHK74hpVR4wCNJgYGB+te//qXIyEjl5+crMDBQkor8OSwsTA0aNHBb3QHAU/hadlStWrXM2VHS9rKWtfo4MgyAu/laduzevZv3XgAoJ2/OjsIf6pJ+GWPUrl2bY3gAKAdvzo4Cu3fvllT0eSGyAwCs84XskH75gFe7du305Zdf6pFHHpHkuusdZX1cZV0nyc7O1okTJ8hOAGXiK9lR4Pz58zIMQ927d9fPP/+sVatWlTpHrL6vF7wvF7xPF14HAHbma9lRWZ+zKuvjKvo5yCrAO/nsxJITJ07o0qVLCg8Pd1ofHh6uPXv2FPmYnJycIsvn5OSY2wvWFVfmavn5+crPzzd/P3nypCQpLy/PQmuuXJiXpCNHjig3N/ean48fPy7DMHTXXXcpPz9fmZmZ5oCnJIGBgfr73/+u8PBw+fn56fLly5JU5M8lbbfj4zy5brSJvqiM54iIiFBERISsKHgPMwzD0uM8HdlR+uzwFEVlmB1fh3Z+nCfXjTaRHZXBV7Lj7NmzkqSnnnrK0vih8M+e9rqo7Md5ct3oC9pEdlQub8+OksYYrjoP5cmvp8p+nCfXjTbZo26e0hdkxy+8OTsKjzWK42nXMDz59USb7FE32kR2VAZvzo6irncUTDCx8/WOsirISUl6+umnzQ+Ccf6ONtEXZIdVvpYdBfu9cOGCzpw549IcCQwM1JQpU5SUlGS2raT3ak9+PZX1cZ5cN/qCNpEdZeNr2eENn7OywhOyypPfI+gL2mTX7PDZiSWeIiUlRS+//PI16+vXr1+m/X388cdF/vz1119LkjZs2GB5n/n5+Xr00UfLVB8Avu3UqVMKDQ11dzW8jh2yw1OQYYD9kB2uUVnZIfHeC6DykR2u4crsuN4YgxwBUBnIDtdwZXZcD9kBoDKQHa7B9Q7XKyonyU6gcpAdrlHZ2VHac1rlkZ+fr8TExGvW8V4N+B6ywzUYd7gGWQV4horODp+dWBIWFiZ/f38dPXrUaf3Ro0eLnfUTERFx3fIF/x49elSRkZFOZdq0aVPkPpOTk51u3XX58mX9+OOPqlOnjhwOR6nbk5eXp/r16+vQoUMKCQkp9eM8iTe0QfKOdtAGz2DnNhiGoVOnTqlevXrurkqFIju8E/1AHxSgH65wVz+QHb8gO1zHzvW3c90l6u9udq7/9epOdvyC7KhYdqyzZM96U+fKY8d6u6LOZMcvyA7vQF+VHn1lDf31C7LjF2SH+9A+e6N99laW9pEdvyA7XIf6u4+d6y5Rf3crrv5kxy/IDu9E35UdfVd23t53rsoOn51YEhAQoJiYGKWnp6tbt26SrgRGenq6hg4dWuRj4uLilJ6eruHDh5vr0tLSFBcXJ0mKjo5WRESE0tPTzZDKy8vTpk2bNGTIkCL3GRgYqMDAQKd1tWrVKnO7QkJCbP8C8IY2SN7RDtrgGezaBm+cQU92eDf6gT4oQD9c4Y5+IDuuIDtcz871t3PdJervbnauf3F1JzuuIDtcw451luxZb+pceexY74quM9lxBdnhXeir0qOvrKG/riA7riA73I/22Rvtszer7SM7riA7XI/6u4+d6y5Rf3crqv5kxxVkh3ej78qOvis7b+47V2SHz04skaSkpCT16dNHd955p9q1a6dp06bpzJkz6tu3rySpd+/euummm5SSkiJJGjZsmO677z5NnjxZXbp00aJFi7Rlyxa9+eabkiSHw6Hhw4frlVdeUePGjRUdHa2XXnpJ9erVM4MRAGBvZAcAwCqyAwBgFdkBALCK7AAAWEV2AACsIjsAAFaRHQBgLz49seSxxx7T8ePHNXbsWOXk5KhNmzZauXKlwsPDJUnZ2dny8/Mzy991111auHChxowZoxdffFGNGzfWsmXL1KJFC7PMqFGjdObMGQ0aNEi5ubm65557tHLlSgUFBVV6+wAAFY/sAABYRXYAAKwiOwAAVpEdAACryA4AgFVkBwDAKrIDAGzGgFc4d+6cMW7cOOPcuXPurkqZeUMbDMM72kEbPIM3tAGejb+xK+gH+qAA/XAF/YDrsfvfh53rb+e6Gwb1dzc719/OdccVdvw/tGOdDcOe9abOlceO9bZjnVEx+L8vPfqq9Ogra+gv2I23/83SPnujffbm7e3zZXb/v6X+7mPnuhsG9Xc3u9ff1/H/V3b0XdnRd2VH35WNwzAMw92TWwAAAAAAAAAAAAAAAAAAAAAAAFD5/EouAgAAAAAAAAAAAAAAAAAAAAAAAG/ExBIAAAAAAAAAAAAAAAAAAAAAAAAfxcQSAAAAAAAAAAAAAAAAAAAAAAAAH8XEEgAAAAAAAAAAAAAAAAAAAAAAAB/FxBIvMHPmTDVs2FBBQUGKjY3V5s2b3V0lJ59++ql+85vfqF69enI4HFq2bJnTdsMwNHbsWEVGRio4OFjx8fHat2+fU5kff/xRTz75pEJCQlSrVi31799fp0+frpT6p6Sk6Fe/+pVq1qypunXrqlu3btq7d69TmXPnzikxMVF16tRRjRo11KNHDx09etSpTHZ2trp06aJq1aqpbt26GjlypC5evFgpbZCk2bNnq1WrVgoJCVFISIji4uL073//21ZtuNqrr74qh8Oh4cOHm+s8vR3jx4+Xw+FwWpo2bWqb+sN7eHp2lJcvvtYqK2+//vpr3XvvvQoKClL9+vU1adIkVzfNkpL64Zlnnrnmb6Nz585OZezeD5V57LJu3Tq1bdtWgYGBuvXWWzVv3jxXNw9u5KnZUZq/+Y4dO17z2h88eLBTGXe879s9rxo2bHhN/R0OhxITEyV5Xr/bPSuvV/8LFy5o9OjRatmypapXr6569eqpd+/eOnz4sNM+ivo/e/XVV11ef/LZt3lSftjxHJUdz0t5wzkou5xzsuuxxP/+9z899dRTqlOnjoKDg9WyZUtt2bLF3O6Jr0VULk/KjspQWa9lO47hPekYfsmSJWratKmCgoLUsmVLffLJJxXe3vLwpGNuT+8reCc7Zoddj+WK40nv2a7gSe+zFc3brylU5vljOx5v+TJPzA47nrsqYMdzWIV5w/mswuxybquANxwXcb7LN3hidriTN7x2K4u3j5dcyZvHYh7LgK0tWrTICAgIMObMmWPs3LnTGDhwoFGrVi3j6NGj7q6a6ZNPPjH+3//7f8bSpUsNScYHH3zgtP3VV181QkNDjWXLlhlfffWV8dvf/taIjo42zp49a5bp3Lmz0bp1a2Pjxo3GZ599Ztx6661Gr169KqX+CQkJxty5c40dO3YYWVlZxsMPP2w0aNDAOH36tFlm8ODBRv369Y309HRjy5YtRvv27Y277rrL3H7x4kWjRYsWRnx8vLFt2zbjk08+McLCwozk5ORKaYNhGMZHH31krFixwvjvf/9r7N2713jxxReNqlWrGjt27LBNGwrbvHmz0bBhQ6NVq1bGsGHDzPWe3o5x48YZt99+u3HkyBFzOX78uG3qD+9gh+woL198rVVG3p48edIIDw83nnzySWPHjh3GP/7xDyM4ONj429/+VlnNLFFJ/dCnTx+jc+fOTn8bP/74o1MZu/dDZR27fPPNN0a1atWMpKQkY9euXcZf//pXw9/f31i5cmWltheVw5OzozR/8/fdd58xcOBAp9f+yZMnze3uet+3e14dO3bMqe5paWmGJGPt2rWGYXhev9s9K69X/9zcXCM+Pt54//33jT179hgZGRlGu3btjJiYGKd9REVFGRMmTHD6Pyn8WnFV/cln3+Vp+WHHc1R2PC9l93NQdjrnZMdjiR9//NGIiooynnnmGWPTpk3GN998Y6xatcrYv3+/WcYTX4uoPJ6WHZWhMl7Ldh3De8ox/BdffGH4+/sbkyZNMnbt2mWMGTPGqFq1qrF9+3aX90Fpecoxtx36Ct7Hrtlhx2O56/GU92x3tc/O5za8/ZpCZZ0/tuvxlq/y1Oyw47mrAnY8h1WY3c9nFWanc1sF7H5cxPku3+Cp2eFOdn/tViZvHy+5kjePxTwVE0tsrl27dkZiYqL5+6VLl4x69eoZKSkpbqxV8a5+YV++fNmIiIgwXnvtNXNdbm6uERgYaPzjH/8wDMMwdu3aZUgyvvzyS7PMv//9b8PhcBj/+9//Kq3uBY4dO2ZIMtavX2/Wt2rVqsaSJUvMMrt37zYkGRkZGYZhXHlz8/PzM3Jycswys2fPNkJCQoz8/PzKbUAhN9xwg/H222/brg2nTp0yGjdubKSlpRn33XefORCyQzvGjRtntG7dushtdqg/vIPdsqMsfP215qq8nTVrlnHDDTc49cHo0aONJk2auLhFZVPcgKJr167FPsYb+8FVxy6jRo0ybr/9dqfneuyxx4yEhARXNwluYKfsuPpv3jAMp2PGorjrfd/b8mrYsGHGLbfcYly+fNkwDM/td8Owf1YWlXFX27x5syHJ+O6778x1UVFRxtSpU4t9TGXUn3z2LZ6cH3Y9R2XX81J2OQdlt3NOdjyWGD16tHHPPfcUu90ur0W4jidnh6tUxmvZG8bw7jyGf/TRR40uXbo41Sc2Ntb4wx/+UKFtrCjuPOa2W1/BO9g1O+x4LFdadj/vUhJvP7fh7dcUXHX+2FPah9KxQ3bY9dxVAbuewyrMLuezCrPbua0Cdj8u4nyXb7BDdlQ2u7923cXbx0uu5O1jMU/hV46bncDNzp8/r8zMTMXHx5vr/Pz8FB8fr4yMDDfWrPQOHjyonJwcpzaEhoYqNjbWbENGRoZq1aqlO++80ywTHx8vPz8/bdq0qdLrfPLkSUlS7dq1JUmZmZm6cOGCUxuaNm2qBg0aOLWhZcuWCg8PN8skJCQoLy9PO3furMTaX3Hp0iUtWrRIZ86cUVxcnO3akJiYqC5dujjVV7LP/8W+fftUr149NWrUSE8++aSys7NtVX/YmzdkR2nxWvtFReVtRkaGOnTooICAALNMQkKC9u7dq59++qmSWlN+69atU926ddWkSRMNGTJEP/zwg7nNG/vBVccuGRkZ12RxQkKC172XwH7ZcfXffIH33ntPYWFhatGihZKTk/Xzzz+b29z5vu8teXX+/HktWLBA/fr1k8PhMNd7ar9fzRuz8uTJk3I4HKpVq5bT+ldffVV16tTRHXfcoddee83pdtLurL+v5bMvsFt+2OUcld3OS9ntHJQdzznZ7Vjio48+0p133qmePXuqbt26uuOOO/TWW2+Z2+3yWoRr2C07KpKrX8veOIavzGN4b+m/yjjm9pa+gn3YPTvsdixXVt543qUo3nJuw9uvKbjq/LGntA8ls2t22G28bLdzWIXZ7XxWYXY8t1XAzsdFnO/yfnbNjspg59eup/CV8ZIrectYzFNUcXcFUHYnTpzQpUuXnN5YJSk8PFx79uxxU62sycnJkaQi21CwLScnR3Xr1nXaXqVKFdWuXdssU1kuX76s4cOH6+6771aLFi3M+gUEBFzzYZ2r21BUGwu2VZbt27crLi5O586dU40aNfTBBx+oefPmysrKsk0bFi1apK1bt+rLL7+8Zpsd/i9iY2M1b948NWnSREeOHNHLL7+se++9Vzt27LBF/WF/3pAdpcFrzVlF5W1OTo6io6Ov2UfBthtuuMEl9a9InTt3Vvfu3RUdHa0DBw7oxRdf1EMPPaSMjAz5+/t7XT+48tiluDJ5eXk6e/asgoODXdEkuIGdsqOov3lJeuKJJxQVFaV69erp66+/1ujRo7V3714tXbpUkvve970pr5YtW6bc3Fw988wz5jpP7feieFtWnjt3TqNHj1avXr0UEhJirv/jH/+otm3bqnbt2tqwYYOSk5N15MgRTZkyxa3197V89hV2yg/JHueo7HReyo7noOx4zsmOxxLffPONZs+eraSkJL344ov68ssv9cc//lEBAQHq06ePLV6LcB27ZUdFqYzXsjeO4SvzGL64/rPTe05lHXN7Q1/BXuycHXY8lisrbzvvUhRvObfh7dcUXHn+2BPah9Kxa3bYabxsp3NYhdnxfFZhdjy3VcDux0Wc7/J+ds0OV7P7a9dT+MJ4yZW8ZSzmSZhYAliQmJioHTt26PPPP3d3VcqkSZMmysrK0smTJ/XPf/5Tffr00fr1691drVI7dOiQhg0bprS0NAUFBbm7OmXy0EMPmT+3atVKsbGxioqK0uLFizmZBFQgXmsozuOPP27+3LJlS7Vq1Uq33HKL1q1bp06dOrmxZq5h92MXwKri/uYHDRpk/tyyZUtFRkaqU6dOOnDggG655ZbKrqbJm/LqnXfe0UMPPaR69eqZ6zy1373dhQsX9Oijj8owDM2ePdtpW1JSkvlzq1atFBAQoD/84Q9KSUlRYGBgZVfV5Gv5DJSVnY7t7HYOyq7nnOx4LHH58mXdeeed+vOf/yxJuuOOO7Rjxw6lpqaqT58+bq4d4B52fC3DfjjmBjwP7//exVveZ+007iwLu50/BuzKru8ldjufVZhdz20VsPtxEee74Kvs/tqFd/CWsZgn8XN3BVB2YWFh8vf319GjR53WHz16VBEREW6qlTUF9bxeGyIiInTs2DGn7RcvXtSPP/5Yqe0cOnSoli9frrVr1+rmm28210dEROj8+fPKzc11Kn91G4pqY8G2yhIQEKBbb71VMTExSklJUevWrTV9+nTbtCEzM1PHjh1T27ZtVaVKFVWpUkXr16/XG2+8oSpVqig8PNwW7SisVq1auu2227R//37b/D/A3rwhO8rC119rFZW33tYvktSoUSOFhYVp//79kryrH1x97FJcmZCQEE4SeBm7ZEdxf/NFiY2NlSSn174nvK7tmlffffedVq9erQEDBly3nKf2e+Hns3tWFkwq+e6775SWluZ0t5KixMbG6uLFi/r222/NOnrC/4k357MvsUt+FPD0c1R2Oy9lt3NQ3nLOyQ7HEpGRkWrevLnTumbNmik7O9vpeT31tQjXslt2uIorXsveOIavzGP44srY+e/SVcfc3thX8GzelB12OJYrK28572KFHc9tePs1BVefP3Z3+1B6ds0Ou4yX7XYOqzC7nc8qzFvObRWw23ER57u8n12zo7LZ7bXrKXxxvORKdhyLeRomlthYQECAYmJilJ6ebq67fPmy0tPTFRcX58aalV50dLQiIiKc2pCXl6dNmzaZbYj7/9i797Cqyvz//68NykkFNRSwPFCpeD5QEpVmEyOaNZqOqZmnTEeDRqO07GNq2mRjHpssxxqlxhzTvmamDoWnrEQdUUpTSY2iRvFQIWIIKvfvj37scScoSw77wPNxXfsK1rr32u91J/u17rXXvVd0tLKzs5Wammpvs2nTJhUWFtoH9BXJGKP4+Hi9//772rRp02W3PIqMjFT16tUd9iE9PV2ZmZkO+7B3716HN6iii3x+e2BZmQoLC5Wfn+82+3DPPfdo7969SktLsz9uueUWDRo0yP6zO+zHpXJzc3XkyBGFhYW5zf8HuDdPyI5rUdX/1sorb6Ojo7V161adP3/e3iY5OVnNmzd329v+/fDDD/rxxx8VFhYmyTP6obKOXaKjox22UdTGk99LqipXz46r/ZsvTlpamiQ5/O27wvu+u+bVkiVLVL9+ffXs2fOK7Vy13yXPyMqiSSWHDh3Shg0bdN111131OWlpafLy8rLf/tdVMs4T87kqcvX8+C1XPUflKeelXP0clKecc3KHY4k77rhD6enpDsu+/vprNW7cWJLr/i2icrhbdlSUivhb9sQxfGUew3ti/1XUMbcn9hVcmydlhzscy10rTzjvYpU7ndvw9M8UKuv8MRnoPtw1O1x9vOwp57Au5ernsy7lKee2irjbcRHnuzyfu2ZHZXO3v11XURXHSxXJncZiLsvArS1fvtz4+vqaxMREs3//fjNq1ChTu3Ztk5WV5ezS7M6cOWP27Nlj9uzZYySZOXPmmD179pjvvvvOGGPMSy+9ZGrXrm0++OAD8+WXX5pevXqZ8PBwk5eXZ99G9+7dTYcOHcyOHTvMZ599Zpo2bWoGDhxYKfWPGTPGBAUFmS1btphjx47ZH7/88ou9zejRo02jRo3Mpk2bzK5du0x0dLSJjo62r79w4YJp3bq16datm0lLSzNJSUmmXr16ZuLEiZWyD8YY88wzz5hPPvnEZGRkmC+//NI888wzxmazmY8//tht9qE4d911lxk7dqz9d1ffjyeffNJs2bLFZGRkmM8//9zExMSY4OBgc+LECbeoH57BHbKjrKri31pl5G12drYJCQkxgwcPNvv27TPLly83AQEB5u9//3ul729JrtQPZ86cMU899ZRJSUkxGRkZZsOGDaZjx46madOm5ty5c/ZtuHs/VNaxyzfffGMCAgLM+PHjzYEDB8yCBQuMt7e3SUpKqtT9ReVw5ey42r/5w4cPm2nTppldu3aZjIwM88EHH5gbb7zRdOnSxb4NZ73ve0JeXbx40TRq1Mg8/fTTDstdsd/dPSuvVH9BQYH5wx/+YG644QaTlpbm8LeQn59vjDFm27ZtZu7cuSYtLc0cOXLELF261NSrV88MGTKkwusnn6suV8sPdzxH5Y7npTzlHJQ7nHNyx2OJnTt3mmrVqpm//OUv5tChQ+add94xAQEBZunSpfY2rvi3iMrjatlRGSrjb9ldx/Cucgz/+eefm2rVqplZs2aZAwcOmClTppjq1aubvXv3Vl5nXIWrHHO7Q1/B87hrdrjjsdyVuMp7tjP2z93PbXj6ZwqVdf7YXY+3qipXzQ53PHdVxB3PYV3KU85nXcodzm0VcffjIs53VQ2umh3O5O5/u5XJ08dLFcmTx2KuioklHuBvf/ubadSokfHx8TGdOnUy27dvd3ZJDjZv3mwkXfYYOnSoMcaYwsJC89xzz5mQkBDj6+tr7rnnHpOenu6wjR9//NEMHDjQ1KxZ0wQGBprhw4ebM2fOVEr9xdUuySxZssTeJi8vzzz22GOmTp06JiAgwDzwwAPm2LFjDtv59ttvTY8ePYy/v78JDg42Tz75pDl//nyl7IMxxjzyyCOmcePGxsfHx9SrV8/cc8899gGQu+xDcX47EHL1/ejfv78JCwszPj4+5vrrrzf9+/c3hw8fdpv64TlcPTvKqir+rVVW3n7xxRfmzjvvNL6+vub66683L730UmXtYqlcqR9++eUX061bN1OvXj1TvXp107hxYzNy5MjLBvru3g+VeeyyefNm0759e+Pj42NuvPFGh9eA53HV7Ljav/nMzEzTpUsXU7duXePr62tuvvlmM378eHP69GmH7Tjjfd8T8uqjjz4yki7LFFfsd3fPyivVn5GRUeLfwubNm40xxqSmppqoqCgTFBRk/Pz8TIsWLcyLL77ocFKtouonn6s2V8oPdzxH5Y7npTzlHJQ7nHNy12OJDz/80LRu3dr4+vqaiIgIs2jRIof1rvi3iMrlStlRGSrrb9kdx/CudAy/YsUK06xZM+Pj42NatWpl1q1bV2H7fS1c6Zjb1fsKnskds8Ndj+VK4krv2ZW9f+5+bsPTP1OozPPH7ni8VZW5Yna447mrIu54DutSnnI+61LucG6riCccF3G+q2pwxexwJk/4260snj5eqkiePBZzVTZjjBEAAAAAAAAAAAAAAAAAAAAAAACqHC9nFwAAAAAAAAAAAAAAAAAAAAAAAADnYGIJAAAAAAAAAAAAAAAAAAAAAABAFcXEEgAAAAAAAAAAAAAAAAAAAAAAgCqKiSUAAAAAAAAAAAAAAAAAAAAAAABVFBNLAAAAAAAAAAAAAAAAAAAAAAAAqigmlgAAAAAAAAAAAAAAAAAAAAAAAFRRTCwBAAAAAAAAAAAAAAAAAAAAAACoophYAgAAAAAALpOYmKjatWuX6za//fZb2Ww2paWllet2mzRponnz5pXrNgEAAAAAAAAAAAAAAKoKJpYAbiArK0uPP/64brzxRvn6+qphw4a6//77tXHjRkm/XkRls9lks9nk7++vJk2a6MEHH9SmTZsctvPjjz+qe/fuatCggX078fHxysnJsbf57LPPdMcdd+i6666Tv7+/IiIiNHfuXIftTJ061f56RY+IiIiK7wgAwDWrzCw5duyYHnroITVr1kxeXl4aN25cZe4qAFRZw4YNs7+X+/j46Oabb9a0adN04cIFZ5dW4f7zn/9o1KhRzi4DAKqc8hpnSNKf//xnRUZGytfXV+3bt7/i6x4+fFi1atUqdgJkdna24uLiFBYWJl9fXzVr1kzr168vj90FAFSSYcOGqXfv3qVu37VrV9lsNr300kuXrevZs6dsNpumTp1afgUCAFxOeY5Nfvs5uM1m0/Llyyt7lwAAZVDZ56xWrFih9u3bKyAgQI0bN9bLL7/ssH7Lli3F5ktWVla57zsAoHxU5nVWq1at0u9//3vVq1dPgYGBio6O1kcffVSp+wsUYWIJ4OK+/fZbRUZGatOmTXr55Ze1d+9eJSUl6e6771ZcXJy93bRp03Ts2DGlp6fr7bffVu3atRUTE6O//OUv9jZeXl7q1auX1qxZo6+//lqJiYnasGGDRo8ebW9To0YNxcfHa+vWrTpw4IAmTZqkSZMmadGiRQ51tWrVSseOHbM/Pvvss4rvDADANansLMnPz1e9evU0adIktWvXrlL3FQCquu7du+vYsWM6dOiQnnzySU2dOvWyDzA8Ub169RQQEODsMgCgSinPcUaRRx55RP3797/i654/f14DBw5U586dL1tXUFCg3//+9/r222/13nvvKT09XW+88Yauv/76su8wAMClNWzYUImJiQ7L/vvf/2rjxo0KCwtzTlEAgEpREWOTJUuWOHwWbmXCIwDAuSr7nNW///1vDRo0SKNHj9a+ffv02muvae7cuXr11Vcva5uenu6QL/Xr1y+/HQcAlJvKvs5q69at+v3vf6/169crNTVVd999t+6//37t2bOnUvcbkKRqzi4AwJU99thjstls2rlzp2rUqGFf3qpVKz3yyCP232vVqqXQ0FBJUqNGjdSlSxeFhYVp8uTJ+uMf/6jmzZurTp06GjNmjP05jRs31mOPPeZwoVmHDh3UoUMH++9NmjTRqlWr9Omnnzp8A3C1atXsrwcAcG2VnSVNmjTR/PnzJUmLFy+u6N0DAFzC19fX/l4+ZswYvf/++1qzZo1Gjx6tsWPH6sMPP1R+fr7uuusuvfLKK2ratKn9uYmJiZo8ebJOnTql2NhY3XnnnZdt//XXX9esWbP0/fffKzw8XJMmTdLgwYPt6202m1577TWtWbNGW7ZsUVhYmGbOnKk//vGPxdZ78eJFjRo1Sps2bVJWVpYaNWqkxx57TGPHjrW3GTZsmLKzs3XnnXdq9uzZKigo0IABAzRv3jxVr15d0q/ZM27cOPtdsmw2m9544w2tW7dOH330ka6//nrNnj1bf/jDH8rcxwCAX5XnOEOSXnnlFUnSyZMn9eWXX5b4upMmTVJERITuuecebdu2zWHd4sWL9dNPP2nbtm0OGQEAcF9nzpzR6NGjtXr1agUGBmrChAn64IMP1L59e82bN8/e7r777tOKFSv0+eef64477pAkvfXWW+rWrZsyMzOdVD0AoDKU99hEkmrXrs1n4QDgpir7nNU///lP9e7d236B8I033qiJEyfqr3/9q+Li4mSz2ext69evX+wdeAEArqWyr7O69ByXJL344ov64IMP9OGHHzpcywtUBu5YAriwn376SUlJSYqLi3MIqCJXG2yMHTtWxhh98MEHxa4/evSoVq1apbvuuqvEbezZs0fbtm27rM2hQ4fUoEED3XjjjRo0aBAfzACAi3KFLAEAOI+/v78KCgo0bNgw7dq1S2vWrFFKSoqMMbr33nt1/vx5SdKOHTs0YsQIxcfHKy0tTXfffbdeeOEFh229//77Gjt2rJ588knt27dPf/rTnzR8+HBt3rzZod1zzz2nvn376osvvtCgQYM0YMAAHThwoNj6CgsLdcMNN2jlypXav3+/Jk+erGeffVYrVqxwaLd582YdOXJEmzdv1ltvvaXExMTLvo34t55//nk9+OCD+vLLL3Xvvfdq0KBB+umnnyz2IACgOBU9zijJpk2btHLlSi1YsKDY9WvWrFF0dLTi4uIUEhKi1q1b68UXX9TFixctvQ4AwHUkJCTo888/15o1a5ScnKxPP/1Uu3fvvqydj4+PBg0apCVLltiXJSYmOnzYDwDwPBU1NomLi1NwcLA6deqkxYsXyxhTnmUDACqIM85Z5efny8/Pz2GZv7+/fvjhB3333XcOy9u3b6+wsDD9/ve/1+eff17q1wAAVB5XuM6qsLBQZ86cUd26dS3VDpQHJpYALuzw4cMyxigiIuKanl+3bl3Vr19f3377rcPygQMHKiAgQNdff70CAwP15ptvXvbcG264Qb6+vrrlllsUFxenRx991L4uKipKiYmJSkpK0uuvv66MjAx17txZZ86cuaY6AQAVx5lZAgBwHmOMNmzYoI8++kiNGjXSmjVr9Oabb6pz585q166d3nnnHf33v//V6tWrJUnz589X9+7dNWHCBDVr1kx//vOfFRsb67DNWbNmadiwYXrsscfUrFkzJSQkqE+fPpo1a5ZDu379+unRRx9Vs2bNNH36dN1yyy3629/+Vmyd1atX1/PPP69bbrlF4eHhGjRokIYPH37ZxJI6dero1VdfVUREhO677z717NlTGzduvGIfDBs2TAMHDtTNN9+sF198Ubm5udq5c6fFngQAFKeixhlX8uOPP2rYsGFKTExUYGBgsW2++eYbvffee7p48aLWr1+v5557TrNnz75ssiQAwD2cOXNGb731lmbNmqV77rlHrVu31pIlS0qcMPjII49oxYoVOnv2rLZu3arTp0/rvvvuq+SqAQCVqSLGJtOmTdOKFSuUnJysvn376rHHHivx3BYAwLU445xVbGysVq1apY0bN6qwsFBff/21Zs+eLUk6duyYJCksLEwLFy7U//t//0//7//9PzVs2FBdu3YtdtI8AMC5XOE6q1mzZik3N1cPPvjgNdUAlAUTSwAXVh7ffGKMcbitoiTNnTtXu3fv1gcffKAjR44oISHhsud9+umn2rVrlxYuXKh58+bpX//6l31djx491K9fP7Vt21axsbFav369srOzL7v4CwDgfM7MEgBA5Vu7dq1q1qwpPz8/9ejRQ/3799ewYcNUrVo1RUVF2dtdd911at68uf1OIgcOHHBYL0nR0dEOvx84cEB33HGHw7I77rjjsruR/PZ50dHRJd6xRJIWLFigyMhI1atXTzVr1tSiRYsuuyNiq1at5O3tbf89LCxMJ06cKHGbktS2bVv7zzVq1FBgYOBVnwMAKJ2KGmdcyciRI/XQQw+pS5cuJbYpLCxU/fr1tWjRIkVGRqp///76v//7Py1cuLDM9QIAKt8333yj8+fPq1OnTvZlQUFBat68ebHt27Vrp6ZNm+q9997T4sWLNXjwYFWrVq2yygUAOEFFjE2ee+453XHHHerQoYOefvppTZgwQS+//HKZXwcAUPGcdc4qPj5e9913n3x8fHTbbbdpwIABkiQvr18vzWzevLn+9Kc/KTIyUrfffrsWL16s22+/XXPnzi1zvQCA8uXs66yWLVum559/XitWrFD9+vXLXAtgFWdTARfWtGlT2Ww2HTx48Jqe/+OPP+rkyZMKDw93WB4aGqrQ0FBFRESobt266ty5s5577jmFhYXZ2xQ9p02bNjp+/LimTp2qgQMHFvs6tWvXVrNmzXT48OFrqhMAUHGcmSUAgMp399136/XXX5ePj48aNGigatWqac2aNc4uq0TLly/XU089pdmzZys6Olq1atXSyy+/rB07dji0q169usPvNptNhYWFV9z2tTwHAFA6FTXOuJJNmzZpzZo19jtlGWNUWFioatWqadGiRXrkkUcUFham6tWrO0xGbNGihbKyslRQUCAfH59rqhcA4D4eeeQRLViwQPv37+eOhQBQBVTG2CQqKkrTp09Xfn6+fH19r7VUAEAlcMY5K5vNpr/+9a968cUXlZWVpXr16tnvuH7jjTeW+LxOnTrps88+u6Y6AQAVx5nXWS1fvlyPPvqoVq5cqZiYmDLtB3CtuGMJ4MLq1q2r2NhYLViwQGfPnr1sfXZ29hWfP3/+fHl5eal3794ltim6sCo/P/+Kba60Pjc3V0eOHOFiYgBwQa6SJQCAylGjRg3dfPPNatSokf2beVu0aKELFy44TNb48ccflZ6erpYtW9rb/HYyx/bt2x1+b9GihT7//HOHZZ9//rl9GyU9b/v27WrRokWx9X7++ee6/fbb9dhjj6lDhw66+eabdeTIEQt7DABwhsoYZ/xWSkqK0tLS7I9p06apVq1aSktL0wMPPCDp1ztpHT582GEi4ddff62wsDAmlQCAG7rxxhtVvXp1/ec//7EvO336tL7++usSn/PQQw9p7969at269WVjFQCA56mMsUlaWprq1KnDpBIAcAPOOGdVxNvbW9dff718fHz0r3/9S9HR0apXr16J7dPS0rjOCgBckLOus/rXv/6l4cOH61//+pd69ux5TbUD5YE7lgAubsGCBbrjjjvUqVMnTZs2TW3bttWFCxeUnJys119/XQcOHJAknTlzRllZWTp//rwyMjK0dOlSvfnmm5oxY4ZuvvlmSdL69et1/Phx3XrrrapZs6a++uorjR8/XnfccYeaNGlif71GjRopIiJCkrR161bNmjVLf/7zn+01PfXUU7r//vvVuHFjHT16VFOmTJG3t3eJdzQBADhXZWeJ9OuJMOnXyYcnT55UWlqafHx8+EAfAJygadOm6tWrl0aOHKm///3vqlWrlp555hldf/316tWrlyTpz3/+s+644w7NmjVLvXr10kcffaSkpCSH7YwfP14PPvigOnTooJiYGH344YdatWqVNmzY4NBu5cqVuuWWW3TnnXfqnXfe0c6dO/WPf/yjxNrefvttffTRRwoPD9c///lP/ec//7H0bWAAAOcoz3GGJB0+fFi5ubnKyspSXl6efUzRsmVL+fj4XDZJcdeuXfLy8lLr1q3ty8aMGaNXX31VY8eO1eOPP65Dhw7pxRdfdDivBQBwH7Vq1dLQoUM1fvx41a1bV/Xr19eUKVPk5eUlm81W7HPq1KmjY8eOXXYHQwCA5yrPscmHH36o48eP67bbbpOfn5+Sk5P14osv6qmnnnLmLgIALKjsc1anTp3Se++9p65du+rcuXNasmSJVq5cqU8++cS+jXnz5ik8PFytWrXSuXPn9Oabb2rTpk36+OOPK7VvAAClU9nXWS1btkxDhw7V/PnzFRUVpaysLEmSv7+/goKCnNIHqMIMAJd39OhRExcXZxo3bmx8fHzM9ddfb/7whz+YzZs3G2OMady4sZFkJBkfHx/TqFEj8+CDD5pNmzY5bGfTpk0mOjraBAUFGT8/P9O0aVPz9NNPm59//tne5pVXXjGtWrUyAQEBJjAw0HTo0MG89tpr5uLFi/Y2/fv3N2FhYfZa+vfvbw4fPlwZXQEAuEaVmSXGGPu2Ln00bty4cnYWAKqooUOHml69ehW77qeffjKDBw82QUFBxt/f38TGxpqvv/7aoc0//vEPc8MNNxh/f39z//33m1mzZpmgoCCHNq+99pq58cYbTfXq1U2zZs3M22+/7bBeklmwYIH5/e9/b3x9fU2TJk3Mu+++a1+fkZFhJJk9e/YYY4w5d+6cGTZsmAkKCjK1a9c2Y8aMMc8884xp167dFfdr7Nix5q677rL/3rhxYzN37lyHOt5//32H5wQFBZklS5YU2z8AgGtTXuMMY4y56667ih1HZGRkFPvaS5YsuSynjDFm27ZtJioqyvj6+pobb7zR/OUvfzEXLlwox70GAFS0S8cAOTk55qGHHjIBAQEmNDTUzJkzx3Tq1Mk888wz9vZ33XWXGTt2bInba9eunZkyZUrFFg0AcKryGpv8+9//Nu3btzc1a9Y0NWrUMO3atTMLFy50+KwcAOD6KvOc1cmTJ81tt91matSoYQICAsw999xjtm/f7rCNv/71r+amm24yfn5+pm7duqZr167FvhYAwHVU5nVWJWXN0KFDK2+Hgf+fzRhjKnjuCgAAAAAAqAJsNpvef//9a7pNPAAAAABczdmzZ3X99ddr9uzZGjFihLPLAQAAAAAAAACPUc3ZBQAAAAAAAAAAAADAb+3Zs0cHDx5Up06ddPr0aU2bNk2S1KtXLydXBgAAAAAAAACehYklAAAAAAAAAAAAAFzSrFmzlJ6eLh8fH0VGRurTTz9VcHCws8sCAAAAAAAAAI9iM8YYZxcBAAAAAAAAAAAAAAAAAAAAAACAyufl7AIAAAAAAAAAAAAAAAAAAAAAAADgHEwsAQAAAAAAAAAAAAAAAAAAAAAAqKKYWAIAAAAAAAAAAAAAAAAAAAAAAFBFMbEEAAAAAAAAAAAAAAAAAAAAAACgimJiCQAAAAAAAAAAAAAAAAAAAAAAQBXFxBIAAAAAAAAAAAAAAAAAAAAAAIAqioklAAAAAAAAAAAAAAAAAAAAAAAAVRQTSwAAAAAAAAAAAAAAAAAAAAAAAKqoas4uAI4KCwt19OhR1apVSzabzdnlAMA1McbozJkzatCggby8mMNY0cgOAJ6A7KhcZAcAT0B2VC6yA4AnIDsqF9kBwBOQHZWL7ADgCciOykV2APAEZEflIjsAeIKKyg4mlriYo0ePqmHDhs4uAwDKxffff68bbrjB2WV4PLIDgCchOyoH2QHAk5AdlYPsAOBJyI7KQXYA8CRkR+UgOwB4ErKjcpAdADwJ2VE5yA4AnqS8s4OJJS6mVq1akn79Hx0YGOjkagDg2uTk5Khhw4b29zRULLIDgCcgOyoX2QHAE5AdlYvsAOAJyI7KRXYA8ARkR+UiOwB4ArKjcpEdADwB2VG5yA4AnqCisoOJJS6m6NZagYGBhBYAt8ftAisH2QHAk5AdlYPsAOBJyI7KQXYA8CRkR+UgOwB4ErKjcpAdADwJ2VE5yA4AnoTsqBxkBwBPUt7Z4VWuWwMAAAAAAAAAAAAAAAAAAAAAAIDb4I4lHiQzM1OnTp2SJAUHB6tRo0ZOrggA4OrIDgCAVWQHAMAqsgMAYBXZAQCwiuwAAJQFOQIAsIrsAOCJmFjiITIzMxUREaG8vDxJkr+/vw4ePEhYAQBKRHYAAKwiOwAAVpEdAACryA4AgFVkBwCgLErKEUlcMAwAKBZjEACeysvZBaB8nDp1Snl5eerTp4/69OmjvLw8++AGAIDikB0AAKvIDgCAVWQHAMAqsgMAYBXZAQAoi+JyZO/evYqIiFBkZKQiIyMVERGhzMxMZ5cKAHARjEEAeComlniY4OBgBQcHO7sMAIAbITsAAFaRHQAAq8gOAIBVZAcAwCqyAwBQFpfmSHZ2NhcMA3BLM2bM0K233qpatWqpfv366t27t9LT0x3anDt3TnFxcbruuutUs2ZN9e3bV8ePH3dok5mZqZ49eyogIED169fX+PHjdeHCBYc2W7ZsUceOHeXr66ubb75ZiYmJl9WzYMECNWnSRH5+foqKitLOnTuvug8rV65URESE/Pz81KZNG61fv95hvTFGkydPVlhYmPz9/RUTE6NDhw6VsofKF2MQAJ6GiSUAAAAAAAAAAAAAAAAAAFyCC4YBuJtPPvlEcXFx2r59u5KTk3X+/Hl169ZNZ8+etbd54okn9OGHH2rlypX65JNPdPToUfXp08e+/uLFi+rZs6cKCgq0bds2vfXWW0pMTNTkyZPtbTIyMtSzZ0/dfffdSktL07hx4/Too4/qo48+srd59913lZCQoClTpmj37t1q166dYmNjdeLEiRLr37ZtmwYOHKgRI0Zoz5496t27t3r37q19+/bZ28ycOVOvvPKKFi5cqB07dqhGjRqKjY3VuXPnyqsbAaDKYmIJAAAAAAAAAAAAAAAAAAAA4MaSkpI0bNgwtWrVSu3atVNiYqIyMzOVmpoqSTp9+rT+8Y9/aM6cOfrd736nyMhILVmyRNu2bdP27dslSR9//LH279+vpUuXqn379urRo4emT5+uBQsWqKCgQJK0cOFChYeHa/bs2WrRooXi4+P1xz/+UXPnzrXXMmfOHI0cOVLDhw9Xy5YttXDhQgUEBGjx4sUl1j9//nx1795d48ePV4sWLTR9+nR17NhRr776qqRf71Yyb948TZo0Sb169VLbtm319ttv6+jRo1q9enUF9SoAVB1MLAEAAAAAAAAAAAAAAAAAAAA8yOnTpyVJdevWlSSlpqbq/PnziomJsbeJiIhQo0aNlJKSIklKSUlRmzZtFBISYm8TGxurnJwcffXVV/Y2l26jqE3RNgoKCpSamurQxsvLSzExMfY2xbnadjMyMpSVleXQJigoSFFRUSVuNz8/Xzk5OQ4PAEDxmFgCAAAAAAAAAAAAAAAAAAAAeIjCwkKNGzdOd9xxh1q3bi1JysrKko+Pj2rXru3QNiQkRFlZWfY2l04qKVpftO5KbXJycpSXl6dTp07p4sWLxbYp2kZxStrupa97aT2l2e6MGTMUFBRkfzRs2LDE1weAqo6JJQAAAAAAAAAAAAAAAAAAAICHiIuL0759+7R8+XJnl+JUEydO1OnTp+2P77//3tklAYDLYmIJAAAAAAAAAAAAAAAAAAAA4AHi4+O1du1abd68WTfccIN9eWhoqAoKCpSdne3Q/vjx4woNDbW3OX78+GXri9ZdqU1gYKD8/f0VHBwsb2/vYtsUbaM4JW330te9tJ7SbNfX11eBgYEODwBA8ZhYAgAAAAAAAAAAAAAAAAAAALgxY4zi4+P1/vvva9OmTQoPD3dYHxkZqerVq2vjxo32Zenp6crMzFR0dLQkKTo6Wnv37tWJEyfsbZKTkxUYGKiWLVva21y6jaI2Rdvw8fFRZGSkQ5vCwkJt3LjR3qY4V9tueHi4QkNDHdrk5ORox44dV9wuAKB0qjm7AAAAAAAAAAAAAAAAAAAAAADXLi4uTsuWLdMHH3ygWrVqKSsrS5IUFBQkf39/BQUFacSIEUpISFDdunUVGBioxx9/XNHR0brtttskSd26dVPLli01ePBgzZw5U1lZWZo0aZLi4uLk6+srSRo9erReffVVTZgwQY888og2bdqkFStWaN26dfZaEhISNHToUN1yyy3q1KmT5s2bp7Nnz2r48OH2NkOGDNH111+vGTNmSJLGjh2ru+66S7Nnz1bPnj21fPly7dq1S4sWLZIk2Ww2jRs3Ti+88IKaNm2q8PBwPffcc2rQoIF69+5dGV0MAB6NO5YAAAAAAAAAAAAAAFCBpk6dKpvN5vCIiIiwrz937pzi4uJ03XXXqWbNmurbt6+OHz/usI3MzEz17NlTAQEBql+/vsaPH68LFy44tNmyZYs6duwoX19f3XzzzUpMTLyslgULFqhJkyby8/NTVFSUdu7cedX6V65cqYiICPn5+alNmzZav369w3pjjCZPnqywsDD5+/srJiZGhw4dstBDAAAAAMrq9ddf1+nTp9W1a1eFhYXZH++++669zdy5c3Xfffepb9++6tKli0JDQ7Vq1Sr7em9vb61du1be3t6Kjo7Www8/rCFDhmjatGn2NuHh4Vq3bp2Sk5PVrl07zZ49W2+++aZiY2Ptbfr3769Zs2Zp8uTJat++vdLS0pSUlKSQkBB7m8zMTB07dsz+++23365ly5Zp0aJFateund577z2tXr1arVu3treZMGGCHn/8cY0aNUq33nqrcnNzlZSUJD8/v3LvTwCoarhjCQAAAAAAAAAAAAAAFaxVq1basGGD/fdq1f73cf0TTzyhdevWaeXKlQoKClJ8fLz69Omjzz//XJJ08eJF9ezZU6Ghodq2bZuOHTumIUOGqHr16nrxxRclSRkZGerZs6dGjx6td955Rxs3btSjjz6qsLAw+wVe7777rhISErRw4UJFRUVp3rx5io2NVXp6uurXr19s3du2bdPAgQM1Y8YM3XfffVq2bJl69+6t3bt32y/wmjlzpl555RW99dZb9m8Njo2N1f79+7nACwAAAKgkxpirtvHz89OCBQu0YMGCEts0btz4ssnkv9W1a1ft2bPnim3i4+MVHx9f4votW7Zctqxfv37q169fic+x2WyaNm2aw0QXAED5sDyx5PPPP9e3336rixcv2pcNGTKkXIsCAHgWsgMAYBXZAQCwiuwAAFhFdgAArCprdlSrVk2hoaGXLT99+rT+8Y9/aNmyZfrd734nSVqyZIlatGih7du367bbbtPHH3+s/fv3a8OGDQoJCVH79u01ffp0Pf3005o6dap8fHy0cOFChYeHa/bs2ZKkFi1a6LPPPtPcuXPtE0vmzJmjkSNHavjw4ZKkhQsXat26dVq8eLGeeeaZYuueP3++unfvrvHjx0uSpk+fruTkZL366qtauHChjDGaN2+eJk2apF69ekmS3n77bYWEhGj16tUaMGBAqfsIADwN4w4AgFVkBwDAWSxNLBk4cKCysrLUoUMHeXt7S/p19h8AACUhOwAAVpEdAACryA4AgFVkBwDAqvLIjkOHDqlBgwby8/NTdHS0ZsyYoUaNGik1NVXnz59XTEyMvW1ERIQaNWqklJQU3XbbbUpJSVGbNm0UEhJibxMbG6sxY8boq6++UocOHZSSkuKwjaI248aNkyQVFBQoNTVVEydOtK/38vJSTEyMUlJSSqw7JSVFCQkJl2139erVkn69U0pWVpbDawcFBSkqKkopKSklTizJz89Xfn6+/fecnJwSawAAd8S4AwBgFdkBAHAmSxNLvvjiC+3fv7+iagEAeCCyAwBgFdkBALCK7AAAWEV2AACsKmt2REVFKTExUc2bN9exY8f0/PPPq3Pnztq3b5+ysrLk4+Oj2rVrOzwnJCREWVlZkqSsrCyHSSVF64vWXalNTk6O8vLy9PPPP+vixYvFtjl48GCJtZe03Utf99J6imtTnBkzZuj5558vcT0AuDvGHQAAq8gOAIAzeVlp3KlTJ6Wnp1dULQAAD0R2AACsIjsAAFaRHQAAq8gOAIBVZc2OHj16qF+/fmrbtq1iY2O1fv16ZWdna8WKFeVYpXuZOHGiTp8+bX98//33zi4JAMoV4w4AgFVkBwDAmSzdsSQtLU3t2rVT8+bN5evrK2OMbDabdu7cWVH1AQDcHNkBALCK7AAAWEV2AACsIjsAAFaVd3bUrl1bzZo10+HDh/X73/9eBQUFys7OdrhryfHjxxUaGipJCg0Nvey1jh8/bl9X9N+iZZe2CQwMlL+/v7y9veXt7V1sm6JtFKek7V76ukXLwsLCHNq0b9++xO36+vrK19e3xPUA4O4YdwAArCI7AADOZGliyQcffFBRdQAAPBTZAQCwiuwAAFhFdgAArCI7AABWlXd25Obm6siRIxo8eLAiIyNVvXp1bdy4UX379pUkpaenKzMzU9HR0ZKk6Oho/eUvf9GJEydUv359SVJycrICAwPVsmVLe5v169c7vE5ycrJ9Gz4+PoqMjNTGjRvVu3dvSVJhYaE2btyo+Pj4EmuNjo7Wxo0bNW7cuGK3Gx4ertDQUG3cuNE+kSQnJ0c7duzQmDFjytZRAODGGHcAAKwiO1xbZmamTp06pQMHDji7FACoEJYmljRu3Fh79uzRZ599Jknq3LnzFb9hBAAAsgMAYBXZAQCwiuwAAFhFdgAArCprdjz11FO6//771bhxYx09elRTpkyRt7e3Bg4cqKCgII0YMUIJCQmqW7euAgMD9fjjjys6Olq33XabJKlbt25q2bKlBg8erJkzZyorK0uTJk1SXFyc/a4fo0eP1quvvqoJEybokUce0aZNm7RixQqtW7fOXkdCQoKGDh2qW265RZ06ddK8efN09uxZDR8+3N5myJAhuv766zVjxgxJ0tixY3XXXXdp9uzZ6tmzp5YvX65du3Zp0aJFkiSbzaZx48bphRdeUNOmTRUeHq7nnntODRo0sE9gAYCqiHEHAMAqssN1ZWZmKiIiQnl5ec4uBQAqjJeVxrNmzdKjjz6q3Nxc5ebmauTIkZozZ05F1QYA8ABkBwDAKrIDAGAV2QEAsIrsAABYVdbs+OGHHzRw4EA1b95cDz74oK677jpt375d9erVkyTNnTtX9913n/r27asuXbooNDRUq1atsj/f29tba9eulbe3t6Kjo/Xwww9ryJAhmjZtmr1NeHi41q1bp+TkZLVr106zZ8/Wm2++qdjYWHub/v37a9asWZo8ebLat2+vtLQ0JSUlKSQkxN4mMzNTx44ds/9+++23a9myZVq0aJHatWun9957T6tXr1br1q3tbSZMmKDHH39co0aN0q233qrc3FwlJSXJz8/PWkcDgAdh3AEAsIrscF2nTp1SXl6e+vTpo7vvvtvZ5QBAhbA0seTtt9/Wtm3bNHHiRE2cOFGfffaZEhMTS/38qVOnymazOTwiIiLs68+dO6e4uDhdd911qlmzpvr27avjx487bCMzM1M9e/ZUQECA6tevr/Hjx+vChQsObbZs2aKOHTvK19dXN998c7E1LliwQE2aNJGfn5+ioqK0c+fOq9a/cuVKRUREyM/PT23atLnsNsLGGE2ePFlhYWHy9/dXTEyMDh06VOr+AQBPVNbsAABUPWQHAMAqsgMAYBXZAQCwqqzZsXz5ch09elT5+fn64YcftHz5ct1000329X5+flqwYIF++uknnT17VqtWrVJoaKjDNho3bqz169frl19+0cmTJzVr1ixVq1bNoU3Xrl21Z88e5efn68iRIxo2bNhltcTHx+u7775Tfn6+duzYoaioKIf1W7ZsuWzf+vXrp/T0dOXn52vfvn269957HdbbbDZNmzZNWVlZOnfunDZs2KBmzZqVun8AwBOVNTu2bt2q+++/Xw0aNJDNZtPq1asd1pfmOqWffvpJgwYNUmBgoGrXrq0RI0YoNzfXoc2XX36pzp07y8/PTw0bNtTMmTMvq+Vq10wVp6Ku3wIAT8Y5K9cXHBysOnXqOLsMAKgQliaWSL9O/iju59Jq1aqVjh07Zn8U3bJLkp544gl9+OGHWrlypT755BMdPXpUffr0sa+/ePGievbsqYKCAm3btk1vvfWWEhMTNXnyZHubjIwM9ezZU3fffbfS0tI0btw4Pfroo/roo4/sbd59910lJCRoypQp2r17t9q1a6fY2FidOHGixLq3bdumgQMHasSIEdqzZ4969+6t3r17a9++ffY2M2fO1CuvvKKFCxdqx44dqlGjhmJjY6+pnwDAk5Q1OwAAVQ/ZAQCwiuwAAFhFdgAArCI7AABWlSU7zp49q3bt2mnBggXFri/NdUqDBg3SV199peTkZK1du1Zbt27VqFGj7OtzcnLUrVs3NW7cWKmpqXr55Zc1depULVq0yN6mNNdM/VZFXb8FAFUB4w4AgLNYmlgyfvx4RUZGavTo0frTn/6kW265RRMmTLD0gtWqVVNoaKj9ERwcLEk6ffq0/vGPf2jOnDn63e9+p8jISC1ZskTbtm3T9u3bJUkff/yx9u/fr6VLl6p9+/bq0aOHpk+frgULFqigoECStHDhQoWHh2v27Nlq0aKF4uPj9cc//lFz58611zBnzhyNHDlSw4cPV8uWLbVw4UIFBARo8eLFJdY9f/58de/eXePHj1eLFi00ffp0dezYUa+++qqkX78FYN68eZo0aZJ69eqltm3b6u2339bRo0cv+8YAAKhKyiM7AABVC9kBALCK7AAAWFXW7OAO7QBQ9TDuAABYVdbs6NGjh1544QU98MADl60rzXVKBw4cUFJSkt58801FRUXpzjvv1N/+9jf7XbQk6Z133lFBQYEWL16sVq1aacCAAfrzn/+sOXPm2F/ratdMFaeirt8CAE/HuAMA4EyWJpYMHjxYW7duVY8ePXTvvfdq69atevjhhy294KFDh9SgQQPdeOONGjRokDIzMyVJqampOn/+vGJiYuxtIyIi1KhRI6WkpEiSUlJS1KZNG4WEhNjbxMbGKicnR1999ZW9zaXbKGpTtI2CggKlpqY6tPHy8lJMTIy9TXGutt2MjAxlZWU5tAkKClJUVNQVt5ufn6+cnByHBwB4kvLIDgBA1UJ2AACsIjsAAFaVR3Zwh3YAqFoYdwAArKrI7CjNdUopKSmqXbu2brnlFnubmJgYeXl5aceOHfY2Xbp0kY+Pj71NbGys0tPT9fPPP9vbXOmaqeJU1PVbXGcFwNMx7gAAOFOpJpZkZGRIkvbv36/s7Gw1bdpUTZs21c8//6z9+/eX+sWioqKUmJiopKQkvf7668rIyFDnzp115swZZWVlycfHR7Vr13Z4TkhIiLKysiRJWVlZDpNKitYXrbtSm5ycHOXl5enUqVO6ePFisW2KtlGckrZ76eteWk9ptztjxgwFBQXZHw0bNiyxLQC4o7JmBwCg6iE7AABWkR0AAKvKIzu4QzsAVC2MOwAAVlVkdpTmOqWsrCzVr1/fYX21atVUt27dcrkW61qusyrr9VtcZwXA0zHuAAA4U7XSNJoxY4YWLVqkuLi4y9bZbDZt2rSpVC/Wo0cP+89t27ZVVFSUGjdurBUrVsjf37+UJXuWiRMnKiEhwf57Tk4Ogx4AHqWs2QEAqHrIDgCAVWQHAMCq8siOoju0+/n5KTo6WjNmzFCjRo2ueof22267rcQ7tI8ZM0ZfffWVOnToUOI3/I4bN07S/77hd+LEifb1pb1D+6WfSxRtt2jSyNW++XjAgAHFbjc/P1/5+fn23/nmYACehnEHAMAqsqP8cZ0VAE9HdgAAnKlUE0sWLVokSVqxYoXq1avnsO7kyZPX/OK1a9dWs2bNdPjwYf3+979XQUGBsrOzHe5acvz4cYWGhkqSQkNDtXPnTodtHD9+3L6u6L9Fyy5tExgYKH9/f3l7e8vb27vYNkXbKE5J2730dYuWhYWFObRp3759idv19fWVr69viesBwN2Vd3YAADwf2QEAsIrsAABYVdbsKLpDe/PmzXXs2DE9//zz6ty5s/bt21dpd2j/+eefS/yG34MHD5ZYe0Xeof35558vcT0AuDvGHQAAqyoyO0pznVJoaKhOnDjh8LwLFy7op59+uup1Vpe+xtWumSqpvoq4fovrrAB4OsYdAABn8rLSODY2tlTLSis3N1dHjhxRWFiYIiMjVb16dW3cuNG+Pj09XZmZmYqOjpYkRUdHa+/evQ6DnuTkZAUGBqply5b2Npduo6hN0TZ8fHwUGRnp0KawsFAbN260tynO1bYbHh6u0NBQhzY5OTnasWPHFbcLAJ6uvLMDAOD5yA4AgFVkBwDAqrJmR48ePdSvXz+1bdtWsbGxWr9+vbKzs7VixYryLNOtTJw4UadPn7Y/vv/+e2eXBADlinEHAMCqisyO0lynFB0drezsbKWmptrbbNq0SYWFhYqKirK32bp1q86fP29vk5ycrObNm6tOnTr2Nle6Zqo4FXX9ljMdOHBAu3fvVmZmprNLAeDBGHcAAJypVBNLDh8+rHXr1iknJ0fr16+3P5YvX+5wW/Oreeqpp/TJJ5/o22+/1bZt2/TAAw/I29tbAwcOVFBQkEaMGKGEhARt3rxZqampGj58uKKjo3XbbbdJkrp166aWLVtq8ODB+uKLL/TRRx9p0qRJiouLs89GHz16tL755htNmDBBBw8e1GuvvaYVK1boiSeesNeRkJCgN954Q2+99ZYOHDigMWPG6OzZsxo+fLi9zZAhQxxuHz927FglJSVp9uzZOnjwoKZOnapdu3YpPj5e0q+3Gxs3bpxeeOEFrVmzRnv37tWQIUPUoEED9e7du9R9BACe5KOPPipzdkydOlU2m83hERERYV9/7tw5xcXF6brrrlPNmjXVt2/fy77VJDMzUz179lRAQIDq16+v8ePH68KFCw5ttmzZoo4dO8rX11c333yzEhMTL6tlwYIFatKkifz8/BQVFXXZXbSKs3LlSkVERMjPz09t2rTR+vXrHdYbYzR58mSFhYXJ399fMTExOnToUKn7BwA8DdlBdgCAVWQH2QEAVpVHdvzWpXdoDw0Ntd+h/VK/vQv6tX4rcNE3/AYHB1f4HdqtbNfX11eBgYEODwDwFBWRHQAAz1Ye2ZGbm6u0tDSlpaVJkjIyMpSWlqbMzMxSXafUokULde/eXSNHjtTOnTv1+eefKz4+XgMGDFCDBg0kSQ899JB8fHw0YsQIffXVV3r33Xc1f/58JSQk2Ou42jVT0q8TzYcMGWL/vbyu33IFubm5stlsevjhhxUZGamIiAgmlwCoEIw7AADOVq00jb766iutXr1aP//8s1auXGlfXqtWLb3xxhulfrEffvhBAwcO1I8//qh69erpzjvv1Pbt2+237po7d668vLzUt29f5efnKzY2Vq+99pr9+d7e3lq7dq3GjBmj6Oho1ahRQ0OHDtW0adPsbcLDw7Vu3To98cQTmj9/vm644Qa9+eabDrM2+/fvr5MnT2ry5MnKyspS+/btlZSU5HBb98zMTHl5/W/eze23365ly5Zp0qRJevbZZ9W0aVOtXr1arVu3treZMGGCzp49q1GjRik7O1t33nmnkpKS5OfnV+o+AgBP8sEHH5Q5OySpVatW2rBhg/33atX+F19PPPGE1q1bp5UrVyooKEjx8fHq06ePPv/8c0nSxYsX1bNnT4WGhmrbtm06duyYhgwZourVq+vFF1+U9OsJuJ49e2r06NF65513tHHjRj366KMKCwuz58e7776rhIQELVy4UFFRUZo3b55iY2OVnp6u+vXrF1v3tm3bNHDgQM2YMUP33Xefli1bpt69e2v37t32/Jg5c6ZeeeUVvfXWWwoPD9dzzz2n2NhY7d+/n/wAUCWRHWQHAFhFdpAdAGBVeWXHpYru0D548GCHO7T37dtXUvF3aP/LX/6iEydO2N/ji7tD+28nC5b0Db9FF44VfcPvpRd4/VbRNwePGzeu2O1e+s3H7du3l/S/bz4eM2bMNfcRALizisgOAIBnK4/s2LVrl+6++27770WTPYYOHarExMRSXaf0zjvvKD4+Xvfcc4/9mqxXXnnFvj4oKEgff/yx4uLiFBkZqeDgYE2ePFmjRo2ytynNNVPHjh1zmGxRXtdvuYJz587JGKM+ffpIklatWqVTp06pUaNGTq4MgKdh3AEAcDpjwY4dO6w0xzU4ffq0kWROnz5t6XmpqalGkhk1apQZNWqUkWRSU1MrqEoAuLJL38vKmh1Tpkwx7dq1K3Zddna2qV69ulm5cqV92YEDB4wkk5KSYowxZv369cbLy8tkZWXZ27z++usmMDDQ5OfnG2OMmTBhgmnVqpXDtvv3729iY2Ptv3fq1MnExcXZf7948aJp0KCBmTFjRom1P/jgg6Znz54Oy6Kiosyf/vQnY4wxhYWFJjQ01Lz88ssO++Tr62v+9a9/lbjd3yI7AHgCsuNXZAcAlB7Z8SuyAwBKrzyz48knnzRbtmwxGRkZ5vPPPzcxMTEmODjYnDhxwhhjzOjRo02jRo3Mpk2bzK5du0x0dLSJjo62P//ChQumdevWplu3biYtLc0kJSWZevXqmYkTJ9rbfPPNNyYgIMCMHz/eHDhwwCxYsMB4e3ubpKQke5vly5cbX19fk5iYaPbv329GjRplateu7ZBJgwcPNs8884z9988//9xUq1bNzJo1yxw4cMBMmTLFVK9e3ezdu9fe5qWXXjK1a9c2H3zwgfnyyy9Nr169THh4uMnLyyt1H5EdADxBeWYHro7sAOAJyI7Kda3ZcanicmTp0qX2ZX369CFnAFQosqNylce4g2wA4GzlcRxcnFLdsaRIRESEZsyYof379zvcXmvFihVWNgMAqELKIzsOHTqkBg0ayM/PT9HR0ZoxY4YaNWqk1NRUnT9/XjExMQ6v16hRI6WkpOi2225TSkqK2rRp4/CtJrGxsRozZoy++uordejQQSkpKQ7bKGpT9K2NBQUFSk1N1cSJE+3rvby8FBMTo5SUlBLrTklJcbhFcNF2V69eLenXbyzOyspyeO2goCBFRUUpJSVFAwYMKHa7+fn5Dn2Zk5NTYg0A4I7IjvLPDgDwdGQH4w4AsKqs2cEd2gGg6uGzcgCAVWQHAMAqsgMA4ExeV2/yP4MGDVLNmjW1Y8cODR06VDabTY0bN66o2gAAHqCs2REVFaXExEQlJSXp9ddfV0ZGhjp37qwzZ84oKytLPj4+ql27tsNzQkJClJWVJUnKysq67Fa5Rb9frU1OTo7y8vJ06tQpXbx4sdg2RdsoTknbvfR1L62ntNudMWOGgoKC7I+GDRuW2BYA3BHZUf7ZkZ+fr5ycHIcHAHgSsoNxBwBYVdbsWL58uY4ePar8/Hz98MMPWr58uW666Sb7ej8/Py1YsEA//fSTzp49q1WrVik0NNRhG40bN9b69ev1yy+/6OTJk5o1a5aqVXP8PrCuXbtqz549ys/P15EjRzRs2LDLaomPj9d3332n/Px87dixQ1FRUQ7rt2zZosTERIdl/fr1U3p6uvLz87Vv3z7de++9DuttNpumTZumrKwsnTt3Ths2bFCzZs1K3T8A4In4rBwAYBXZAQCwiuxwXwcOHFBmZqazywCAMrE0seTo0aN6/PHH5efnp549e2r58uX65JNPKqo2AIAHKGt29OjRQ/369VPbtm0VGxur9evXKzs7u0rPxJ84caJOnz5tf3z//ffOLgkAyhXZUf64OBiApyM7yh/jDgCejs87AABWkR0AAKvIDgCAVWSH+8nNzZXNZtPDDz+siIgIJpcAcGuWJpYUfVNWSEiINm7cqIMHD+rHH3+skMIAAJ6hvLOjdu3aatasmQ4fPqzQ0FAVFBQoOzvboc3x48ft3wAZGhqq48ePX7a+aN2V2gQGBsrf31/BwcHy9vYuts1vv2nyUiVt99LXvbSe0m7X19dXgYGBDg8A8CRkR/lnBxcHA/B0ZAfjDgCwis87AABWkR0AAKvIDgCAVWSH+zl37pyMMerSpYv9DvUA4K4sTSx59tlndfr0ac2ePVvTp0/Xww8/rDlz5lRUbQAAD1De2ZGbm6sjR44oLCxMkZGRql69ujZu3Ghfn56erszMTEVHR0uSoqOjtXfvXp04ccLeJjk5WYGBgWrZsqW9zaXbKGpTtA0fHx9FRkY6tCksLNTGjRvtbYpzte2Gh4crNDTUoU1OTo527Nhxxe0CgKcjO8o/O7g4GICnIzsYdwCAVXzeAQCwiuwAAFhFdgAArCI73FdQUJCzSwCAMqtmpXGvXr0kSW3bttWWLVsqoh4AgIcpa3Y89dRTuv/++9W4cWMdPXpUU6ZMkbe3twYOHKigoCCNGDFCCQkJqlu3rgIDA/X4448rOjpat912mySpW7duatmypQYPHqyZM2cqKytLkyZNUlxcnHx9fSVJo0eP1quvvqoJEybokUce0aZNm7RixQqtW7fOXkdCQoKGDh2qW265RZ06ddK8efN09uxZDR8+3N5myJAhuv766zVjxgxJ0tixY3XXXXdp9uzZ9ttT7tq1S4sWLZIk2Ww2jRs3Ti+88IKaNm2q8PBwPffcc2rQoIF69+59Ld0NAB6B7CA7AMAqsoPsAACr+LwDAGAV2QEAsIrsAABYRXYAAJzJ0sSSI0eO6NVXX9W3336rixcv2pevWbOm3AsDAHiGsmbHDz/8oIEDB+rHH39UvXr1dOedd2r79u2qV6+eJGnu3Lny8vJS3759lZ+fr9jYWL322mv253t7e2vt2rUaM2aMoqOjVaNGDQ0dOlTTpk2ztwkPD9e6dev0xBNPaP78+brhhhv05ptvKjY21t6mf//+OnnypCZPnqysrCy1b99eSUlJCgkJsbfJzMyUl9f/bgZ2++23a9myZZo0aZKeffZZNW3aVKtXr1br1q3tbSZMmKCzZ89q1KhRys7O1p133qmkpCT5+flZ6GUA8CxkB9kBAFaRHWQHAFjF5x0AAKvIDgCAVWQHAMAqsgMA4EyWJpY88MADio+P14MPPujwATYAACUpa3YsX778iuv9/Py0YMECLViwoMQ2jRs31vr166+4na5du2rPnj1XbBMfH6/4+PgS1xf3TQH9+vVTv379SnyOzWbTtGnTHC44A4CqjuwgOwDAKrKD7AAAq/i8AwBgFdkBALCK7AAAWEV2AACcydLEkoCAAI0aNaqiagEAeCCyAwBgFdkBALCK7AAAWEV2AACsIjsAAFaRHQAAq8gOAIAzWZpYMnHiRD399NOKiYmRr6+vfXmXLl3KvTAAgGcgOwAAVpEdAACryA4AgFVkBwDAKrIDAGAV2QEAsIrsAAA4k6WJJR999JG2bNmiw4cP22+zZbPZCC0AQInIDgCAVWQHAMAqsgMAYBXZAQCwiuwAAFhFdgAArCI7AADOZGliyYYNG5Seni6bzVZR9QAAPAzZAQCwiuwAAFhFdgAArCI7AABWkR0AAKvIDgCAVWQHAMCZvKw07tSpk44cOVJRtQAAPBDZAQCwiuwAAFhFdgAArCI7AABWkR0AAKvIDgCAVWQHAMCZLN2xZN++fWrdurWaN28uX19fGWNks9m0c+fOiqoPAODmyA4AgFVkBwDAKrIDAGAV2QEAsIrsAABYRXa4r4yMDGeXAKCKIjsAAM5kaWLJBx98UFF1AAA8FNkBALCK7AAAWEV2AACsIjsAAFaRHQAAq8gO95ObmyubzabnnnvO2aUAqKLIDgCAM5VqYkl+fr58fX1Vr169iq4HAOBhyA4AgFVkBwDAKrIDAGAV2QEAsIrsAABYRXa4n3PnzskYow4dOmjPnj3OLgdAFUR2AACcqVQTS/r27au1a9eqVatWstls9ttrFf33m2++qeg6AQBuiuwAAFhFdgAArCI7AABWkR0AAKvIDgCAVWSH+6pZs6azSwBQRZEdAABnKtXEkrVr10qSMjIyKrQYAIDnITsAAFaRHQAAq8gOAIBVZAcAwCqyAwBgFdkBALCK7AAAOJOXlcadOnUq1TIAAIqQHQAAq8gOAIBVZAcAwCqyAwBgFdkBALCK7AAAWFXW7Ni6davuv/9+NWjQQDabTatXr3ZYb4zR5MmTFRYWJn9/f8XExOjQoUMObX766ScNGjRIgYGBql27tkaMGKHc3FyHNl9++aU6d+4sPz8/NWzYUDNnzryslpUrVyoiIkJ+fn5q06aN1q9ff9X6t2zZoo4dO8rX11c333yzEhMTL2uzYMECNWnSRH5+foqKitLOnTuv3jEAgFIp1R1LTp06pePHjys3N1cHDhyQMUaSlJOTo5ycnAotEADgvg4cOEB2AAAsITsAAFaRHQAAq8gOAIBVZAcAwCqyAwBgVXlkx9mzZ9WuXTs98sgj6tOnz2XrZ86cqVdeeUVvvfWWwsPD9dxzzyk2Nlb79++Xn5+fJGnQoEE6duyYkpOTdf78eQ0fPlyjRo3SsmXL7DV169ZNMTExWrhwofbu3atHHnlEtWvX1qhRoyRJ27Zt08CBAzVjxgzdd999WrZsmXr37q3du3erdevWxdaekZGhnj17avTo0XrnnXe0ceNGPfroowoLC1NsbKwk6d1331VCQoIWLlyoqKgozZs3T7GxsUpPT1f9+vVL39kAgGKVamLJunXrlJiYqO+//15xcXH20KpVq5ZefPHFCi0QAOC+xo8fT3YAACwhOwAAVpEdAACryA4AgFVkBwDAKrIDAGBVeWRHjx491KNHj2LXGWM0b948TZo0Sb169ZIkvf322woJCdHq1as1YMAAHThwQElJSfrPf/6jW265RZL0t7/9Tffee69mzZqlBg0a6J133lFBQYEWL14sHx8ftWrVSmlpaZozZ459Ysn8+fPVvXt3jR8/XpI0ffp0JScn69VXX9XChQuLrW/hwoUKDw/X7NmzJUktWrTQZ599prlz59onlsyZM0cjR47U8OHD7c9Zt26dFi9erGeeeabU/QQAKF6pJpYMHTpUQ4cO1erVq9W7d+8KLgkA4CnWrl2rTZs2kR0AgFIjOwAAVpEdAACryA4AgFVkBwDAKrLD9WVmZurUqVM6cOCAs0sBAEkVnx0ZGRnKyspSTEyMfVlQUJCioqKUkpKiAQMGKCUlRbVr17ZPKpGkmJgYeXl5aceOHXrggQeUkpKiLl26yMfHx94mNjZWf/3rX/Xzzz+rTp06SklJUUJCgsPrx8bGavXq1SXWl5KS4lBb0XPGjRsnSSooKFBqaqomTpxoX+/l5aWYmBilpKSUuN38/Hzl5+fbf+fuYQBQMi8rjffv368zZ87o4sWL6tevn5o1a3bFN3oAAMgOAIBVZAcAwCqyAwBgFdkBALCK7AAAWEV2uK7MzExFREQoMjJSDz/8sLPLAQC7isyOrKwsSVJISIjD8pCQEPu6rKws1a9f32F9tWrVVLduXYc2xW3j0tcoqU3R+pLqK+45OTk5ysvL06lTp3Tx4kXL250xY4aCgoLsj4YNG5bYFgCqOksTS1auXKlatWpp7dq18vPz02effabnn3++omoDAHgAsgMAYBXZAQCwiuwAAFhFdgAArCprdsyYMUO33nqratWqpfr166t3795KT093aNO1a1fZbDaHx+jRox3aZGZmqmfPngoICFD9+vU1fvx4XbhwwaHNli1b1LFjR/n6+urmm29WYmLiZfUsWLBATZo0kZ+fn6KiorRz585S9UFERIT8/PzUpk0brV+/3mG9MUaTJ09WWFiY/P39FRMTo0OHDpWyhwDA8zDucF2nTp1SXl6e+vTpo7vvvtvZ5QCAHdlR/iZOnKjTp0/bH99//72zSwIAl2VpYkleXp4k6YMPPtCAAQNUv359GWMqpDAAgGcgOwAAVpEdAACryA4AgFVkBwDAqrJmxyeffKK4uDht375dycnJOn/+vLp166azZ886tBs5cqSOHTtmf8ycOdO+7uLFi+rZs6cKCgq0bds2vfXWW0pMTNTkyZPtbTIyMtSzZ0/dfffdSktL07hx4/Too4/qo48+srd59913lZCQoClTpmj37t1q166dYmNjdeLEiRLr37ZtmwYOHKgRI0Zoz5496t27t3r37q19+/bZ28ycOVOvvPKKFi5cqB07dqhGjRqKjY3VuXPnSt1PAOBJGHe4vuDgYNWpU8fZZQCAXUVmR2hoqCTp+PHjDsuPHz9uXxcaGnrZuODChQv66aefHNoUt41LX6OkNkXrS6qvuOcEBgbK399fwcHB8vb2trxdX19fBQYGOjwAAMWzNLHk/vvvV+PGjZWamqpu3brp5MmT8vX1rajaAAAegOwAAFhFdgAArCI7AABWkR0AAKvKmh1JSUkaNmyYWrVqpXbt2ikxMVGZmZlKTU11aBcQEKDQ0FD749KLnj7++GPt379fS5cuVfv27dWjRw9Nnz5dCxYsUEFBgSRp4cKFCg8P1+zZs9WiRQvFx8frj3/8o+bOnWvfzpw5czRy5EgNHz5cLVu21MKFCxUQEKDFixeXWP/8+fPVvXt3jR8/Xi1atND06dPVsWNHvfrqq5J+vVvJvHnzNGnSJPXq1Utt27bV22+/raNHj2r16tWl7icA8CSMOwAAVlVkdoSHhys0NFQbN260L8vJydGOHTsUHR0tSYqOjlZ2drbDOGXTpk0qLCxUVFSUvc3WrVt1/vx5e5vk5GQ1b97cPlkvOjra4XWK2hS9TnGu9hwfHx9FRkY6tCksLNTGjRuvuF0AQOlZmljy8ssva8+ePdq9e7eqV6+ugIAAffDBBxVVGwDAA5AdAACryA4AgFVkBwDAKrIDAGBVeWfH6dOnJUl169Z1WP7OO+8oODhYrVu31sSJE/XLL7/Y16WkpKhNmzYKCQmxL4uNjVVOTo6++uore5uYmBiHbcbGxiolJUWSVFBQoNTUVIc2Xl5eiomJsbcpztW2m5GRoaysLIc2QUFBioqKKnG7+fn5ysnJcXgAgCdh3AEAsKqs2ZGbm6u0tDSlpaVJ+vU4PS0tTZmZmbLZbBo3bpxeeOEFrVmzRnv37tWQIUPUoEED9e7dW5LUokULde/eXSNHjtTOnTv1+eefKz4+XgMGDFCDBg0kSQ899JB8fHw0YsQIffXVV3r33Xc1f/58JSQk2OsYO3askpKSNHv2bB08eFBTp07Vrl27FB8fb28zceJEDRkyxP776NGj9c0332jChAk6ePCgXnvtNa1YsUJPPPGEvU1CQoLeeOMNvfXWWzpw4IDGjBmjs2fPavjw4dfS3QCA37A0sSQ7O1svvfSSBg8eLEn64Ycf9Omnn1ZIYQAAz0B2AACsIjsAAFaRHQAAq8gOAIBV5ZkdhYWFGjdunO644w61bt3avvyhhx7S0qVLtXnzZk2cOFH//Oc/9fDDD9vXZ2VlOUwqkWT/PSsr64ptcnJylJeXp1OnTunixYvFtinaRnFK2u6lr3tpPaXZ7owZMxQUFGR/NGzYsMTXBwB3xLgDAGBVWbNj165d6tChgzp06CDp14kYHTp00OTJkyVJEyZM0OOPP65Ro0bp1ltvVW5urpKSkuTn52ffxjvvvKOIiAjdc889uvfee3XnnXdq0aJF9vVBQUH6+OOPlZGRocjISD355JOaPHmyRo0aZW9z++23a9myZVq0aJHatWun9957T6tXr3YY/xw7dkyZmZn238PDw7Vu3TolJyerXbt2mj17tt58803Fxsba2/Tv31+zZs3S5MmT1b59e6WlpSkpKemycQgA4NpYmlgydOhQtWjRQvv27ZP06xv59OnTS/38GTNm6NZbb1WtWrVUv3599e7dW+np6Q5tunbtKpvN5vAYPXq0Q5vMzEz17NlTAQEBql+/vsaPH68LFy44tNmyZYs6duwoX19f3XzzzUpMTLysngULFqhJkyby8/NTVFSUdu7cedV9WLlypSIiIuTn56c2bdpo/fr1DuuNMZo8ebLCwsLk7++vmJgYHTp0qJQ9BACep6zZAQCoesgOAIBVZAcAwCqyAwBgVXlmR1xcnPbt26fly5c7LB81apRiY2PVpk0bDRo0SG+//bbef/99HTlypMz1u6KJEyfq9OnT9sf333/v7JIAoFxVxrhj6tSpl11nFRERYV9/7tw5xcXF6brrrlPNmjXVt29fHT9+3GEb5XUd1m99+eWX6ty5s/z8/NSwYUPNnDnzsjZXuw4LAKqasmZH165dZYy57FH0vm2z2TRt2jRlZWXp3Llz2rBhg5o1a+awjbp162rZsmU6c+aMTp8+rcWLF6tmzZoObdq2batPP/1U586d0w8//KCnn376slr69eun9PR05efna9++fbr33nsd1icmJmrLli2X1b9nzx7l5+fryJEjGjZs2GXbjY+P13fffaf8/Hzt2LFDUVFRpe4fAMCVWZpYcvToUQ0fPlze3t6SJB8fH3l5lX4Tn3zyieLi4rR9+3YlJyfr/Pnz6tatm86ePevQbuTIkTp27Jj9cenA4uLFi+rZs6cKCgq0bds2vfXWW0pMTLTPqJR+vX1Xz549dffddystLU3jxo3To48+qo8++sje5t1331VCQoKmTJmi3bt3q127doqNjdWJEydKrH/btm0aOHCgRowYoT179qh3797q3bu3PcQlaebMmXrllVe0cOFC7dixQzVq1FBsbKzOnTtX6n4CAE9S1uwAAFQ9ZAcAwCqyAwBgVVmzgy/SAoCqp7zGHfHx8Vq7dq02b96sG2644Yptiy6QOnz4sCQpNDT0souBi34PDQ29YpvAwED5+/srODhY3t7exbYp2kZxStrupa97aT2l2a6vr68CAwMdHgDgSSrrnFWrVq0crrP67LPP7OueeOIJffjhh1q5cqU++eQTHT16VH369LGvL6/rsH4rJydH3bp1U+PGjZWamqqXX35ZU6dOdfjG+9JchwUAVQ2fdwAAnMlS4tSoUUPZ2dmy2WySpN27d6tWrVqlfn5SUpKGDRumVq1aqV27dkpMTFRmZqZSU1Md2gUEBCg0NNT+uPQE0scff6z9+/dr6dKlat++vXr06KHp06drwYIFKigokCQtXLhQ4eHhmj17tlq0aKH4+Hj98Y9/1Ny5c+3bmTNnjkaOHKnhw4erZcuWWrhwoQICArR48eIS658/f766d++u8ePHq0WLFpo+fbo6duyoV199VdKvH7LMmzdPkyZNUq9evdS2bVu9/fbbOnr0qFavXl3qfgIAT1LW7AAAVD1kBwDAKrIDAGBVWbODL9ICgKqnrNlhjFF8fLzef/99bdq0SeHh4Vd9TlpamiQpLCxMkhQdHa29e/c6vMcnJycrMDBQLVu2tLfZuHGjw3aSk5MVHR0t6dcL0yIjIx3aFBYWauPGjfY2xbnadsPDwxUaGurQJicnRzt27LjidgHAk1XWOatq1ao5XGcVHBwsSTp9+rT+8Y9/aM6cOfrd736nyMhILVmyRNu2bdP27dslld91WL/1zjvvqKCgQIsXL1arVq00YMAA/fnPf9acOXPsba52HRYAVEV83gEAcCZLE0tmz56t3r17KyMjQ/fcc48GDBigV1555Zpf/PTp05J+vXXWpd555x0FBwerdevWmjhxon755Rf7upSUFLVp00YhISH2ZbGxscrJydFXX31lbxMTE+OwzdjYWKWkpEiSCgoKlJqa6tDGy8tLMTEx9jbFudp2MzIylJWV5dAmKChIUVFRJW43Pz9fOTk5Dg8A8CTlnR0AAM9HdgAArCI7AABWlTU7+CItAKh6ypodcXFxWrp0qZYtW6ZatWopKytLWVlZysvLkyQdOXJE06dPV2pqqr799lutWbNGQ4YMUZcuXdS2bVtJUrdu3dSyZUsNHjxYX3zxhT766CNNmjRJcXFx8vX1lSSNHj1a33zzjSZMmKCDBw/qtdde04oVK/TEE0/Ya0lISNAbb7yht956SwcOHNCYMWN09uxZDR8+3N5myJAhmjhxov33sWPHKikpSbNnz9bBgwc1depU7dq1S/Hx8ZIkm82mcePG6YUXXtCaNWu0d+9eDRkyRA0aNFDv3r2vud8BwJ1V1jmrQ4cOqUGDBrrxxhs1aNAgZWZmSpJSU1N1/vx5h+uYIiIi1KhRI/t1TOVxHVZxUlJS1KVLF/n4+Dg8Jz09XT///PM1b5frrAB4Oj7vAAA4UzUrjSMjI7Vhwwalp6ersLBQERERql69+jW9cGFhocaNG6c77rhDrVu3ti9/6KGH1LhxYzVo0EBffvmlnn76aaWnp2vVqlWSpKysLIfBjCT771lZWVdsk5OTo7y8PP3888+6ePFisW0OHjxYYs0lbffS1720nuLa/NaMGTP0/PPPl/iaAODuyjM7AABVA9kBALCK7AAAWFXe2XGlL9JaunSpQkNDdf/99+u5555TQECApJIv4BozZoy++uordejQocQLrcaNGyfpf1+kdemFv6X9Iq2EhITLtls0aeRqX6Q1YMCAy7aZn5+v/Px8++9c4AXA05Q1O15//XVJUteuXR2WL1myRMOGDZOPj482bNigefPm6ezZs2rYsKH69u2rSZMm2dt6e3tr7dq1GjNmjKKjo1WjRg0NHTpU06ZNs7cJDw/XunXr9MQTT2j+/Pm64YYb9Oabbyo2Ntbepn///jp58qQmT56srKwstW/fXklJSQ6ZlJmZKS+v/31P5e23365ly5Zp0qRJevbZZ9W0aVOtXr3a4bP+CRMm6OzZsxo1apSys7N15513KikpSX5+fqXuJwDwJJVxzioqKkqJiYlq3ry5jh07pueff16dO3fWvn37lJWVJR8fH9WuXdvhOb+91qms12H5+/tfVldWVtZld+e6dLt16tS56nVYxeE6KwCejs87AADOZGliifTr7RNbtWpV5heOi4vTvn379NlnnzksHzVqlP3nNm3aKCwsTPfcc4+OHDmim266qcyv62omTpzo8OFNTk6OGjZs6MSKAKD8lVd2AACqDrIDAGAV2QEAsKq8soMv0voVF3gBqArKkh3GmCuub9iwoT755JOrbqdx48Zav379Fdt07dpVe/bsuWKb+Ph4+91GirNly5bLlvXr10/9+vUr8Tk2m03Tpk1zmOgCAFVdRZ+z6tGjh/3ntm3bKioqSo0bN9aKFSuKnfDh7rjOCkBVwOcdAABnsTyxpDzEx8dr7dq12rp1q2644YYrto2KipIkHT58WDfddJNCQ0O1c+dOhzbHjx+XJIWGhtr/W7Ts0jaBgYHy9/eXt7e3vL29i21TtI3ilLTdS1+3aFlYWJhDm/bt2xe7TV9fX/ttiQEAAAAAAAAAgHvhi7R+xQVeAAAAgPPVrl1bzZo10+HDh/X73/9eBQUFys7OdrhryW+vdSrrdVjFKek5pdnula7dcrXrrDIzM3Xq1ClJUnBwsBo1auTkigAAAIBr53X1JuXHGKP4+Hi9//772rRp02W3PCxOWlqaJNknakRHR2vv3r06ceKEvU1ycrICAwPVsmVLe5uNGzc6bCc5OVnR0dGSJB8fH0VGRjq0KSws1MaNG+1tinO17YaHhys0NNShTU5Ojnbs2HHF7QIAAAAAAAAAAPdT9EVamzdvtvRFWlLZLrQquoArODi4wr9Iq7Tb9fX1VWBgoMMDAAAAQOXKzc3VkSNHFBYWpsjISFWvXt3hOqb09HRlZmbar2Mqj+uwihMdHa2tW7fq/PnzDs9p3ry56tSpc83bdSWZmZmKiIhQZGSkIiMjFRERoczMTGeXBQAAAFyzUk0smT9/vv3n3bt3X/OLxcXFaenSpVq2bJlq1aqlrKwsZWVlKS8vT5J05MgRTZ8+Xampqfr222+1Zs0aDRkyRF26dFHbtm0lSd26dVPLli01ePBgffHFF/roo480adIkxcXF2Wekjx49Wt98840mTJiggwcP6rXXXtOKFSv0xBNP2GtJSEjQG2+8obfeeksHDhzQmDFjdPbsWQ0fPtzeZsiQIZo4caL997FjxyopKUmzZ8/WwYMHNXXqVO3atct+i2CbzaZx48bphRde0Jo1a7R3714NGTJEDRo0UO/eva+53wDA3ZUlOwAAVRPZAQCwiuwAAFhVluzgi7QAoGpi3AEAsKqis+Opp57SJ598om+//Vbbtm3TAw88IG9vbw0cOFBBQUEaMWKEEhIStHnzZqWmpmr48OGKjo7WbbfdJqn8rsN69dVXdc8999h/f+ihh+Tj46MRI0boq6++0rvvvqv58+c73OXwatdhubpTp04pLy9Pffr0UZ8+fZSXl2e/ewkAlAXjDgCAs5RqYslbb71l//nRRx+95hd7/fXXdfr0aXXt2lVhYWH2x7vvvivp1w9ANmzYoG7duikiIkJPPvmk+vbtqw8//NC+DW9vb61du1be3t6Kjo7Www8/rCFDhmjatGn2NuHh4Vq3bp2Sk5PVrl07zZ49W2+++aZiY2Ptbfr3769Zs2Zp8uTJat++vdLS0pSUlKSQkBB7m8zMTB07dsz+++23365ly5Zp0aJFateund577z2tXr1arVu3treZMGGCHn/8cY0aNUq33nqrcnNzlZSUJD8/v2vuNwBwd2XJDgBA1UR2AACsIjsAAFaVJTv4Ii0AqJoYdwAArKro7Pjhhx80cOBANW/eXA8++KCuu+46bd++XfXq1ZMkzZ07V/fdd5/69u2rLl26KDQ0VKtWrbI/v7yuwzp16pSOHDli/z0oKEgff/yxMjIyFBkZqSeffFKTJ0/WqFGj7G1Kcx2WOwgODlZwcLCzywDgQRh3AACcpVplvpgx5orrGzZsqE8++eSq22ncuLHWr19/xTZdu3bVnj17rtgmPj7+irPct2zZctmyfv36qV+/fiU+x2azadq0aQ4DLAAAAAAAAAAA4Dlef/11Sb9+FnGpJUuWaNiwYfYv0po3b57Onj2rhg0bqm/fvpo0aZK9bdEFXGPGjFF0dLRq1KihoUOHFnsB1xNPPKH58+frhhtuKPaLtE6ePKnJkycrKytL7du3L/aLtLy8/vddY0UXcE2aNEnPPvusmjZtWuwXaZ09e1ajRo1Sdna27rzzTr5ICwAAAHAxy5cvv+J6Pz8/LViwQAsWLCixTXlchzV16lRNnTrVYVnbtm316aefXnG7V7sOCwAAAEDlKdXEkpMnT+q1116TMcb+86Uee+yxCikOAODe3njjDfn5+ZEdAIBSIzsAAFaRHQAAq8ojO/giLQCoWhh3AACsIjsAAFaRHQAAZyvVxJJHH31UJ0+evOxnAACu5Mcff5Svry/ZAQAoNbIDAGAV2QEAsIrsAABYRXYAAKwiOwAAVpEdAABnK9XEkilTplR0HQAAD/TMM88oMDDQ2WUAANwI2QEAsIrsAABYRXYAAKwiOwAAVpEdAACryA4AgLOVamLJ1W5zPnny5HIpBgDgWf7617/K19e32HVkBwCgOGQHAMAqsgMAYBXZAQCwiuwAAFhFdgAArCI7PEtmZqZOnTolSQoODlajRo2cXBEAXF2pJ5a0bt1affr0UXBwsIwxFV0XAMADfPjhh/rjH/9IdgAASo3sAABYRXYAAKwiOwAAVpEdAACryA7PduDAAWeXAMADkR2eIzMzUxEREcrLy5Mk+fv76+DBg0wuAeDySjWx5IcfftB7772n999/Xz4+PurXr58eeOAB1alTp6LrAwC4sSFDhujf//432QEAKDWyAwBgFdkBALCK7AAAWEV2AACsIjs8U25urmw2mx5++OFi1x84cIBvpQdwzcgOz3Hq1Cnl5eWpT58+kqRVq1bp1KlT5AMAl+dVmkahoaGKj4/Xxo0btXjxYp0+fVotWrTQW2+9VdH1AQDc2KhRo8gOAIAlZAcAwCqyAwBgFdkBALCK7AAAWEV2eKZz587JGKM+ffro7rvvti+/dMJJRESEMjMznVglAHdFdnie4OBgBQcHO7sMACi1Ut2xRJKMMfrkk0/07rvvaufOnRo4cKDuuOOOiqwNAODmjDHasmUL2QEAKDWyAwBgFdkBALCK7AAAWEV2AACsIjs8228vEi6acNKlSxdt3bqVb6UHcE3IDgCAs5VqYkl8fLy2b9+uzp07a8iQIXr99dcrui4AgAfo2rWrunbtSnYAAEqN7AAAWEV2AACsIjsAAFaRHQAAq8iOqikoKMjZJQBwY2QHAMDZSjWx5LXXXlPdunX13XffaenSpbLZbJJ+nSFps9l04sSJCi0SAOCeMjMztXTpUrIDAFBqZAcAwCqyAwBgFdkBALCK7AAAWEV2AACsIjsAAM5WqoklhYWFFV0HAMADZWRkKDAw0NllAADcCNkBALCK7AAAWEV2AACsIjvcz4EDByRJwcHBatSokZOrAVAVkR0AAKvIDs9QNBYBAHdUqokl586d08KFC3X48GG1bdtWjzzyiKpVK9VTAQBV2GuvvaYffviB7AAAlBrZAQCwiuwAAFhFdgAArCI73Edubq5sNpsefvhhSZK/v78OHjzI5BIAlY7sAABYRXa4t19++cVhLAIA7sirNI2GDh2qXbt2qU2bNlq/fr2eeuqpiq4LAOAB9uzZQ3YAACwhOwAAVpEdAACryA4AgFVkh/s4d+6cjDHq06eP+vTpo7y8PJ06dcrZZQGogsgOSFJmZqZ2796t3bt3KzMz09nlAHBxZId7KygosI9F7r777svWHzhwgDwA4PJKNaVx//792rt3ryRpxIgR6tSpU4UWBQDwDG+88YYCAwPJDgBAqZEdAACryA4AgFVkBwDAKrLD/QQHBzu7BABVHNmBzMxMRUREKC8vTxJ30QJwdWSHZ/jtWIS7KgJwJ6W6Y0n16tXtP3N7LQCAVWQHAMAqsgMAYBXZAQCwiuwAAFhFdgAArCI7qq5Tp04pLy/P4S5an376Kd9WD+CqyA7Pwl0VAbiTUiXQl19+qfr160uSjDHKzs5W/fr1ZYyRzWbTiRMnKrRIAIB7uummm2Sz2cgOAECpkR0AAKvIDgCAVWQHAMAqsgMAYBXZgSLBwcF8Wz2AUiE7PBt3VQTgDko1seTChQsVXQcAwAMdOXJEgYGBzi4DAOBGyA4AgFVkBwDAKrIDAGAV2QEAsIrswKUu/bZ6SVq1apVOnTqlRo0aKTMzU6dOnVJwcDATTYAqjuyoOg4cOCBJvPcDcDncMwsAAAAAAAAAAAAAAAAAgAr022+rz8zMVEREhPLy8riLCQBUAdzBCoCr83J2AQAAAAAAAAAAAAAAAAAAVCWnTp1SXl6eunTpory8PJ06dcrZJQEAKtCld7Dq06cP7/0AXA53LAEAAAAAAAAAAAAAAAAAwAmCgoIkSQcOHJD0651N+PZ6APBcv72DFQC4CiaWAAAAAAAAAAAAAAAAAABQDoomiJTWL7/8IpvNpocffliS5O/vr4MHDzK5BAAAAJWKiSUAAAAAAAAAAAAAAAAAAJTBbyeIlFZBQYGMMerTp48kadWqVTp16hQTSwCgisjMzNSpU6ckcdcqAM7FxBIAAAAAAAAAAAAAAAAAAMrg0gkiP//8szZv3lxi2+LuahIcHFyR5QEAXNCxY8d05513Ki8vTxJ3rQLgXEws8WBFAxBmMAIAAAAAAAAAAAAAAABAxbvSBJHc3FxLdzXhW+wBwLNlZ2crLy+Pu1YBcAlMLPFAvx2AMIMRAAAAAAAAAAAAAAAAAJzr3Llzpb6rSWZmpiIiIvgWewCoArhrFQBXwMQSD3TpAERiBiMAAAAAAAAAAAAAAAAAuIqrXUB84MABSbrsW+w//fRTde7cmevAAMBDZGRkXLasKAO4UxWAysbEEg/GDEYAAAAAAAAAAODu+DAdAAAAQFWRm5srm82mhx9+2L4sODjYYTl3LgEA91f0vv7cc89dtqwoA3i/B1DZvJxdgLMtWLBATZo0kZ+fn6KiorRz584rtl+5cqUiIiLk5+enNm3aaP369Q7rjTGaPHmywsLC5O/vr5iYGB06dKgidwEAUMnIDgCAVWQHAMAqsgMAYJUnZselH6ZHRkYqIiJCmZmZlVoDAHgyT8yO4hw4cID8AIByUlWyw5nOnTsnY4z69Omju++++7LlXbp0UV5enk6dOiVJyszM1O7du7V7927yDoBLIjuKV/S+3qFDh8uW9enTR3369FFeXp4+/fRT3uMBVJoqPbHk3XffVUJCgqZMmaLdu3erXbt2io2N1YkTJ4ptv23bNg0cOFAjRozQnj171Lt3b/Xu3Vv79u2zt5k5c6ZeeeUVLVy4UDt27FCNGjUUGxurc+fOVdZuFYuTZQBQPqpSdgAAygfZAQCwiuwAAFjlqdlR3IfpRRdPAQDKxlOz41KXTlBkciIAlF1VyA5XEhwcrDp16ly2PCgoSNKv14KtW7dOzZs3V2RkpCIjI9WsWTOtW7eOC5ABuAyy4+pq1qx52bLg4GD5+fnxhSsAKl2VnlgyZ84cjRw5UsOHD1fLli21cOFCBQQEaPHixcW2nz9/vrp3767x48erRYsWmj59ujp27KhXX31V0q8zIefNm6dJkyapV69eatu2rd5++20dPXpUq1evrsQ9+59LT5YxeACAsvP07Dhw4AA5AQDlzNOzAwBQ/jw9Oxh3AED58/TsCA4OVnBwsKRfcyQlJcX+jbyX/ky2AEDpeXp2SJd/szvf9AsAZVMVssMd/PLLL/Zrwe677z6dO3dOffr0Uffu3VVQUKD77rvvskkmReMmxk8AKhvZce2udPeSovdz3ssBlLdqzi7AWQoKCpSamqqJEyfal3l5eSkmJkYpKSnFPiclJUUJCQkOy2JjY+2BlJGRoaysLMXExNjXBwUFKSoqSikpKRowYMBl28zPz1d+fr7999OnT0uScnJyLO1Pbm6uJOnYsWPKzs52+NkYo2bNmunrr7/WfffdJ0ny9fXVP//5T4WEhMjLy0uFhYX2Pvjtz1dbf61t3eV5rlwb+0RfVMZrhIaGKjQ0VFYUvYcZYyw9z9V5cnbk5eVJkh5++GFJ/8uJsLAwt/s36wrPc+Xa6Av2ieyoXJ6cHUVSU1OVm5vr1v9mXeF5rlwbfcE+kR2Vy5Ozg3GHazzPlWtjn9yjNlfpC7Ljfzw5Oy79vOO3OVKcq332wd8v++QOtbFPZEdlqCrZUfTz2bNnJV0+Finvz8qv9Xmu/PfEPrlHbfQF2VEZqlp2FG23pPXOfN7JkydljNHtt9+u3Nxcffnllzp//rzOnj1rX56fn6/U1FT7dWLFIQ9d93muXBv7RHZYQXaUTwacP3++xPNirvZeXtnPc+Xa6Av2yV2zo8pOLDl16pQuXryokJAQh+UhISE6ePBgsc/Jysoqtn1WVpZ9fdGyktr81owZM/T8889ftrxhw4al25Hf+PDDD4v9+euvv3Zol5+frwcffPCaXgMASuvMmTP227B6gqqQHUXICQDOQna4X3aMGjXqmrYBAOWF7HC/7CjCuAOAs5Ad7pcdxeVIccgWABWF7HDv7EhNTXVoR14AqAxkh3tnx5dffnnF9c58XlHbbdu2Fbv+0uVXQh4CrofsIDuu1va3eC8HUN7ZUWUnlriKiRMnOsywLCws1E8//aTrrrtONput1NvJyclRw4YN9f333yswMLAiSvVY9N21o++unaf3nTFGZ86cUYMGDZxdikciO64d+8w+eypP2Geyo2JV9exwx7rdsWbJPet2x5ol96y7vGsmOypWVc+OikBf/A998T/0xf9URl+QHRWrqmeHO9btjjVL1F2Z3LFmqXzrJjsqVlXPDldGn5Y/+rT8uWqfkh0Vi+xwTfRn+aI/y5c79CfZUbHIDtdA/5UN/Vd2ntaHFZUdVXZiSXBwsLy9vXX8+HGH5cePHy/xdjKhoaFXbF/03+PHjyssLMyhTfv27Yvdpq+vr3x9fR2W1a5d28quOAgMDPSIf/DOQN9dO/ru2nly33nSDPoiZIfnYJ+rBvbZ/ZAdvyI7Ko471u2ONUvuWbc71iy5Z93lWTPZ8Suyw73QF/9DX/wPffE/Fd0XZMevyI6K4451u2PNEnVXJnesWSq/usmOX5EdVRN9Wv7o0/Lnin1KdvyK7Kh66M/yRX+WL1fvT7LjV2SH56P/yob+KztP6sOKyA6vct+im/Dx8VFkZKQ2btxoX1ZYWKiNGzcqOjq62OdER0c7tJek5ORke/vw8HCFhoY6tMnJydGOHTtK3CYAwH2QHQAAq8gOAIBVZAcAwCqyAwBgFdkBALCK7AAAWEV2AID7qbJ3LJGkhIQEDR06VLfccos6deqkefPm6ezZsxo+fLgkaciQIbr++us1Y8YMSdLYsWN11113afbs2erZs6eWL1+uXbt2adGiRZIkm82mcePG6YUXXlDTpk0VHh6u5557Tg0aNFDv3r2dtZsAgHJEdgAArCI7AABWkR0AAKvIDgCAVWQHAMAqsgMAYBXZAQDupUpPLOnfv79OnjypyZMnKysrS+3bt1dSUpJCQkIkSZmZmfLy+t9NXW6//XYtW7ZMkyZN0rPPPqumTZtq9erVat26tb3NhAkTdPbsWY0aNUrZ2dm68847lZSUJD8/vwrdF19fX02ZMuWyW3bh6ui7a0ffXTv6zn2RHe6Nfa4a2Ge4GrLD+dyxbnesWXLPut2xZsk963bHmp2F7PBM9MX/0Bf/Q1/8D31RNmSH87lj3e5Ys0Tdlckda5bct+7KRnbgSujT8keflj/6tPKRHSgJ/Vm+6M/yRX86F9mBIvRf2dB/ZUcflo7NGGOcXQQAAAAAAAAAAAAAAAAAAAAAAAAqn9fVmwAAAAAAAAAAAAAAAAAAAAAAAMATMbEEAAAAAAAAAAAAAAAAAAAAAACgimJiCQAAAAAAAAAAAAAAAAAAAAAAQBXFxBIAAAAAAAAAAAAAAAAAAAAAAIAqioklHmDBggVq0qSJ/Pz8FBUVpZ07dzq7JKebMWOGbr31VtWqVUv169dX7969lZ6e7tDm3LlziouL03XXXaeaNWuqb9++On78uEObzMxM9ezZUwEBAapfv77Gjx+vCxcuVOauONVLL70km82mcePG2ZfRb1f23//+Vw8//LCuu+46+fv7q02bNtq1a5d9vTFGkydPVlhYmPz9/RUTE6NDhw45bOOnn37SoEGDFBgYqNq1a2vEiBHKzc2t7F2Bh/Ok7Jg6dapsNpvDIyIiwr7eE963tm7dqvvvv18NGjSQzWbT6tWrHdaX13vLl19+qc6dO8vPz08NGzbUzJkzK3rXSnS1fR42bNhl/9+7d+/u0Mad9rkyj122bNmijh07ytfXVzfffLMSExMrevfgIVwpOzzleN9djrfd8Rj34sWLeu655xQeHi5/f3/ddNNNmj59uowxLlW3O2b8lWo+f/68nn76abVp00Y1atRQgwYNNGTIEB09etSpNcO5XCk/KoKnZFJFcJecqyjumJ8VwV0yGa7FlbKjNO/zXbt2vewcxejRox3aVOZ7m7ueK2vSpMllddtsNsXFxUlynX6uqsfwxf3/eemllyqs5qvVLXne+UGUjStlhytj/FLxqvo4qLwwnkJlIDusK4+xRlVXWeOJqqKyxgxAEbKjdMgLa8iGsiELKoCBW1u+fLnx8fExixcvNl999ZUZOXKkqV27tjl+/LizS3Oq2NhYs2TJErNv3z6TlpZm7r33XtOoUSOTm5trbzN69GjTsGFDs3HjRrNr1y5z2223mdtvv92+/sKFC6Z169YmJibG7Nmzx6xfv94EBwebiRMnOmOXKt3OnTtNkyZNTNu2bc3YsWPty+m3kv3000+mcePGZtiwYWbHjh3mm2++MR999JE5fPiwvc1LL71kgoKCzOrVq80XX3xh/vCHP5jw8HCTl5dnb9O9e3fTrl07s337dvPpp5+am2++2QwcONAZuwQP5WnZMWXKFNOqVStz7Ngx++PkyZP29Z7wvrV+/Xrzf//3f2bVqlVGknn//fcd1pfHe8vp06dNSEiIGTRokNm3b5/517/+Zfz9/c3f//73ytpNB1fb56FDh5ru3bs7/H//6aefHNq40z5X1rHLN998YwICAkxCQoLZv3+/+dvf/ma8vb1NUlJSpe4v3I+rZYcnHO+7y/G2ux7j/uUvfzHXXXedWbt2rcnIyDArV640NWvWNPPnz3eput0x469Uc3Z2tomJiTHvvvuuOXjwoElJSTGdOnUykZGRDttwp4xG2bhaflQET8ikiuAuOVdR3DU/K4K7ZDJch6tlR2ne5++66y4zcuRIh3MUp0+ftq+v7Pc2dz1XduLECYeak5OTjSSzefNmY4zr9HNVPYZv3LixmTZtmkP/X/p3UBHH8FXt/CCunatlhytj/FKxqvo4qLwwnkJlIDuuTVnHGqic8URVUhljBqAI2VF65IU1ZEPZkAXlj4klbq5Tp04mLi7O/vvFixdNgwYNzIwZM5xYles5ceKEkWQ++eQTY8yvJ8qrV69uVq5caW9z4MABI8mkpKQYY359w/Hy8jJZWVn2Nq+//roJDAw0+fn5lbsDlezMmTOmadOmJjk52dx11132E1/025U9/fTT5s477yxxfWFhoQkNDTUvv/yyfVl2drbx9fU1//rXv4wxxuzfv99IMv/5z3/sbf79738bm81m/vvf/1Zc8ahSPC07pkyZYtq1a1fsOk983/rtQXB5vbe89tprpk6dOg77/PTTT5vmzZtX8B5dXUkH/r169SrxOe6+zxV17DJhwgTTqlUrh9fq37+/iY2Nrehdgptz9exwt+N9dzredtdj3J49e5pHHnnEYVmfPn3MoEGDXLZud8z44jL6t3bu3Gkkme+++84lakblcvX8qAjulkkVwZ1yrqK4a35WBHfMZDiXq2fHb9/njTEO73XFqez3Nk85VzZ27Fhz0003mcLCQmOM6/WzMVXnGN6YXyeWzJ07t8TnVPQxfFU8P4jSc/XscGWMX8oP46Dyw3gKlYHsuDZlHWvAUUWNJ6qqihozAEXIjtIjL64d2VA2ZEH58Cqf+57AGQoKCpSamqqYmBj7Mi8vL8XExCglJcWJlbme06dPS5Lq1q0rSUpNTdX58+cd+i4iIkKNGjWy911KSoratGmjkJAQe5vY2Fjl5OToq6++qsTqK19cXJx69uzp0D8S/XY1a9as0S233KJ+/fqpfv366tChg9544w37+oyMDGVlZTn0X1BQkKKiohz6r3bt2rrlllvsbWJiYuTl5aUdO3ZU3s7AY3lqdhw6dEgNGjTQjTfeqEGDBikzM1NS1XjfKq/3lpSUFHXp0kU+Pj72NrGxsUpPT9fPP/9cSXtjzZYtW1S/fn01b95cY8aM0Y8//mhf5+77XFHHLikpKZfle2xsrFv//aPiuUN2uNvxvjsdb7vrMe7tt9+ujRs36uuvv5YkffHFF/rss8/Uo0cPl677Up6S8adPn5bNZlPt2rXdpmaUD3fIj4rgbplUEdwp5yqKu+ZnRfCETEblcYfs+O37fJF33nlHwcHBat26tSZOnKhffvnFvs4Z723ufq6soKBAS5cu1SOPPCKbzWZf7mr9/Fueegxf5KWXXtJ1112nDh066OWXX9aFCxfs65xVsyefH0TpuEN2uDLGL+WHcVD5YTyFikZ2lE1Zxhq4Mt7fKkZZxwyARHZcC/KifJAN5YMssKaaswvAtTt16pQuXrzocIJBkkJCQnTw4EEnVeV6CgsLNW7cON1xxx1q3bq1JCkrK0s+Pj6XnRQPCQlRVlaWvU1xfVu0zlMtX75cu3fv1n/+85/L1tFvV/bNN9/o9ddfV0JCgp599ln95z//0Z///Gf5+Pho6NCh9v0vrn8u7b/69es7rK9WrZrq1q3r8f2HyuGJ2REVFaXExEQ1b95cx44d0/PPP6/OnTtr3759VeJ9q7zeW7KyshQeHn7ZNorW1alTp0Lqv1bdu3dXnz59FB4eriNHjujZZ59Vjx49lJKSIm9vb7fe54o8dimpTU5OjvLy8uTv718RuwQ35+rZ4W7H++52vO2ux7jPPPOMcnJyFBERIW9vb128eFF/+ctfNGjQIHtNrlj3pTwh48+dO6enn35aAwcOVGBgoFvUjPLj6vlREdwtkyqCu+VcRXHX/KwInpDJqDyunh3Fvc9L0kMPPaTGjRurQYMG+vLLL/X0008rPT1dq1atklT5722ecK5s9erVys7O1rBhw+zLXK2fi+Opx/CS9Oc//1kdO3ZU3bp1tW3bNk2cOFHHjh3TnDlznFazJ58fROm5ena4MsYv5YdxUPliPIWKRnZcu7KONXBlvL+Vv/IYMwAS2WEVeVF+yIayIwusY2IJPF5cXJz27dunzz77zNmluLzvv/9eY8eOVXJysvz8/JxdjtspLCzULbfcohdffFGS1KFDB+3bt08LFy7U0KFDnVwd4LmKvuVUktq2bauoqCg1btxYK1as4CJ5DzZgwAD7z23atFHbtm110003acuWLbrnnnucWFnZcewCWONOfzPueLztrse4K1as0DvvvKNly5apVatWSktL07hx49SgQQOXrtuTnD9/Xg8++KCMMXr99dedXQ5QKdwpkyqCO+ZcRXHX/KwIZDI8SUnv86NGjbL/3KZNG4WFhemee+7RkSNHdNNNN1V2mR5xruwf//iHevTooQYNGtiXuVo/e6IrHcMnJCTYf27btq18fHz0pz/9STNmzJCvr29llyrJs88PApWhqo9fygvjoPLHeApwXZ4w1kDVwpgBcA7yAq6ELLDOy9kF4NoFBwfL29tbx48fd1h+/PhxhYaGOqkq1xIfH6+1a9dq8+bNuuGGG+zLQ0NDVVBQoOzsbIf2l/ZdaGhosX1btM4Tpaam6sSJE+rYsaOqVaumatWq6ZNPPtErr7yiatWqKSQkhH67grCwMLVs2dJhWYsWLey3civa/yv9zYaGhurEiRMO6y9cuKCffvrJ4/sPlaMqZEft2rXVrFkzHT58uEq835fXe4u798ONN96o4OBgHT58WJL77nNFH7uU1CYwMJABPErkytnhbsf77ni87a7HuOPHj9czzzyjAQMGqE2bNho8eLCeeOIJzZgxw6XrvpQ7Z3zRBWnfffedkpOTHb7p2FVrRvlz5fyoCO6WSRXBHXOuorhrflYET8hkVB5Xzo6S3ueLExUVJUkO5yic+d7mbufKvvvuO23YsEGPPvroFdu5Wj9f+jqedgxfnKioKF24cEHffvut02r+LU85PwhrXDk7XBnjl/LDOKj8MZ5CRSM7yo/VsQaujPe3inctYwZAIjvKiry4dmRD+SMLro6JJW7Mx8dHkZGR2rhxo31ZYWGhNm7cqOjoaCdW5nzGGMXHx+v999/Xpk2bLruNdWRkpKpXr+7Qd+np6crMzLT3XXR0tPbu3evwplF0Mv23JzI8xT333KO9e/cqLS3N/rjllls0aNAg+8/0W8nuuOMOpaenOyz7+uuv1bhxY0lSeHi4QkNDHfovJydHO3bscOi/7Oxspaam2tts2rRJhYWF9g/KgLKoCtmRm5urI0eOKCwsrEq835fXe0t0dLS2bt2q8+fP29skJyerefPmqlOnTiXtzbX74Ycf9OOPPyosLEyS++1zZR27REdHO2yjqI2n/P2jYrhidrjr8b47Hm+76zHuL7/8Ii8vx1Me3t7eKiwsdOm6L+WuGV90QdqhQ4e0YcMGXXfddQ7rXbFmVAxXzI+K4K6ZVBHcMecqirvmZ0XwhExG5XHF7Lja+3xx0tLSJMnhHIUz39vc7VzZkiVLVL9+ffXs2fOK7VytnyXPPYYvTlpamry8vFS/fn2n1Fwcdz8/iGvjitnhyhi/lD/GQeWP8RQqGtlRfqyONXBlvL9VvGsZMwAS2VFW5MW1IxvKH1lQCgZubfny5cbX19ckJiaa/fv3m1GjRpnatWubrKwsZ5fmVGPGjDFBQUFmy5Yt5tixY/bHL7/8Ym8zevRo06hRI7Np0yaza9cuEx0dbaKjo+3rL1y4YFq3bm26detm0tLSTFJSkqlXr56ZOHGiM3bJae666y4zduxY++/0W8l27txpqlWrZv7yl7+YQ4cOmXfeeccEBASYpUuX2tu89NJLpnbt2uaDDz4wX375penVq5cJDw83eXl59jbdu3c3HTp0MDt27DCfffaZadq0qRk4cKAzdgkeytOy48knnzRbtmwxGRkZ5vPPPzcxMTEmODjYnDhxwhjjGe9bZ86cMXv27DF79uwxksycOXPMnj17zHfffWeMKZ/3luzsbBMSEmIGDx5s9u3bZ5YvX24CAgLM3//+90rfX2OuvM9nzpwxTz31lElJSTEZGRlmw4YNpmPHjqZp06bm3Llz9m240z5X1rHLN998YwICAsz48ePNgQMHzIIFC4y3t7dJSkqq1P2F+3G17PCk431XP95212PcoUOHmuuvv96sXbvWZGRkmFWrVpng4GAzYcIEl6rbHTP+SjUXFBSYP/zhD+aGG24waWlpDn+f+fn5TqsZzuNq+VERPCmTKoKr51xFcdf8rAjukslwHa6WHVd7nz98+LCZNm2a2bVrl8nIyDAffPCBufHGG02XLl3s26js9zZ3Pld28eJF06hRI/P00087LHelfq6Kx/Dbtm0zc+fONWlpaebIkSNm6dKlpl69embIkCEVVvPV6vbE84O4dq6WHa6M8UvlqKrjoPLCeAqVgey4NmUda6ByxhNVSWWMGYAiZEfpkRfWkA1lQxaUPyaWeIC//e1vplGjRsbHx8d06tTJbN++3dklOZ2kYh9Lliyxt8nLyzOPPfaYqVOnjgkICDAPPPCAOXbsmMN2vv32W9OjRw/j7+9vgoODzZNPPmnOnz9fyXvjXL898UW/XdmHH35oWrdubXx9fU1ERIRZtGiRw/rCwkLz3HPPmZCQEOPr62vuuecek56e7tDmxx9/NAMHDjQ1a9Y0gYGBZvjw4ebMmTOVuRuoAjwpO/r372/CwsKMj4+Puf76603//v3N4cOH7es94X1r8+bNxeba0KFDjTHl997yxRdfmDvvvNP4+vqa66+/3rz00kuVtYuXudI+//LLL6Zbt26mXr16pnr16qZx48Zm5MiRlw3Y3WmfK/PYZfPmzaZ9+/bGx8fH3HjjjQ6vAVyJK2WHJx3vu8Pxtjse4+bk5JixY8eaRo0aGT8/P3PjjTea//u//3OY3OAKdbtjxl+p5oyMjBL/Pjdv3uy0muFcrpQfFcGTMqkiuEPOVRR3zM+K4C6ZDNfiStlxtff5zP+PvTuPq6Js/P//PqAsLuCCAm6IZW65FCbSYlYkGZWmWZnmmn71hm6VOzXK1LSiLLdut7tFrVuNtI9Zt3pjiEuLqImaG1KaRt2KS6mIKajM749+nDwJyMiBwznn9Xw8zqNzZq6Zc11jzHvmmnPNZGYanTp1MmrVqmV4e3sbN954ozF69GjjzJkzNuspz32bM/eVrVmzxpB01T6gIm1ndzyGT0tLM8LDww1/f3/Dx8fHaNGihfHaa6/ZXIC3d52vVW9X7B9E6VSk7KjIOH8pH+58HmQvnE+hPJAd5tnjXMPdldf5hLsor3MGoADZUTLkhTlkQ+mQBfZnMQzDEAAAAAAAAAAAAAAAAAAAAAAAANyOh6MrAAAAAAAAAAAAAAAAAAAAAAAAAMdgYAkAAAAAAAAAAAAAAAAAAAAAAICbYmAJAAAAAAAAAAAAAAAAAAAAAACAm2JgCQAAAAAAAAAAAAAAAAAAAAAAgJtiYAkAAAAAAAAAAAAAAAAAAAAAAICbYmAJAAAAAAAAAAAAAAAAAAAAAACAm2JgCQAAAAAAAAAAAAAAAAAAAAAAgJtiYAkAAAAAAAAAAAAAAAAAAAAAAICbYmAJAAAAAAAAAAAAAAAAAAAAAACAm2JgCeAEsrKy9Oyzz6pJkyby9vZWw4YN9fDDDyslJUWS1LhxY1ksFlksFvn6+qpx48Z6/PHHtW7duqvW9fe//11hYWHy9vZWu3btCv2+pUuXql27dqpSpYpCQkL05ptvXlUmNzdXL774okJCQuTt7a3GjRtr/vz5dm03AOD6lXd2rFmzRh07dlT16tVVp04d9ezZU4cPH7bO37Bhg/X7rnxlZWWVRfMBANehvLNj165duuuuu+Tj46OGDRtqypQpNvOXL1+u9u3bq0aNGqpataratWunf//733ZvNwDAfuyZJZK0cOFCtWnTRj4+Pqpbt65iYmJs5pekDwsAULGUZ1Zs2LBB3bp1U3BwsPWcYvHixTbLT5w4schzFgBAxVDefVaGYeitt97STTfdJG9vb9WvX1+vvvqqdf7Ro0f11FNP6aabbpKHh4dGjhxZFs0GAJRCeWbH4cOHC70OvnnzZmuZd999V3fddZdq1qypmjVrKjIyUlu3bi2z9gMAzLNXdnz33Xfq3bu3GjZsKF9fX7Vo0UIzZ860KbN8+XLdf//9qlOnjvz8/BQREaE1a9bYlJk7d67atGkjPz8/a5n//ve/ZbsRADGwBKjwDh8+rLCwMK1bt05vvvmmdu/eraSkJN1zzz02F0gmTZqko0ePKiMjQx9++KFq1KihyMhIm06uAoMGDdITTzxR6Pf997//VZ8+fTRs2DDt2bNHc+bM0fTp0zVr1iybco8//rhSUlL0/vvvKyMjQx999JGaNWtm38YDAK5LeWfHoUOH1K1bN917773auXOn1qxZo5MnT6pHjx5Xlc3IyNDRo0etr7p169qv4QCA61be2ZGdna0uXbooJCREaWlpevPNNzVx4kS988471jK1atXSiy++qNTUVO3atUsDBw7UwIEDr+pUAwBUDPbOkmnTpunFF1/U888/r71792rt2rWKioqyzi9pHxYAoOIo76zYtGmT2rRpo//7v/+znlP069dPK1euLLc2AwBKp7z7rCRpxIgReu+99/TWW29p//79+vzzz9WhQwfr/NzcXNWpU0fjxo1T27Zt7dtgAECpOSI7JGnt2rU218HDwsKs8zZs2KDevXtr/fr1Sk1NVcOGDdWlSxf973//s1/DAQDXzZ7ZkZaWprp162rRokXau3evXnzxRcXHx9tcu/jyyy91//33a/Xq1UpLS9M999yjhx9+WDt27LCWadCggV5//XWlpaVp27Ztuvfee9WtWzft3bu3fDYK3JcBoELr2rWrUb9+fSMnJ+eqeadOnTIMwzBCQkKM6dOnXzV//PjxhoeHh7F///6r5k2YMMFo27btVdN79+5tPPbYYzbT3n77baNBgwZGfn6+YRiG8d///tfw9/c3fv31V/MNAgCUufLOjmXLlhmVKlUyLl++bJ32+eefGxaLxcjLyzMMwzDWr19vSLJ+PwCgYinv7JgzZ45Rs2ZNIzc31zpt7NixRrNmzYqt5y233GKMGzeu+MYAABzCnlny22+/Gb6+vsbatWuL/L6S9GEBACqW8s6Kwjz44IPGwIEDrZ+LOmcBAFQM5d1ntW/fPqNSpUqFLlOYu+++2xgxYkSJygIAykd5Z8ehQ4cMScaOHTtKXMdLly4Z1atXNz744IMSLwMAKDtllR0F/va3vxn33HNPsXVo2bKl8fLLLxdbpmbNmsZ7771XbBmgtHhiCVCB/fbbb0pKSlJMTIyqVq161fwaNWoUu/yIESNkGIY+++yzEn9nbm6ufHx8bKb5+vrql19+0U8//SRJ+vzzz9W+fXtNmTJF9evX10033aTnnntO58+fL/H3AADKhiOyIywsTB4eHlqwYIEuX76sM2fO6N///rciIyNVuXJlm7Lt2rVTcHCw7r//fn3zzTcl/g4AQNlxRHakpqaqU6dO8vLysk6LiopSRkaGTp06dVV5wzCUkpKijIwMderUqcTfAwAoH/bOkuTkZOXn5+t///ufWrRooQYNGujxxx/Xzz//bF2mJH1YAICKwxFZUZgzZ86oVq1a190OAED5cUSf1X/+8x81adJEK1euVGhoqBo3bqxnnnlGv/32m9nqAwAcwBHZUeCRRx5R3bp1deedd+rzzz8vtuzvv/+uixcvcm4CABVAeWTHtfqj8vPzdfbs2SLLXL58WYmJiTp37pwiIiKKrQ9QWgwsASqwAwcOyDAMNW/e/LqWr1WrlurWravDhw+XeJmoqCgtX75cKSkpys/P1/fff6+pU6dKko4ePSpJ+vHHH/X1119rz549+vTTTzVjxgx98skn+tvf/nZd9QQA2I8jsiM0NFRffPGFXnjhBXl7e6tGjRr65ZdftHTpUmuZ4OBgzZs3T//3f/+n//u//1PDhg3VuXNnbd++/brqCQCwH0dkR1ZWlgIDA22mFXzOysqyTjtz5oyqVasmLy8vRUdH65///Kfuv//+66onAKDs2DtLfvzxR+Xn5+u1116z9jv99ttvuv/++5WXlyepZH1YAICKwxFZ8VdLly7Vt99+q4EDB15vMwAA5cgRfVY//vijfvrpJy1btkwffvihFi5cqLS0ND322GPXVQcAQPlyRHZUq1ZNU6dO1bJly7Rq1Srdeeed6t69e7GDS8aOHat69eopMjLyuuoJALCfss6OTZs26eOPP9bQoUOLXMdbb72lnJwcPf744zbTd+/erWrVqsnb21vDhg3Tp59+qpYtW15XPYGSquToCgAommEYdlmHxWIpcfkhQ4bo4MGDeuihh3Tx4kX5+flpxIgRmjhxojw8/hiLlp+fL4vFosWLF8vf31+SNG3aND322GOaM2eOfH19S11vAMD1cUR2ZGVlaciQIerfv7969+6ts2fPavz48XrssceUnJwsi8WiZs2aqVmzZtZlbr/9dh08eFDTp0/Xv//971LXGQBw/RyRHSVVvXp17dy5Uzk5OUpJSVFcXJyaNGmizp072/27AADXz95Zkp+fr4sXL+rtt99Wly5dJEkfffSRgoKCtH79ekVFRZWoDwsAUHE4IiuutH79eg0cOFDvvvuuWrVqVeq6AADKniP6rPLz85Wbm6sPP/xQN910kyTp/fffV1hYmDIyMmyucwAAKh5HZEdAQIDi4uKsn2+77TYdOXJEb775ph555JGryr/++utKTEzUhg0brnoaLwCg/JVlduzZs0fdunXThAkTrP1Xf7VkyRK9/PLL+uyzz1S3bl2bec2aNdPOnTt15swZffLJJ+rfv782btzI4BKUKa6wARVY06ZNZbFYtH///uta/tdff9WJEycUGhpa4mUsFoveeOMN5eTk6KefflJWVpY6dOggSWrSpImkP+46X79+feugEklq0aKFDMPQL7/8cl11BQDYhyOyY/bs2fL399eUKVN0yy23qFOnTlq0aJFSUlK0ZcuWIpfr0KGDDhw4cF31BADYjyOyIygoSMeOHbOZVvA5KCjIOs3Dw0M33nij2rVrp3/84x967LHHlJCQcF31BACUHXtnSXBwsCTZXBypU6eOAgIClJmZKalkfVgAgIrDEVlRYOPGjXr44Yc1ffp09evX7zpbAAAob47oswoODlalSpWsg0qkP66DS7oqXwAAFY8jsqMw4eHhhV4Hf+utt/T666/riy++UJs2bUr1HQAA+yir7Ni3b5/uu+8+DR06VOPGjSt02cTERD3zzDNaunRpoU+x8vLy0o033qiwsDAlJCSobdu2mjlz5nXVEygpBpYAFVitWrUUFRWl2bNn69y5c1fNP336dLHLz5w5Ux4eHurevbvp7/b09FT9+vXl5eWljz76SBEREapTp44k6Y477tCRI0eUk5NjLf/999/Lw8NDDRo0MP1dAAD7cUR2/P7771fdEdjT01PSH3f3KsrOnTutPwIAADiOI7IjIiJCX375pS5evGidlpycrGbNmqlmzZpFLldw10gAQMVi7yy54447JEkZGRnWMr/99ptOnjypkJAQm2WL68MCAFQcjsqKDRs2KDo6Wm+88YaGDh1a+oYAAMqNI/qs7rjjDl26dEkHDx60Tvv+++8l6apzEQBAxePI31ldqbDr4FOmTNHkyZOVlJSk9u3bl2r9AAD7KYvs2Lt3r+655x71799fr776aqHLffTRRxo4cKA++ugjRUdHl6iuXCtHeajk6AoAKN7s2bN1xx13qEOHDpo0aZLatGmjS5cuKTk5WXPnzlV6erok6ezZs8rKytLFixd16NAhLVq0SO+9954SEhJ04403Wtd34MAB5eTkKCsrS+fPn9fOnTsl/XFXLy8vL508eVKffPKJOnfurAsXLmjBggVatmyZNm7caF3HU089pcmTJ2vgwIF6+eWXdfLkSY0ePVqDBg2Sr69vuW4fAMDVyjs7oqOjNX36dE2aNEm9e/fW2bNn9cILLygkJES33HKLJGnGjBkKDQ1Vq1atdOHCBb333ntat26dvvjii3LfPgCAq5V3djz11FN6+eWXNXjwYI0dO1Z79uzRzJkzNX36dOs6EhIS1L59e91www3Kzc3V6tWr9e9//1tz584t120DACgZe2bJTTfdpG7dumnEiBF655135Ofnp/j4eDVv3lz33HOPJJWoDwsAULGUd1asX79eDz30kEaMGKGePXsqKytL0h93e6xVq5a1XleesxSoXr26brjhhnLYKgCA4pR3n1VkZKRuvfVWDRo0SDNmzFB+fr5iYmJ0//332zzFpGC5nJwcnThxQjt37pSXl5fNk7QAAI5R3tnxwQcfyMvLy3pdfPny5Zo/f77ee+896zreeOMNjR8/XkuWLFHjxo2t5ybVqlVTtWrVymnLAACKYs/s2LNnj+69915FRUUpLi7Ous/39PS03hRryZIl6t+/v2bOnKnw8HBrGV9fX/n7+0uS4uPj1bVrVzVq1Ehnz57VkiVLtGHDBq1Zs6a8Nw/cjQGgwjty5IgRExNjhISEGF5eXkb9+vWNRx55xFi/fr1hGIYREhJiSDIkGV5eXkajRo2Mxx9/3Fi3bt1V67r77rutZa98HTp0yDAMwzhx4oTRsWNHo2rVqkaVKlWM++67z9i8efNV60lPTzciIyMNX19fo0GDBkZcXJzx+++/l+VmAACYUJ7ZYRiG8dFHHxm33HKLUbVqVaNOnTrGI488YqSnp1vnv/HGG8YNN9xg+Pj4GLVq1TI6d+5c6HcBABynvLPju+++M+68807D29vbqF+/vvH666/brOPFF180brzxRsPHx8eoWbOmERERYSQmJpblJgAAlJI9s+TMmTPGoEGDjBo1ahi1atUyHn30USMzM9M6v6R9WACAiqU8s6J///6Fnpfcfffd1jITJkwotMx9991X1psCAFBC5d1n9b///c/o0aOHUa1aNSMwMNAYMGCA8euvv9qsp7B1hISElOFWAACYUZ7ZsXDhQqNFixZGlSpVDD8/P6NDhw7GsmXLbNZx5fdd+ZowYUIZbwkAQEnZKzuK6mu68nyhqGzp37+/tcygQYOsdalTp45x3333GV988UU5bAm4O4thGEYpxqUAAAAAAAAAAAAAAAAAAAAAAADASXk4ugIAAAAAAAAAAAAAAAAAAAAAAABwDAaWAAAAAAAAAAAAAACLtoIuAADrpUlEQVQAAAAAAAAAuCkGlgAAAAAAAAAAAAAAAAAAAAAAALgpBpYAAAAAAAAAAAAAAAAAAAAAAAC4KQaWAAAAAAAAAAAAAAAAAAAAAAAAuCkGlgAAAAAAAAAAAAAAAAAAAAAAALgpBpYAAAAAAAAAAAAAAAAAAAAAAAC4KQaWAAAAAAAAAAAAAAAAAAAAAAAAuCkGlgAAAAAAAAAAAAAAAAAAAAAAALgpBpYAAAAAAAAAAAAAAAAAAAAAAAC4KQaWAAAAAAAAAAAAAAAAAAAAAAAAuKlKjq4AbOXn5+vIkSOqXr26LBaLo6sDANfFMAydPXtW9erVk4cHYxjLGtkBwBWQHeWL7ADgCsiO8kV2AHAFZEf5IjsAuAKyo3yRHQBcAdlRvsgOAK6A7ChfZAcAV1BW2cHAkgrmyJEjatiwoaOrAQB28fPPP6tBgwaOrobLIzsAuBKyo3yQHQBcCdlRPsgOAK6E7CgfZAcAV0J2lA+yA4ArITvKB9kBwJWQHeWD7ADgSuydHQwsqWCqV68u6Y9/aD8/PwfXBgCuT3Z2tho2bGjdp6FskR0AXAHZUb7IDgCugOwoX2QHAFdAdpQvsgOAKyA7yhfZAcAVkB3li+wA4ArIjvJFdgBwBWWVHQwsqWAKHq3l5+dHaAFwejwusHyQHQBcCdlRPsgOAK6E7CgfZAcAV0J2lA+yA4ArITvKB9kBwJWQHeWD7ADgSsiO8kF2AHAl9s4OD7uuDQAAAAAAAAAAAAAAAAAAAAAAAE6DJ5a4kMzMTJ08eVKSFBAQoEaNGjm4RgCAio7sAACYRXYAAMwiOwAApUGOAABKgrwAAJhFdgAAzCI7ALg6Bpa4iMzMTDVv3lznz5+XJPn6+mr//v0EFwCgSGQHAMAssgMAYBbZAQAoDXIEAFAS5AUAwCyyAwBgFtkBwB14OLoCsI+TJ0/q/Pnz6tGjh3r06KHz589bR0YCAFAYsgMAYBbZAQAwi+wAAJQGOQIAKAnyAgBgFtkBADCL7ADgDnhiiYsJCAhwdBUAAE6G7AAAmEV2AADMIjsAAKVBjgAASoK8AACYRXYAAMwiOwC4Mp5YAgAAAAAAAAAAAKeQnp6uzMxMR1cDAAAAAAAAAACXwsASAAAAAAAAAAAAVGg5OTmyWCzq27evmjdvzuASAAAAAAAAAADsiIElAAAAAAAAAAAAqNAuXLggwzDUqVMnnT9/XidPnnR0lQAAAAAAAAAAcBkMLAEAAAAAAAAAAIBT8Pf3d3QVAAAAAAAAAABwOQwsAQAAAAAAAAAAAAAAAAAAAAAAcFMMLAEAAAAAAAAAAAAAAAAAAAAAAHBTDCwBAAAAAAAAAAAAAAAAAAAAAABwUwwsAQAAAAAAAAAAAAAAAAAAAAAAcFMMLAEAAAAAAAAAAAAAAAAAAACc2MSJE2WxWGxezZs3t86/cOGCYmJiVLt2bVWrVk09e/bUsWPHbNaRmZmp6OhoValSRXXr1tXo0aN16dIlmzIbNmzQrbfeKm9vb914441auHDhVXWZPXu2GjduLB8fH4WHh2vr1q3XrP+yZcvUvHlz+fj4qHXr1lq9erXNfMMwNH78eAUHB8vX11eRkZH64YcfTGwhAEBxKpld4JtvvtHhw4d1+fJl67R+/frZtVIAANdCdgAAzCI7AABmkR0AALPIDgCAWWQHAMAssgMAYFZps6NVq1Zau3at9XOlSn/+THjUqFFatWqVli1bJn9/f8XGxqpHjx765ptvJEmXL19WdHS0goKCtGnTJh09elT9+vVT5cqV9dprr0mSDh06pOjoaA0bNkyLFy9WSkqKnnnmGQUHBysqKkqS9PHHHysuLk7z5s1TeHi4ZsyYoaioKGVkZKhu3bqF1nvTpk3q3bu3EhIS9NBDD2nJkiXq3r27tm/frptvvlmSNGXKFL399tv64IMPFBoaqpdeeklRUVHat2+ffHx8SryNAACFM/XEkt69e2vcuHFKS0vT7t27tXv3bu3Zs6es6gYAcAGlzQ5G0gOA+7Hnecfrr78ui8WikSNHWqeRHQDgeuizAgCYRXYAAMwiOwAAZpEdAACz7JEdlSpVUlBQkPUVEBAgSTpz5ozef/99TZs2Tffee6/CwsK0YMECbdq0SZs3b5YkffHFF9q3b58WLVqkdu3aqWvXrpo8ebJmz56tvLw8SdK8efMUGhqqqVOnqkWLFoqNjdVjjz2m6dOnW+swbdo0DRkyRAMHDlTLli01b948ValSRfPnzy+y3jNnztQDDzyg0aNHq0WLFpo8ebJuvfVWzZo1S9If18lnzJihcePGqVu3bmrTpo0+/PBDHTlyRCtWrDC1jQAAhTP1xJLvvvtO+/btK6u6AABckD2yg5H0AOBe7HXe8e233+pf//qX2rRpYzOd7AAA10OfFQDALLIDAGAW2QEAMIvsAACYZY/s+OGHH1SvXj35+PgoIiJCCQkJatSokdLS0nTx4kVFRkZayzZv3lyNGjVSamqqOnbsqNTUVLVu3VqBgYHWMlFRURo+fLj27t2rW265RampqTbrKChTcLPHvLw8paWlKT4+3jrfw8NDkZGRSk1NLbLeqampiouLu2q9BYNGDh06pKysLJvv9vf3V3h4uFJTU/Xkk08Wut7c3Fzl5uZaP2dnZxdZBwBwd6aeWNKhQwdlZGSUVV0AAC7IHtnBSHoAcC/2yI6cnBz16dNH7777rmrWrGmdTnYAgGuizwoAYBbZAQAwi+wAAJhFdgAAzCptdoSHh2vhwoVKSkrS3LlzdejQId111106e/assrKy5OXlpRo1atgsExgYqKysLElSVlaWzaCSgvkF84ork52drfPnz+vkyZO6fPlyoWUK1lGYotZ75fdeWZ+SrjchIUH+/v7WV8OGDYssCwDuztTAkp07d6pt27Zq27atOnTooNtuu00dOnQoq7oBAFyAPbKjYCR9kyZN1KdPH2VmZkrSNUfSSypyJH12drb27t1rLVPYSPqCdRSMpL+yTElH0he33muNpC9Kbm6usrOzbV4A4ErskR0xMTGKjo6+aj9MdpAdAFwTfVYAALPIDgCAWWQHAMAssgMAYFZps6Nr167q1auX2rRpo6ioKK1evVqnT5/W0qVLy7DWFVt8fLzOnDljff3888+OrhIAVFiVzBT+7LPPyqoeAAAXVdrsKBhJ36xZMx09elQvv/yy7rrrLu3Zs6fcRtKfOnWqyJH0+/fvL7LuZTmS/uWXXy5yPgA4u9JmR2JiorZv365vv/32qnlkBwC4JvqsAABmkR0AALPIDgCAWWQHAMAse2dHjRo1dNNNN+nAgQO6//77lZeXp9OnT9tcLz927JiCgoIkSUFBQdq6davNOo4dO2adV/DfgmlXlvHz85Ovr688PT3l6elZaJmCdRSmqPVe+b0F04KDg23KtGvXrsj1ent7y9vbu8j5AIA/mXpiSUhIiH777Td9/vnn+vzzz3Xq1CmFhISUVd0AAC6gtNnBSPqrMZIegKsrTXb8/PPPGjFihBYvXiwfH58yrqnzIDsAuDr6rAAAZpEdAACzyA4AgFlkBwDALHtnR05Ojg4ePKjg4GCFhYWpcuXKSklJsc7PyMhQZmamIiIiJEkRERHavXu3jh8/bi2TnJwsPz8/tWzZ0lrmynUUlClYh5eXl8LCwmzK5OfnKyUlxVqmMNdab2hoqIKCgmzKZGdna8uWLcWuFwBQcqYGlrz11lt65plnlJOTo5ycHA0ZMkTTpk0rq7oBAFyAvbPjypH0QUFB1pH0V/rraPXCRrMXzCuuTMFI+oCAgDIfSW9mvd7e3vLz87N5AYArKU12pKWl6fjx47r11ltVqVIlVapUSRs3btTbb7+tSpUqKTAwkOwgOwC4IPqsAABmlTY7vvzySz388MOqV6+eLBaLVqxYYTPfMAyNHz9ewcHB8vX1VWRkpH744QebMr/99pv69OkjPz8/1ahRQ4MHD1ZOTo5NmV27dumuu+6Sj4+PGjZsqClTplxVl2XLlql58+by8fFR69attXr16mvWf8OGDbr11lvl7e2tG2+8UQsXLryqzOzZs9W4cWP5+PgoPDz8qrtVAoC74bwDAGAW2QEAMKu02fHcc89p48aNOnz4sDZt2qRHH31Unp6e6t27t/z9/TV48GDFxcVp/fr1SktL08CBAxUREaGOHTtKkrp06aKWLVvq6aef1nfffac1a9Zo3LhxiomJsT71Y9iwYfrxxx81ZswY7d+/X3PmzNHSpUs1atQoaz3i4uL07rvv6oMPPlB6erqGDx+uc+fOaeDAgdYy/fr1U3x8vPXziBEjlJSUpKlTp2r//v2aOHGitm3bptjYWEmSxWLRyJEj9corr+jzzz/X7t271a9fP9WrV0/du3cvzWYHAPz/TA0s+fDDD7Vp0ybFx8crPj5eX3/9daEXGwAAKGDv7GAkPQC4vtJkx3333afdu3dr586d1lf79u3Vp08f63uyAwBcD31WAACzSpsd586dU9u2bTV79uxC50+ZMkVvv/225s2bpy1btqhq1aqKiorShQsXrGX69OmjvXv3Kjk5WStXrtSXX36poUOHWudnZ2erS5cuCgkJUVpamt58801NnDhR77zzjrXMpk2b1Lt3bw0ePFg7duxQ9+7d1b17d+3Zs6fIuh86dEjR0dG65557tHPnTo0cOVLPPPOM1qxZYy3z8ccfKy4uThMmTND27dvVtm1bRUVF2ZwnAYC74bwDAGAW2QEAMKu02fHLL7+od+/eatasmR5//HHVrl1bmzdvVp06dSRJ06dP10MPPaSePXuqU6dOCgoK0vLly63Le3p6auXKlfL09FRERIT69u2rfv36adKkSdYyoaGhWrVqlZKTk9W2bVtNnTpV7733nqKioqxlnnjiCb311lsaP3682rVrp507dyopKUmBgYHWMpmZmTp69Kj18+23364lS5bonXfeUdu2bfXJJ59oxYoVuvnmm61lxowZo2effVZDhw7VbbfdppycHCUlJcnHx8fUdgYAFK6S2QUuXLhgHXl45QUQAACKUprseO655/Twww8rJCRER44c0YQJEwodSV+rVi35+fnp2WefLXIk/ZQpU5SVlVXoSPpZs2ZpzJgxGjRokNatW6elS5dq1apV1nrExcWpf//+at++vTp06KAZM2YUOpK+fv36SkhIkPTHSPq7775bU6dOVXR0tBITE7Vt2zbrxf8rR9I3bdpUoaGheumllxhJDwC6/uyoXr26TceSJFWtWlW1a9e2Tic7AMA10WcFADCrNNnRtWtXde3atdB5hmFoxowZGjdunLp16ybpjx8FBAYGasWKFXryySeVnp6upKQkffvtt2rfvr0k6Z///KcefPBBvfXWW6pXr54WL16svLw8zZ8/X15eXmrVqpV27typadOmWQegzJw5Uw888IBGjx4tSZo8ebKSk5M1a9YszZs3r9D6zZs3T6GhoZo6daokqUWLFvr66681ffp06w8Apk2bpiFDhljPX+bNm6dVq1Zp/vz5ev75501tKwBwJZx3AADMIjsAAGaVJjsSExOLne/j46PZs2cXebMUSQoJCbnmE3E7d+6sHTt2FFsmNjbW+rSRwmzYsOGqab169VKvXr2KXMZisWjSpEk2A10AAPZj6oklo0ePVlhYmIYNG6b/9//+n9q3b68xY8aUePmJEyfKYrHYvJo3b26df+HCBcXExKh27dqqVq2aevbsqWPHjtmsIzMzU9HR0apSpYrq1q2r0aNH69KlSzZlyuoR7td6nHxJHm0PAO6mtNnBSHoAcD+lzY5rITsAwPWUdXYAAFxPWWbHoUOHlJWVpcjISOs0f39/hYeHKzU1VZKUmpqqGjVqWAeVSFJkZKQ8PDy0ZcsWa5lOnTrJy8vLWiYqKkoZGRk6deqUtcyV31NQpuB7CnOtZfLy8pSWlmZTxsPDQ5GRkcWuNzc3V9nZ2TYvAHAlnHcAAMwiOwAAZpEdAABHMvXEkqefflr33Xefvv32W0l/DBQJDg429YWtWrXS2rVr/6xApT+rMGrUKK1atUrLli2Tv7+/YmNj1aNHD33zzTeSpMuXLys6OlpBQUHatGmTjh49qn79+qly5cp67bXXJP35CPdhw4Zp8eLFSklJ0TPPPKPg4GDrj7wKHuE+b948hYeHa8aMGdaLMXXr1i203gWPk09ISNBDDz2kJUuWqHv37tq+fbv1R14Fj7b/4IMPrHcOjoqK0r59+/iRFwC3VdrsYCQ9ALgfe5x3XOmv+2eyAwBcj72zAwDg+soyO7KysiTJZlB5weeCeVlZWVddj6hUqZJq1aplUyY0NPSqdRTMq1mzprKysor9nqLqV9gy2dnZOn/+vE6dOqXLly8XWmb//v1FrjchIUEvv/xykfMBwNlx3gEAMIvsAACYRXYAABypRANLDh06pNDQUO3bt0+S1LRpU0nSqVOndOrUKbVs2bLkX1ipkoKCgq6afubMGb3//vtasmSJ7r33XknSggUL1KJFC23evFkdO3bUF198oX379mnt2rUKDAxUu3btNHnyZI0dO1YTJ06Ul5dXmT3C/VqPky/Jo+0BwB3ZIzsAAO6F7AAAmEV2AADMIjvsLz4+XnFxcdbP2dnZatiwYZl9X3p6uiQpICBAjRo1KrPvAYACZAcAwCyyAwBgFtkBAHCkEg0sSUhI0DvvvKOYmJir5lksFq1bt67EX/jDDz+oXr168vHxUUREhBISEtSoUSOlpaXp4sWLNo9Wb968uRo1aqTU1FR17NhRqampat26tc1dsqKiojR8+HDt3btXt9xyS5GPcB85cqSkPx/hHh8fb51fkke4p6am2lwQKVjvihUrJF370fZFDSzJzc1Vbm6u9TOPhgfgauyRHQAA90J2AADMIjucCz8EBlARlGV2FNxc69ixYzZ3lDx27JjatWtnLXP8+HGb5S5duqTffvvNunxQUJCOHTtmU6bg87XKFHaDryvrV9gyfn5+8vX1laenpzw9PU2v19vbW97e3kXOt5fff/9dFotFffv2lST5+vpq//79ZAqAMlfa7Jg4ceJVT3Zq1qyZ9WlQFy5c0D/+8Q8lJiYqNzdXUVFRmjNnjs218czMTA0fPlzr169XtWrV1L9/fyUkJKhSpT8v+2/YsEFxcXHau3evGjZsqHHjxmnAgAE23zt79my9+eabysrKUtu2bfXPf/5THTp0KLb+y5Yt00svvaTDhw+radOmeuONN/Tggw9a5xuGoQkTJujdd9/V6dOndccdd2ju3LnWH8QBgDuizwoAYBbZAQBwpBINLHnnnXckSUuXLlWdOnVs5p04caLEXxYeHq6FCxeqWbNmOnr0qF5++WXddddd2rNnj7KysuTl5aUaNWrYLPPXR8MX9uj1gnnFlSntI9yv9Tj5kjzavjA8Gh6AqyttdgAA3A/ZAQAwi+xwDjk5OfwQGECFUZbZERoaqqCgIKWkpFgHkmRnZ2vLli0aPny4JCkiIkKnT59WWlqawsLCJEnr1q1Tfn6+wsPDrWVefPFFXbx4UZUrV5YkJScnq1mzZqpZs6a1TEpKivXmWgVlIiIiiqxfRESEVq9ebTPtymW8vLwUFhamlJQUde/eXZKUn5+vlJQUxcbGlm7j2EFeXp4Mw1CPHj0kScuXL9fJkyfJEwBlzh7Z0apVK61du9b6+coBIaNGjdKqVau0bNky+fv7KzY2Vj169NA333wjSbp8+bKio6MVFBSkTZs26ejRo+rXr58qV66s1157TdIfN0OMjo7WsGHDtHjxYqWkpOiZZ55RcHCwoqKiJEkff/yx4uLiNG/ePIWHh2vGjBmKiopSRkaG6tatW2i9N23apN69eyshIUEPPfSQlixZou7du2v79u26+eabJUlTpkzR22+/rQ8++EChoaF66aWXFBUVpX379snHx8fUdgIAV0GfFQDALLIDAOBIHmYKF3Q2XWtaUbp27apevXqpTZs2ioqK0urVq3X69GktXbrUTDVcSnx8vM6cOWN9/fzzz46uEgDYVWmzAwDgfsgOAIBZZIdzuHDhgvWHwD169ND58+d18uRJR1cLgJsqbXbk5ORo586d2rlzp6Q/fsi7c+dOZWZmymKxaOTIkXrllVf0+eefa/fu3erXr5/q1atnHajRokULPfDAAxoyZIi2bt2qb775RrGxsXryySdVr149SdJTTz0lLy8vDR48WHv37tXHH3+smTNn2jxdfcSIEUpKStLUqVO1f/9+TZw4Udu2bbMZABIfH69+/fpZPw8bNkw//vijxowZo/3792vOnDlaunSpRo0aZS0TFxend999Vx988IHS09M1fPhwnTt3TgMHDizxNiprAQEBCggIcHQ1ALgRe5x3VKpUSUFBQdZXwX7szJkzev/99zVt2jTde++9CgsL04IFC7Rp0yZt3rxZkvTFF19o3759WrRokdq1a6euXbtq8uTJmj17tvLy8iRJ8+bNU2hoqKZOnaoWLVooNjZWjz32mKZPn26tw7Rp0zRkyBANHDhQLVu21Lx581SlShXNnz+/yHrPnDlTDzzwgEaPHq0WLVpo8uTJuvXWWzVr1ixJfzytZMaMGRo3bpy6deumNm3a6MMPP9SRI0e0YsUKU9sIAFwJfVYAALPIDgCAI5XoiSUHDhxQRkaGsrOzbe5ilZ2drdzc3Ov+8ho1auimm27SgQMHdP/99ysvL0+nT5+2eWrJlY9WDwoK0tatW23WUdLHvpf2Ee7Xepx8SR5tX5jyejQ8ADjCmjVr7J4dAADXRnYAAMwiO5wPPwIG4Gj2yI5t27bpnnvusX4uGOzRv39/LVy4UGPGjNG5c+c0dOhQnT59WnfeeaeSkpJs7ti+ePFixcbG6r777pOHh4d69uypt99+2zrf399fX3zxhWJiYhQWFqaAgACNHz9eQ4cOtZa5/fbbtWTJEo0bN04vvPCCmjZtqhUrVljvHi9JR48eVWZmpvVzaGioVq1apVGjRmnmzJlq0KCB3nvvPZsfKTzxxBM6ceKExo8fr6ysLLVr105JSUlXPbUdANyFvc47fvjhB9WrV08+Pj6KiIhQQkKCGjVqpLS0NF28eFGRkZHWss2bN1ejRo2Umpqqjh07KjU1Va1bt7bZF0dFRWn48OHau3evbrnlFqWmptqso6BMwZOt8vLylJaWpvj4eOt8Dw8PRUZGKjU1tch6p6am2gxsLFhvwaCRQ4cOKSsry+a7/f39FR4ertTUVD355JOFrjc3N9dmG2ZnZxdZBwBwNvbIjokTJ+rll1+2mdasWTPt379f0h838fjHP/6hxMRE5ebmKioqSnPmzLHJiszMTA0fPlzr169XtWrV1L9/fyUkJNg8NWvDhg2Ki4vT3r171bBhQ40bN04DBgyw+d7Zs2frzTffVFZWltq2bat//vOf6tChQ7H1X7ZsmV566SUdPnxYTZs21RtvvKEHH3zQOt8wDE2YMEHvvvuuTp8+rTvuuENz585V06ZNS7yNAMCVcL0DAOBoJRpYsnfvXq1YsUKnTp3SsmXLrNOrV6+ud99997q/PCcnRwcPHtTTTz+tsLAwVa5cWSkpKerZs6ckKSMjQ5mZmdbHr0dEROjVV1/V8ePHrY/hTU5Olp+fn1q2bGktUxaPcL/W4+RL8mh7AHA3n332md2zAwDg2sgOAIBZ9siOhIQELV++XPv375evr69uv/12vfHGG2rWrJm1DBfqAcB12CM7OnfuLMMwipxvsVg0adIkTZo0qcgytWrV0pIlS4r9njZt2uirr74qtkyvXr3Uq1evIucvXLjwqmmdO3fWjh07il1vbGxssddNAMCd2CM7wsPDtXDhQjVr1kxHjx7Vyy+/rLvuukt79uxRVlaWvLy8bG7AKEmBgYHKysqSJGVlZV01wK/g87XKZGdn6/z58zp16pQuX75caJmCHykXpqj1Xvm9V9ansDKFSUhIuOoH0wDgKux1vaNVq1Zau3at9fOV/UyjRo3SqlWrtGzZMvn7+ys2NlY9evTQN998I0m6fPmyoqOjFRQUpE2bNuno0aPq16+fKleurNdee03SH4MDo6OjNWzYMC1evFgpKSl65plnFBwcbB18/vHHHysuLk7z5s1TeHi4ZsyYoaioKGVkZFh/v/VXmzZtUu/evZWQkKCHHnpIS5YsUffu3bV9+3brQPgpU6bo7bff1gcffKDQ0FC99NJLioqK0r59+2wG5QOAu+BaOQDA0Uo0sKRbt27q1q2btm7des2L2MV57rnn9PDDDyskJERHjhzRhAkT5Onpqd69e8vf31+DBw9WXFycatWqJT8/Pz377LOKiIhQx44dJUldunRRy5Yt9fTTT2vKlCnKysrSuHHjFBMTY33qx7BhwzRr1iyNGTNGgwYN0rp167R06VKtWrXKWo+4uDj1799f7du3V4cOHTRjxoyrHuHer18/1a9fXwkJCZL+eJz83XffralTpyo6OlqJiYnatm2b3nnnHUmyebR906ZNrSc8Vz7aHgDczZw5c7R///5SZQcAwL2QHQAAs+yRHRs3blRMTIxuu+02Xbp0SS+88IK6dOmiffv2qWrVqpK4UA8AroTzDgCAWfbIjq5du1rft2nTRuHh4QoJCdHSpUvl6+trj2o6nfj4eJsnoWRnZ6thw4YOrBEA2I+9zjsqVaqkoKCgq6afOXNG77//vpYsWaJ7771XkrRgwQK1aNFCmzdvVseOHfXFF19o3759Wrt2rQIDA9WuXTtNnjxZY8eO1cSJE+Xl5aV58+YpNDRUU6dOlSS1aNFCX3/9taZPn27tr5o2bZqGDBli/V3VvHnztGrVKs2fP1/PP/98ofWeOXOmHnjgAY0ePVqSNHnyZCUnJ2vWrFmaN2+eDMPQjBkzNG7cOHXr1k2S9OGHHyowMFArVqwo8mlXAODK6LMCADhaiQaWFGjevLkSEhK0b98+m8drLV26tETL//LLL+rdu7d+/fVX1alTR3feeac2b96sOnXqSJKmT59ufdz7lXd+LODp6amVK1dq+PDhioiIUNWqVdW/f3+bO37Z6xHumZmZ8vDwsH4uyePkS/JoewBwN6XNDgCA+yE7AABmlTY7kpKSbD4vXLhQdevWVVpamjp16sSFegBwQZx3AADMsnd21KhRQzfddJMOHDig+++/X3l5eTp9+rTNU0uOHTtm/TFxUFCQtm7darOOY8eOWecV/Ldg2pVl/Pz85OvrK09PT3l6ehZaprAfLRcoar1Xfm/BtODgYJsy7dq1K3K93t7e1htIAoArskd2/PDDD6pXr558fHwUERGhhIQENWrUSGlpabp48aIiIyNtvq9Ro0ZKTU1Vx44dlZqaqtatW9v8HioqKkrDhw/X3r17dcsttyg1NdVmHQVlRo4cKUnKy8tTWlqa4uPjrfM9PDwUGRmp1NTUIuudmppqM3iwYL0rVqyQ9McNWLKysmy+29/fX+Hh4UpNTS2yvyo3N9dmW2ZnZxdZBwBwRvRZAQAcyePaRf7Up08fVatWTVu2bFH//v1lsVgUEhJS4uUTExN15MgR5ebm6pdfflFiYqJuuOEG63wfHx/Nnj1bv/32m86dO6fly5df1YEVEhKi1atX6/fff9eJEyf01ltv2TzmUfrzEe65ubk6ePCgBgwYcFVdYmNj9dNPPyk3N1dbtmxReHi4zfwNGzZc9Xj4Xr16KSMjQ7m5udqzZ48efPBBm/kFj7bPysrShQsXtHbtWt10000l3j4A4IpKmx0AAPdDdgAAzLJ3dpw5c0aSVKtWLUm65oV6SUVeqM/OztbevXutZQq7UF+wjoIL9VeWKemF+uLWe60L9YXJzc1Vdna2zQsAXAnnHQAAs+ydHTk5OTp48KCCg4MVFhamypUrKyUlxTo/IyNDmZmZioiIkCRFRERo9+7dOn78uLVMcnKy/Pz81LJlS2uZK9dRUKZgHV5eXgoLC7Mpk5+fr5SUFGuZwlxrvaGhoQoKCrIpk52drS1bthS7XgBwdaXNjvDwcC1cuFBJSUmaO3euDh06pLvuuktnz55VVlaWvLy8bAYkSlJgYKCysrIkSVlZWTZ9VQXzC+YVVyY7O1vnz5/XyZMndfny5ULLFKyjMEWt98rvvbI+JV1vQkKC/P39rS+edAXA1dBnBQBwJFMDS44cOaJnn31WPj4+io6OVmJiojZu3FhWdQMAuACyAwBgFtkBADDLntmRn5+vkSNH6o477rA+qdYdL9RzkR6Aq+O8AwBgVmmz47nnntPGjRt1+PBhbdq0SY8++qg8PT3Vu3dv+fv7a/DgwYqLi9P69euVlpamgQMHKiIiQh07dpQkdenSRS1bttTTTz+t7777TmvWrNG4ceMUExNjferHsGHD9OOPP2rMmDHav3+/5syZo6VLl2rUqFHWesTFxendd9/VBx98oPT0dA0fPlznzp2zPjVRkvr162dzZ/oRI0YoKSlJU6dO1f79+zVx4kRt27ZNsbGxkv64AePIkSP1yiuv6PPPP9fu3bvVr18/1atXT927dy/NZgcAp1ba7Ojatat69eqlNm3aKCoqSqtXr9bp06fd+q718fHxOnPmjPX1888/O7pKAGBX9FkBAByp0rWLXFH4/38ySGBgoFJSUlSvXj39+uuvZVIxAIBrIDsAAGaRHQAAs+yZHTExMdqzZ4++/vpre1bR6cTHxysuLs76OTs7m8ElAFwK5x0AALNKmx2//PKLevfurV9//VV16tTRnXfeqc2bN6tOnTqSpOnTp8vDw0M9e/ZUbm6uoqKiNGfOHOvynp6eWrlypYYPH66IiAhVrVpV/fv316RJk6xlQkNDtWrVKo0aNUozZ85UgwYN9N577ykqKspa5oknntCJEyc0fvx4ZWVlqV27dkpKSrIZiJ6ZmSkPjz/vUXn77bdryZIlGjdunF544QU1bdpUK1assA7Gl6QxY8bo3LlzGjp0qE6fPq0777xTSUlJ8vHxMbGVAcC12Pu8o0aNGrrpppt04MAB3X///crLy9Pp06dtboZy7NgxBQUFSZKCgoK0detWm3UcO3bMOq/gvwXTrizj5+cnX19feXp6ytPTs9AyBesoTFHrvfJ7C6YFBwfblGnXrl2R6/X29rYOqAQAV0SfFQDAkUwNLHnhhRd05swZTZ06VX//+9919uxZTZs2razqBgBwAWQHAMAssgMAYJa9siM2NlYrV67Ul19+qQYNGlinBwUFud2Fei7SA3B1nHcAAMwqbXYkJiYWO9/Hx0ezZ8/W7NmziywTEhKi1atXF7uezp07a8eOHcWWiY2NtT5tpDAbNmy4alqvXr3Uq1evIpexWCyaNGmSzUAXAHB39j7vyMnJ0cGDB/X0008rLCxMlStXVkpKinr27ClJysjIUGZmpiIiIiRJERERevXVV3X8+HHVrVtXkpScnCw/Pz+1bNnSWuav2ZKcnGxdh5eXl8LCwpSSkmJ9ClV+fr5SUlKKzZKIiAilpKRo5MiRha43NDRUQUFBSklJsfZPZWdna8uWLRo+fPh1byMAcHb0WQEAHMnUwJJu3bpJktq0aVNoZxIAAH9FdgAAzCI7AABmlTY7DMPQs88+q08//VQbNmxQaGiozXwu1AOA6+G8AwBgFtkBADCrtNnx3HPP6eGHH1ZISIiOHDmiCRMmyNPTU71795a/v78GDx6suLg41apVS35+fnr22WcVERGhjh07SpK6dOmili1b6umnn9aUKVOUlZWlcePGKSYmxnpDkWHDhmnWrFkaM2aMBg0apHXr1mnp0qVatWqVtR5xcXHq37+/2rdvrw4dOmjGjBk6d+6cBg4caC3Tr18/1a9fXwkJCZKkESNG6O6779bUqVMVHR2txMREbdu2Te+8846kPwYkjhw5Uq+88oqaNm2q0NBQvfTSS6pXr561XwwA3BHnHQAARzI1sOTgwYOaNWuWDh8+rMuXL1unf/7553avGADANZAdAACzyA4AgFmlzY6YmBgtWbJEn332mapXr66srCxJkr+/v3x9fblQDwAuiPOOii0zM1MnT55Uenq6o6sCAFZkBwDArNJmxy+//KLevXvr119/VZ06dXTnnXdq8+bNqlOnjiRp+vTp8vDwUM+ePZWbm6uoqCjNmTPHurynp6dWrlyp4cOHKyIiQlWrVlX//v1tni4VGhqqVatWadSoUZo5c6YaNGig9957T1FRUdYyTzzxhE6cOKHx48crKytL7dq1U1JSkgIDA61lMjMz5eHhYf18++23a8mSJRo3bpxeeOEFNW3aVCtWrNDNN99sLTNmzBidO3dOQ4cO1enTp3XnnXcqKSlJPj4+JrYyALgWzjsAAI5kamDJo48+qtjYWD3++OM2JwMAABSF7AAAmEV2AADMKm12zJ07V5LUuXNnm+kLFizQgAEDJHGhHgBcDecdFVdmZqaaN2+u8+fPO7oqAGCD7AAAmFXa7EhMTCx2vo+Pj2bPnq3Zs2cXWSYkJOSqJ+j+VefOnbVjx45iy8TGxhb7RN3C7qrfq1cv9erVq8hlLBaLJk2aZNN/BgDujvMOAIAjmRpYUqVKFQ0dOrSs6gIAcEFkBwDALLIDAGBWabPDMIxrluFCPQC4Fs47Kq6TJ0/q/Pnz6tGjh06dOqX169c7ukoAIInsAACYR3YAAMwiOwAAjmRqYEl8fLzGjh2ryMhIeXt7W6d36tTJ7hUDALgGsgMAYBbZAQAwi+wAAJhFdlR8AQEBjq4CANggOwAAZpEdAACzyA4AgCOZGliyZs0abdiwQQcOHLA+ZstisRBaAIAikR0AALPIDgCAWWQHAMAssgMAYBbZAQAwi+wAAJhFdgAAHMnUwJK1a9cqIyNDFoulrOoDAHAxZAcAwCyyAwBgFtkBADCL7AAAmEV2AADMIjsAAGaRHQAAR/IwU7hDhw46ePBgWdUFAOCCyA4AgFlkBwDALLIDAGAW2QEAMIvsAACYRXYAAMwiOwAAjmTqiSV79uzRzTffrGbNmsnb21uGYchisWjr1q1lVT8AgJMjOwAAZpEdAACzyA4AgFlkBwDALLIDAGAW2QEAMIvsAAA4kqmBJZ999llZ1QMA4KLIDgCAWWQHAMAssgMAYBbZ4VrS09MlSQEBAWrUqJGDawPAVZEdAACzyA4AgFlkBwDAkUo0sCQ3N1fe3t6qU6dOWdcHAOBiyA4AgFlkBwDALLIDAGAW2eEacnJyZLFY1LdvX0mSr6+v9u/fz+ASAGWC7AAAmEV2AADMIjsAAI5UooElPXv21MqVK9WqVStZLBbr47UK/vvjjz+WdT0BAE6K7AAAmEV2AADMIjsAAGaRHa7hwoULMgxDPXr0kCQtX75cJ0+eZGAJgDJBdgAAzCI7AABmkR0AAEcq0cCSlStXSpIOHTpUppUBALgesgMAYBbZAQAwi+wAAJhFdriWgIAAR1cBgBsgOwAAZpEdAACzyA4AgCN5mCncoUOHEk0DAKAA2QEAMIvsAACYRXYAAMwiOwAAZpEdAACzyA4AgFlkBwDAkUr0xJKTJ0/q2LFjysnJUXp6ugzDkCRlZ2crOzu7TCsIAHBe6enpZAcAwBSyAwBgFtkBADCL7AAAmEV2AADMIjsAAGaRHQAARyvRwJJVq1Zp4cKF+vnnnxUTE2MNrerVq+u1114r0woCAJzX6NGjyQ4AgClkBwDALLIDAGAW2QEAMIvsAACYRXYAAMwiOwAAjlaigSX9+/dX//79tWLFCnXv3r2MqwQAcBUrV67UunXryA4AQImRHQAAs8gOAIBZZAcAwCyyAwBgFtkBADCL7AAAOJqHmcL79u3T2bNndfnyZfXq1Us33XSTVqxYUUZVAwC4ArIDAGAW2QEAMIvsAACYRXYAAMwiOwAAZpEdAACzyA4AgCOZGliybNkyVa9eXStXrpSPj4++/vprvfzyy2VVNwCACyA7AABmkR0AALPIDgCAWWQHAMAssgMAYBbZAQAwi+wAADiSqYEl58+flyR99tlnevLJJ1W3bl0ZhlEmFQMAuIbSZkdCQoJuu+02Va9eXXXr1lX37t2VkZFhU6Zz586yWCw2r2HDhtmUyczMVHR0tKpUqaK6detq9OjRunTpkk2ZDRs26NZbb5W3t7duvPFGLVy48Kr6zJ49W40bN5aPj4/Cw8O1devWa7Zh2bJlat68uXx8fNS6dWutXr3aZr5hGBo/fryCg4Pl6+uryMhI/fDDDyXcQgDgesojOy5cuKCYmBjVrl1b1apVU8+ePXXs2DGbMmQHADgP+qwAAGaRHQAAs8gOAIBZZAcAwCx+Z8W1cgBwJFMDSx5++GGFhIQoLS1NXbp00YkTJ+Tt7V1WdQMAuIDSZsfGjRsVExOjzZs3Kzk5WRcvXlSXLl107tw5m3JDhgzR0aNHra8pU6ZY512+fFnR0dHKy8vTpk2b9MEHH2jhwoUaP368tcyhQ4cUHR2te+65Rzt37tTIkSP1zDPPaM2aNdYyH3/8seLi4jRhwgRt375dbdu2VVRUlI4fP15k/Tdt2qTevXtr8ODB2rFjh7p3767u3btrz5491jJTpkzR22+/rXnz5mnLli2qWrWqoqKidOHChRJvJwBwJeWRHaNGjdJ//vMfLVu2TBs3btSRI0fUo0cP63yyAwCcC31WAACzyA4AgFlkBwDALLIDAGAWv7PiWjkAOJKpgSVvvvmmduzYoe3bt6ty5cqqUqWKPvvss7KqGwDABZQ2O5KSkjRgwAC1atVKbdu21cKFC5WZmam0tDSbclWqVFFQUJD15efnZ533xRdfaN++fVq0aJHatWunrl27avLkyZo9e7by8vIkSfPmzVNoaKimTp2qFi1aKDY2Vo899pimT59uXc+0adM0ZMgQDRw4UC1bttS8efNUpUoVzZ8/v8j6z5w5Uw888IBGjx6tFi1aaPLkybr11ls1a9YsSX+Mop8xY4bGjRunbt26qU2bNvrwww915MgRrVixosTbCQBcSVlnx5kzZ/T+++9r2rRpuvfeexUWFqYFCxZo06ZN2rx5sySyAwCcDX1WAACzyA4AgFlkBwDALLIDAGAWv7PiWjkAOJKpgSWnT5/W66+/rqefflqS9Msvv+irr74qk4oBAFyDvbPjzJkzkqRatWrZTF+8eLECAgJ08803Kz4+Xr///rt1Xmpqqlq3bq3AwEDrtKioKGVnZ2vv3r3WMpGRkTbrjIqKUmpqqiQpLy9PaWlpNmU8PDwUGRlpLVOYa6330KFDysrKsinj7++v8PDwYtcLAK6srLMjLS1NFy9etNn3Nm/eXI0aNbLue8kOAHAu9FkBAMwqj+yYOHGiLBaLzat58+bW+RcuXFBMTIxq166tatWqqWfPnjp27JjNOjIzMxUdHa0qVaqobt26Gj16tC5dumRTZsOGDbr11lvl7e2tG2+8UQsXLrxm3Xbt2qW77rpLPj4+atiwoc1dKQssW7ZMzZs3l4+Pj1q3bq3Vq1df34YAABfBeQcAwCyyAwBgFr+zsv+18tzcXGVnZ9u8AACFMzWwpH///mrRooX1sVKhoaGaPHlymVQMAOAa7Jkd+fn5GjlypO644w7dfPPN1ulPPfWUFi1apPXr1ys+Pl7//ve/1bdvX+v8rKwsm5MdSdbPWVlZxZbJzs7W+fPndfLkSV2+fLnQMgXrKExR673ye6+sT0nWywkPAFdX1tmRlZUlLy8v1ahRw6bsX/fPZAcAOA/6rAAAZpVXdrRq1UpHjx61vr7++mvrvFGjRuk///mPli1bpo0bN+rIkSPq0aOHdf7ly5cVHR2tvLw8bdq0SR988IEWLlyo8ePHW8scOnRI0dHRuueee7Rz506NHDlSzzzzjNasWVNknbKzs9WlSxeFhIQoLS1Nb775piZOnKh33nnHWmbTpk3q3bu3Bg8erB07dqh79+7q3r27dXsBgDvivAMAYBbZAQAwi99Z2f9aeUJCgvz9/a2vhg0bFvn9AODuTA0sOXLkiAYOHChPT09JkpeXlzw8Sr6KhIQE3Xbbbapevbrq1q2r7t27KyMjw6ZM586dr7qD17Bhw2zK2OsOXbNnz1bjxo3l4+Oj8PBwbd269ZptuNYdugzD0Pjx4xUcHCxfX19FRkbqhx9+KOEWAgDXU9rsuFJMTIz27NmjxMREm+lDhw5VVFSUWrdurT59+ujDDz/Up59+qoMHD5a6/hURJzwAXF15ZIe7ITsAuDp7ZgcAwD2UV3ZUqlRJQUFB1ldAQICkP+4W+f7772vatGm69957FRYWpgULFmjTpk3avHmzJOmLL77Qvn37tGjRIrVr105du3bV5MmTNXv2bOXl5UmS5s2bp9DQUE2dOlUtWrRQbGysHnvsMU2fPr3IOi1evFh5eXmaP3++WrVqpSeffFJ///vfNW3aNGuZmTNn6oEHHtDo0aPVokULTZ48WbfeeqtmzZpl921kb+np6dq+fbsyMzMdXRUALobzDgCAWWQHAMAsfmdlf/Hx8Tpz5oz19fPPPzu6SgBQYZlKnKpVq+r06dOyWCySpO3bt6t69eolXn7jxo2KiYnR5s2blZycrIsXL6pLly46d+6cTbkhQ4bY3MHrykew2+sOXR9//LHi4uI0YcIEbd++XW3btlVUVJSOHz9eZP1LcoeuKVOm6O2339a8efO0ZcsWVa1aVVFRUbpw4UKJtxMAuJLSZkeB2NhYrVy5UuvXr1eDBg2KLRseHi5JOnDggCQpKChIx44dsylT8DkoKKjYMn5+fvL19VVAQIA8PT0LLVOwjsIUtd4rv/fK+pRkvZzwAHB1ZZ0dQUFBysvL0+nTp23K/3X/THYAgPOwV3YAANxHeWXHDz/8oHr16qlJkybq06ePdbBDWlqaLl68qMjISGvZ5s2bq1GjRkpNTZUkpaamqnXr1jZ3YIyKilJ2drb27t1rLXPlOgrKFKyjMKmpqerUqZO8vLxslsnIyNCpU6eue72OlpOTI4vFor59+yosLEzNmzdncAkAuyptdnATRgBwP/RZAQDM4ndW9r9W7u3tLT8/P5sXAKBwpgaWTJ06Vd27d9ehQ4d033336cknn9Tbb79d4uWTkpI0YMAAtWrVSm3bttXChQuVmZmptLQ0m3JVqlSxuYPXlTtye92ha9q0aRoyZIgGDhyoli1bat68eapSpYrmz59fZP2vdYcuwzA0Y8YMjRs3Tt26dVObNm304Ycf6siRI1qxYkWJtxMAuJLSZodhGIqNjdWnn36qdevWKTQ09JrL7Ny5U5IUHBwsSYqIiNDu3bttBg8mJyfLz89PLVu2tJZJSUmxWU9ycrIiIiIk/XEHgLCwMJsy+fn5SklJsZYpzLXWGxoaqqCgIJsy2dnZ2rJlS5Hr5YQHgKsr6+wICwtT5cqVbfa9GRkZyszMtO57yQ4AcC6lzQ4AgPspj+wIDw/XwoULlZSUpLlz5+rQoUO66667dPbsWWVlZcnLy0s1atSwWSYwMFBZWVmSpKysLJtBJQXzC+YVVyY7O1vnz58vtF6lWW/B/MLk5uYqOzvb5lWeLly4IMMw1KNHD/Xo0UPnz5/XyZMny7UOAFxbabODmzACgPuhzwoAYBa/s7L/tXIAQMlVMlM4LCxMa9euVUZGhvLz89W8eXNVrlz5ur/8zJkzkqRatWrZTF+8eLEWLVqkoKAgPfzww3rppZdUpUoVSUXfoWv48OHau3evbrnlliLvpDVy5EhJUl5entLS0hQfH2+d7+HhocjIyGvexSsuLu6q9RYMGjl06JCysrJsvtvf31/h4eFKTU3Vk08+edU6c3NzlZuba/1c3hdaAKCslTY7YmJitGTJEn322WeqXr269eK1v7+/fH19dfDgQS1ZskQPPvigateurV27dmnUqFHq1KmT2rRpI0nq0qWLWrZsqaefflpTpkxRVlaWxo0bp5iYGHl7e0uShg0bplmzZmnMmDEaNGiQ1q1bp6VLl2rVqlXWusTFxal///5q3769OnTooBkzZujcuXMaOHCgtUy/fv1Uv359JSQkSJJGjBihu+++W1OnTlV0dLQSExO1bds2vfPOO5Iki8WikSNH6pVXXlHTpk0VGhqql156SfXq1VP37t1Lte0BwFmVdXb4+/tr8ODBiouLU61ateTn56dnn31WERER6tixoySyAwCcjb37rAAArq88sqNr167W923atFF4eLhCQkK0dOlS+fr62vW7KoKEhAS9/PLLjq6GAgICHF0FAC6qtNmRlJRk83nhwoWqW7eu0tLS1KlTJ+v0gpswFqbgJoxr165VYGCg2rVrp8mTJ2vs2LGaOHGivLy8bG7CKEktWrTQ119/renTpysqKkqS7U0YpT9u3Lhq1SrNnz9fzz//fKHffeVNGCVp8uTJSk5O1qxZszRv3ryrbsIoSR9++KECAwO1YsWKQq+VA4Cro88KAGAWv7PiWjkAOJKpgSWSVKlSJbVq1arUX5yfn6+RI0fqjjvu0M0332yd/tRTTykkJET16tXTrl27NHbsWGVkZGj58uWS7HOHrlOnTuny5cuFltm/f3+Rdb7WHboK/mvmLl4V5UILAJSl0mTH3LlzJf3x+PcrLViwQAMGDJCXl5fWrl1rPflo2LChevbsqXHjxlnLenp6auXKlRo+fLgiIiJUtWpV9e/fX5MmTbKWCQ0N1apVqzRq1CjNnDlTDRo00HvvvWe9yCJJTzzxhE6cOKHx48crKytL7dq1U1JSks1+PzMzUx4efz4Q7Pbbb9eSJUs0btw4vfDCC2ratKlWrFhhk31jxozRuXPnNHToUJ0+fVp33nmnkpKS5OPjc13bDABcQVlmhyRNnz5dHh4e6tmzp3JzcxUVFaU5c+ZYy5IdAOB87NVnBQBwH+WdHTVq1NBNN92kAwcO6P7771deXp5Onz5t89SSY8eOWX9MHBQUpK1bt9qs49ixY9Z5Bf8tmHZlGT8/vyIHrxS1TEnWW9QPnSUpPj7e5uZc2dnZatiwYZHlAcAZ2TM7uAkjALgH+qwAAGbxOyuulQOAo5geWGIvMTEx2rNnj77++mub6UOHDrW+b926tYKDg3Xffffp4MGDuuGGG8q7mmWOCy0AUDzDMIqd37BhQ23cuPGa6wkJCdHq1auLLdO5c2ft2LGj2DKxsbGKjY0tcv6GDRuumtarVy/16tWryGUsFosmTZpkcwIGALh+18oOSfLx8dHs2bM1e/bsIsuQHSWTnp4u6Y+7Ajdq1MjBtQEAAAAqrpycHB08eFBPP/20wsLCVLlyZaWkpKhnz56SpIyMDGVmZioiIkKSFBERoVdffVXHjx9X3bp1JUnJycny8/NTy5YtrWX+et6SnJxsXUdhIiIi9OKLL+rixYvWO14mJyerWbNmqlmzprVMSkqK9UfIJVmvt7e39a6VAIDicRPGP+Tm5io3N9f6OTs7u8jvBwAAAHBt/M4KAFAaHtcuYn+xsbFauXKl1q9frwYNGhRbNjw8XJJ04MABSaW7k1bBHboCAgLk6elp+m5b17pDV8F/zazX29tbfn5+Ni8AAAAAqOhycnJksVjUt29fhYWFqXnz5srMzHR0tQAAAIAK47nnntPGjRt1+PBhbdq0SY8++qg8PT3Vu3dv+fv7a/DgwYqLi9P69euVlpamgQMHKiIiQh07dpQkdenSRS1bttTTTz+t7777TmvWrNG4ceMUExNjHcAxbNgw/fjjjxozZoz279+vOXPmaOnSpRo1apS1HrNmzdJ9991n/fzUU0/Jy8tLgwcP1t69e/Xxxx9r5syZNjfBGjFihJKSkjR16lTt379fEydO1LZt24r9IQAAoOQKbsKYmJhoM33o0KGKiopS69at1adPH3344Yf69NNPdfDgQQfVtGwlJCTI39/f+uIGjAAAAAAAAI5TooElM2fOtL7fvn37dX+ZYRiKjY3Vp59+qnXr1ik0NPSay+zcuVOSFBwcLOmPu2Tt3r1bx48ft5Yp7A5dKSkpNuu58k5aXl5eCgsLsymTn5+vlJSUa97Fq7j1hoaGKigoyKZMdna2tmzZUux6AcDVlSY7AADuieyo+C5cuCDDMNSjRw/16NFD58+f18mTJx1dLQBujOwAAJhV1tnxyy+/qHfv3mrWrJkef/xx1a5dW5s3b1adOnUkSdOnT9dDDz2knj17qlOnTgoKCrLekV6SPD09tXLlSnl6eioiIkJ9+/ZVv379bO7GGBoaqlWrVik5OVlt27bV1KlT9d577ykqKspa5uTJkzY/SPb399cXX3yhQ4cOKSwsTP/4xz80fvx4myfK33777VqyZIneeecdtW3bVp988olWrFhhc1d9AHBH9sgObsL4p/j4eJ05c8b6+vnnn4v8fgBwVvRZAQDMIjsAAI5SooElH3zwgfX9M888c91fFhMTo0WLFmnJkiWqXr26srKylJWVpfPnz0uSDh48qMmTJystLU2HDx/W559/rn79+qlTp05q06aNJPvdoSsuLk7vvvuuPvjgA6Wnp2v48OE6d+6cBg4caC3Tr18/xcfHWz9f6w5dFotFI0eO1CuvvKLPP/9cu3fvVr9+/VSvXj117979urcbADi70mQHAMA9kR3OIyAgQAEBAY6uBgCQHQAA08o6OxITE3XkyBHl5ubql19+UWJiom644QbrfB8fH82ePVu//fabzp07p+XLl1/1w9uQkBCtXr1av//+u06cOKG33npLlSpVsinTuXNn7dixQ7m5uTp48KAGDBhgM3/ixIk6fPiwzbQ2bdroq6++0oULF/TLL79o7NixV9W/V69eysjIUG5urvbs2aMHH3ywdBsEAFxAabKDmzBezdvbW35+fjYvAHA19FkBAMwiOwAAjlLp2kXsZ+7cuZL+uMhxpQULFmjAgAHy8vLS2rVrNWPGDJ07d04NGzZUz549NW7cOGvZgjt0DR8+XBEREapatar69+9f6B26Ro0apZkzZ6pBgwZX3aHriSee0IkTJzR+/HhlZWWpXbt2SkpKUmBgoLVMZmamPDz+HHtTcIeucePG6YUXXlDTpk2vukPXmDFjdO7cOQ0dOlSnT5/WnXfeqaSkJPn4+NhtOwIAAAAAAACuID09XQEBAWrUqJGjqwIAAACUqZiYGC1ZskSfffaZ9SaM0h9PkvL19dXBgwe1ZMkSPfjgg6pdu7Z27dqlUaNGFXkTxilTpigrK6vQmzDOmjVLY8aM0aBBg7Ru3TotXbpUq1atstYlLi5O/fv3V/v27dWhQwfr9fm/3oSxfv36SkhIkPTHTRjvvvtuTZ06VdHR0UpMTNS2bdv0zjvvSLK9CWPTpk0VGhqql156iZswAgAAAAAAOIkSDSw5ceKE5syZI8MwrO+v9Le//a1EX2YYRrHzGzZsqI0bN15zPQV36CpOwR26ihMbG2t92khhNmzYcNW0Xr16qVevXkUuY7FYNGnSJJuBLgDgrt599135+PiUKjsAAO6F7AAAmEV2OKecnBxZLBb17dtXvr6+2r9/P4NLAJQbssN9pKenSxKDGAGUmj2yg5swAoB74bwDAGAW2QEAcLQSDSx55plndOLEiaveAwBQnF9//VXe3t5kBwCgxMgOAIBZZIdzunDhggzDUKdOnfTll1/q5MmT/OAXQLkhO1zflQMYJTGIEUCp2SM7uAkjALgXzjsAAGaRHQAARyvRwJIJEyaUdT0AAC7o+eefl5+fn6OrAQBwImQHAMAsssO5+fv7O7oKANwQ2eH6CgYw9ujRQ5K0fPlyBjECKBWyAwBgFtkBADCL7AAAOFqJBpZc644i48ePt0tlAACu5Y033pC3t3eh88gOAEBhyA4AgFlkBwDALLLDfQQEBDi6CgBcBNkBADCL7AAAmEV2AAAczaMkhSZNmqTly5dL+qMTvnbt2jYvAAAK85///EcS2QEAKDmyAwBgFtkBADCL7AAAmEV2AADMIjsAAGaRHQAARyvRE0t++eUXffLJJ/r000/l5eWlXr166dFHH1XNmjXLun4AACfWr18//fe//yU7AAAlRnYAAMwiOwAAZpEdAACzyA4AgFlkBwDALLIDAOBoJXpiSVBQkGJjY5WSkqL58+frzJkzatGihT744IOyrh8AwIkNHTqU7AAAmEJ2AADMIjsAAGaRHQAAs8gOAIBZZAcAwCyyAwDgaCV6YokkGYahjRs36uOPP9bWrVvVu3dv3XHHHWVZNwCAkzMMQxs2bCA7AAAlRnYAAMwiOwAAZpEd7ik9PV0BAQFq1KiRo6sCwAmRHQAAs8gOAIBZZAcAwNFKNLAkNjZWmzdv1l133aV+/fpp7ty5ZV0vAIAL6Ny5szp37kx2AABKjOwAAJhFdgAAzCI73EtOTo4sFov69u0rX19f7d+/n8ElAEwjOwAAZpEdAACzyA4AgKOVaGDJnDlzVKtWLf30009atGiRLBaLpD9GSFosFh0/frxMKwkAcE6ZmZlatGgR2QEAKDGyAwBgFtkBADCL7HAvFy5ckGEY6tSpk7788kudPHmSgSUATCM7AABmkR0AALPIDgCAo5VoYEl+fn5Z1wMA4IIOHTokPz8/R1cDAOBEyA4AgFlkBwDALLLDPfn7+zu6CgCcGNkBADCL7AAAmEV2AAAcrUQDSy5cuKB58+bpwIEDatOmjQYNGqRKlUq0KADAjc2ZM0e//PIL2QEAKDGyAwBgFtkBADCL7HBv6enpkqSAgACeXAKgxMgOAIBZZAcAwCyyAwDgaB4lKdS/f39t27ZNrVu31urVq/Xcc8+Vdb0AAC5gx44dZAcAwBSyAwBgFtkBADCL7HBPv//+uywWi/r27auwsDA1b95cmZmZjq4WACdBdgAAzCI7AABmkR0AAEcr0ZDGffv2affu3ZKkwYMHq0OHDmVaKQCAa3j33Xfl5+dHdgAASozsAACYRXYAAMwiO9xTXl6eDMNQjx49JEnLly/XyZMneWoJgBIhOwAAZpEdAACzyA4AgKOVaGBJ5cqV/1yAx2sBAEwiOwAAZpEdAACzyA4AgFlkh3sKCAiwvk9PT7dOY4AJgJIgOwAAZpEdAACzyA4AgKOUKIF27dqlunXrSpIMw9Dp06dVt25dGYYhi8Wi48ePl2klAQDO6YYbbpDFYiE7AAAlRnYAAMwiOwAAZpEdyMnJkcViUd++fSVJvr6+2r9/P4NLABSJ7AAAmEV2AADMIjsAAI5WooElly5dKut6AABc0MGDB+Xn5+foagAAnAjZAQAwi+wAAJhFduDChQsyDEM9evSQJC1fvlwnT55kYAmAIpEdAACzyA4AgFlkBwDA0XhmFgAAAAAAAACHSk9PlyQFBATwo14AQLkJCAiwvieLAAAAAAAAYAb9SQBcDQNLAAAAAAAAADjE77//LovFor59+0qSfH19tX//fi7AAADKTU5ODlkEAAAAAACAEqM/CYCr8nB0BQAAAAAAAAC4p7y8PBmGoR49eqhHjx46f/68Tp486ehqAQDcyIULF8giAAAAAAAAlBj9SQBcFU8sAQAAAAAAAOBQAQEBjq4CAMDNXZlF6enp1mncaRIAAAAAAACF4doGAFfDwBIAAGDFRXMAQGmkp6eTIQAAAACcVk5OjiwWi/r27StJ8vX11f79+znHAQAAAAAAAAC4PA9HVwAAADjelRfNw8LC1Lx5c2VmZjq6WgAAJ3FljpAhAAAAAJzVhQsXZBiGevTooR49euj8+fP66quvOMcBAAAAAAAAALg8BpYAAIBCL5qfPHnS0dUCADiJghzp1KkTGQIAAADA6QUEBMjHx4cB9AAAAAAAAAAAt8HAEgAAYBUQEKCAgABHVwMA4KT8/f0dXQUAgAtIT0/X9u3b+QEvAMCh/jqA/quvviKfAAAAAAAAAAAuq5KjKwAAAAAAAAAAOTk51jvDS5Kvr6/279+vRo0aObhmAAB3VrlyZfIJAAAAAAAAxUpPT1dAQAB9RgCcGk8sAQAAAAAAAOBwBXeG79Gjh3r06KHz58/r5MmTjq4WAMDN5eXlXZVPPL0EAAAAAAAAku1Ns5o3b05/EQCnxhNLXFh6erokMQoSAAAAQLniXAQAUBoBAQHW92QKAKCiCAgIuOrpWt7e3vq///s/BQcHk1UAAAAAAABuqOCmWZ06ddKXX36pkydP0kcEwGm5/RNLZs+ercaNG8vHx0fh4eHaunVrseWXLVum5s2by8fHR61bt9bq1att5huGofHjxys4OFi+vr6KjIzUDz/8UJZNuMqVFzbCwsIYBQkAduaK2VGY9PR08gMA7MRdsuP333/nXAQA7MRdsqMof+3fuummm7Rq1Spt375dqamp3CUeAArh7tlRHq58utYDDzygvLw8PfTQQzZZRT4BcCaunB3p6emcNwBAGXDl7AAAlA13yQ5/f39JnIsAcG5uPbDk448/VlxcnCZMmKDt27erbdu2ioqK0vHjxwstv2nTJvXu3VuDBw/Wjh071L17d3Xv3l179uyxlpkyZYrefvttzZs3T1u2bFHVqlUVFRWlCxculFezbC5sXPlYdoIKAErPVbPjSjyiEQDsyx2yo0BeXl6h5yJ0nAGAOe6UHUUp7oe7d9xxR5GDTf76nvwB4C7IjvIVEBCgKlWqFJpVV+YTOQSgInPV7OAmjABQdlw1OwAAZcedsoObMAJwBZUcXQFHmjZtmoYMGaKBAwdKkubNm6dVq1Zp/vz5ev75568qP3PmTD3wwAMaPXq0JGny5MlKTk7WrFmzNG/ePBmGoRkzZmjcuHHq1q2bJOnDDz9UYGCgVqxYoSeffLL8GqerH8t+5SPZc3Nz5e3tbS3Ho7cAoGRcPTukqx/R+NVXX6lFixZkBwBcJ3fIjr/667mIJM5HAMAEd8yOogQEBOjkyZPWH+6eOnVK69evV4cOHfTtt9/qoYcekiRZLBYZhnHV+4L8qVWrljV7rsyha70npwA4C7LDca7Mqr/mU1HnQYW95zwJQHlz1ey4cpC6JC1fvlxfffWVmjRpUuh+mH0uAJScq2ZHgfT0dElkAwDYk6tnx5WuvAmj9Oe5CL+5AuBM3HZgSV5entLS0hQfH2+d5uHhocjISKWmpha6TGpqquLi4mymRUVFacWKFZKkQ4cOKSsrS5GRkdb5/v7+Cg8PV2pqaqGhlZubq9zcXOvnM2fOSJKys7NNtScnJ0eSdPToUZ0+fdrmvWEYuummm/T9999bL2ZcydvbW//+978VGBgoDw8P5efnS5L1fWHTinpvpqyzLFeR60ab2Bbl8R1BQUEKCgqSGQX7sIIf8rgKd8oOSTp37pwkWX8QfCWyw/Hf4SzLVeS60Sayozy4W3YUrPfKc5Hbb79dubm5SktLK/Z8JDg4uEL9XZT3chW5bmwL2kR2lC93z47i3l+8eFGXLl2S9OePxW6//Xbl5ORo165dV70vLn9K6lrnPkW9d6e/34qwXEWuG20qu21BdvyJ7CjZ+/JY7sp8Kk0Omckf9km0yRnqVlG2BdnxJ3fIjosXL+r8+fOSCr/OUcCe1zuud7mK/PdEm5yjbmwLsqM8uHJ2/DUvrue6xZXv+TukTWwL56qbvdtEdvzJlbOjuD6ka52LFHYOwt8hbWJbOFfd7N2mipQdbjuw5OTJk7p8+bICAwNtpgcGBmr//v2FLpOVlVVo+aysLOv8gmlFlfmrhIQEvfzyy1dNb9iwYcka8hf/+c9/Cn3//fffF7lMbm6uHn/88ev6PgAoztmzZ+Xv7+/oatiNu2VHWlpakcuQHQDKCtnh3Nmxa9euq6Zt2rSp2HWRKQBKi+xwvewoyfuC5a7MmaLelwY5BbgmssO9s6Mslyssn64H+QNUPGSHc2dHcdjnAigrZIfzZUcBsgGAo5Adzpcd1+pDKgw5A8Ce7J0dbjuwpKKIj4+3GWGZn5+v3377TbVr15bFYinxerKzs9WwYUP9/PPP8vPzK4uqOoQrtssV2yS5ZrtcsU1S+bTLMAydPXtW9erVK5P1uzuyo3ywfYrGtike26doxW0bsqNskR3lh210bWyja2MbXVvBNtq3bx/ZUUbIjqK5Ypsk12wXbXIe5dUuzjvKFtlRMrTPebly2yTaVxSyo2yRHebRVtflTu119baSHWXL3bODepcv6l2+3LneZEfZcufsoM7lwxnrLDlnvanzn8oqO9x2YElAQIA8PT117Ngxm+nHjh0r8nEyQUFBxZYv+O+xY8cUHBxsU6Zdu3aFrtPb21ve3t4202rUqGGmKTb8/Pyc5o/FDFdslyu2SXLNdrlim6Syb5crjaAvQHa4J7ZP0dg2xWP7FK2obUN2/IHscA1so2tjG10b2+ja6tevLw8PD0dXw67IDufhim2SXLNdtMl5lEe7OO/4A9nheLTPebly2yTaVxiy4w9kR8VCW12XO7XXldtKdvyB7Cg71Lt8Ue/y5a71Jjv+QHaUDepcPpyxzpJz1ps6/6EsssO1rryb4OXlpbCwMKWkpFin5efnKyUlRREREYUuExERYVNekpKTk63lQ0NDFRQUZFMmOztbW7ZsKXKdAADnQXYAAMwiOwAAZpEdAACzyA4AgFlkBwDALLIDAGAW2QEAzsdtn1giSXFxcerfv7/at2+vDh06aMaMGTp37pwGDhwoSerXr5/q16+vhIQESdKIESN09913a+rUqYqOjlZiYqK2bdumd955R5JksVg0cuRIvfLKK2ratKlCQ0P10ksvqV69eurevbujmgkAsCOyAwBgFtkBADCL7AAAmEV2AADMIjsAAGaRHQAAs8gOAHAubj2w5IknntCJEyc0fvx4ZWVlqV27dkpKSlJgYKAkKTMzUx4efz7U5fbbb9eSJUs0btw4vfDCC2ratKlWrFihm2++2VpmzJgxOnfunIYOHarTp0/rzjvvVFJSknx8fMq0Ld7e3powYcJVj+xydq7YLldsk+Sa7XLFNkmu267yQna4D7ZP0dg2xWP7FM1dtw3Z4V7YRtfGNro2ttG1ufo2IjsqNldsk+Sa7aJNzsNV21WeyA7nQfuclyu3TaJ97ojscE601XW5U3vdqa2uhuxwPOpdvqh3+aLeronscCzqXD6csc6Sc9abOpc9i2EYhqMrAQAAAAAAAAAAAAAAAAAAAAAAgPLnce0iAAAAAAAAAAAAAAAAAAAAAAAAcEUMLAEAAAAAAAAAAAAAAAAAAAAAAHBTDCwBAAAAAAAAAAAAAAAAAAAAAABwUwwsAQAAAAAAAAAAAAAAAAAAAAAAcFMMLHEBs2fPVuPGjeXj46Pw8HBt3brV0VUqUkJCgm677TZVr15ddevWVffu3ZWRkWFT5sKFC4qJiVHt2rVVrVo19ezZU8eOHbMpk5mZqejoaFWpUkV169bV6NGjdenSpfJsSrFef/11WSwWjRw50jrNGdv1v//9T3379lXt2rXl6+ur1q1ba9u2bdb5hmFo/PjxCg4Olq+vryIjI/XDDz/YrOO3335Tnz595Ofnpxo1amjw4MHKyckp76ZYXb58WS+99JJCQ0Pl6+urG264QZMnT5ZhGNYyztCuL7/8Ug8//LDq1asni8WiFStW2My3Vxt27dqlu+66Sz4+PmrYsKGmTJlS1k1DOXGm7LCn8vrbcUbuktHXa+7cuWrTpo38/Pzk5+eniIgI/fe//7XOd+dt81euchyEq7lrdkjsI68H+4LCueI5lj25yvkabDlLfpRkX9+5c2dZLBab17Bhw2zKVLT92MSJE6+qc/Pmza3znXHf3Lhx46vaZLFYFBMTI8k5/p1ctV+nuHZdvHhRY8eOVevWrVW1alXVq1dP/fr105EjR2zWUdi/7+uvv+7QdqH8OUt2FMde5xDO4nqP/ysyexy7V0T2OuauKOjvRQFnyw5XPR4sTHn2q23YsEG33nqrvL29deONN2rhwoVl3Twb5XUdwdHtLExZ9gVWxPbCNVSk7HCVaxDOdF3AGfvqnaX/3FmPc+zRr+Usx2e4fhUpO5ztfNgZs84VfifkLNnsrNeynPF4okQMOLXExETDy8vLmD9/vrF3715jyJAhRo0aNYxjx445umqFioqKMhYsWGDs2bPH2Llzp/Hggw8ajRo1MnJycqxlhg0bZjRs2NBISUkxtm3bZnTs2NG4/fbbrfMvXbpk3HzzzUZkZKSxY8cOY/Xq1UZAQIARHx/viCZdZevWrUbjxo2NNm3aGCNGjLBOd7Z2/fbbb0ZISIgxYMAAY8uWLcaPP/5orFmzxjhw4IC1zOuvv274+/sbK1asML777jvjkUceMUJDQ43z589byzzwwANG27Ztjc2bNxtfffWVceONNxq9e/d2RJMMwzCMV1991ahdu7axcuVK49ChQ8ayZcuMatWqGTNnzrSWcYZ2rV692njxxReN5cuXG5KMTz/91Ga+Pdpw5swZIzAw0OjTp4+xZ88e46OPPjJ8fX2Nf/3rX+XVTJQRZ8sOeyqPvx1n5Q4ZXRqff/65sWrVKuP77783MjIyjBdeeMGoXLmysWfPHsMw3HvbXMlVjoNwNXfODsNgH2kW+4LCueo5lj25yvka/uRM+VGSff3dd99tDBkyxDh69Kj1debMGev8irgfmzBhgtGqVSubOp84ccI63xn3zcePH7dpT3JysiHJWL9+vWEYzvHv5Kr9OsW16/Tp00ZkZKTx8ccfG/v37zdSU1ONDh06GGFhYTbrCAkJMSZNmmTz73fl3yH9Va7PmbKjOPY4h3AW13v8X5HZ69i9IrLXMXdFQX8vDMM5s8NVjwcLU179aj/++KNRpUoVIy4uzti3b5/xz3/+0/D09DSSkpLKra3lcR2hIrTzr8qyL7AitheuoaJlhytcg3Cm6wLO2lfvLP3nznqcY49+LWc5PsP1qWjZ4Wznw86Ydc7+OyFnymZnvJblrMcTJcHAEifXoUMHIyYmxvr58uXLRr169YyEhAQH1qrkjh8/bkgyNm7caBjGHwdilStXNpYtW2Ytk56ebkgyUlNTDcP4IxQ9PDyMrKwsa5m5c+cafn5+Rm5ubvk24C/Onj1rNG3a1EhOTjbuvvtu6w7ZGds1duxY48477yxyfn5+vhEUFGS8+eab1mmnT582vL29jY8++sgwDMPYt2+fIcn49ttvrWX++9//GhaLxfjf//5XdpUvRnR0tDFo0CCbaT169DD69OljGIZztuuvB4f2asOcOXOMmjVr2vz/N3bsWKNZs2Zl3CKUNWfPDnspq78dV+FqGV0Watasabz33ntsm/+fKx0H4Wpkhy32kUVjX1A0Vz3HsidXPF9zd86cH3/d1xuGYbNfK0xF3I9NmDDBaNu2baHzXGXfPGLECOOGG24w8vPzDcNwvn8nV+3XKexi5l9t3brVkGT89NNP1mkhISHG9OnTi1zG0e1C2XPm7CjO9ZxDOIPSHP9XZPY4dq+o7HHMXVHR3+u+nD07XPV4sChl1a82ZswYo1WrVjbf9cQTTxhRUVFl3aRi2fs6QkVrZ1n3BVa09sJ1VPTscLZrEM52XcBZ++qdsf/cWY9zrqdfqyLUG2WrImeHM54PO1vWFXCW3wk5WzY747UsZz2eKAkPOzz0BA6Sl5entLQ0RUZGWqd5eHgoMjJSqampDqxZyZ05c0aSVKtWLUlSWlqaLl68aNOm5s2bq1GjRtY2paamqnXr1goMDLSWiYqKUnZ2tvbu3VuOtb9aTEyMoqOjbeovOWe7Pv/8c7Vv3169evVS3bp1dcstt+jdd9+1zj906JCysrJs2uTv76/w8HCbNtWoUUPt27e3lomMjJSHh4e2bNlSfo25wu23366UlBR9//33kqTvvvtOX3/9tbp27SrJedt1JXu1ITU1VZ06dZKXl5e1TFRUlDIyMnTq1Klyag3szRWyo6y4wt+/PblaRtvT5cuXlZiYqHPnzikiIoJt8/9zpeMg2CI7rsY+smjsC4rmqudY9uQO52vuxNnz46/7+gKLFy9WQECAbr75ZsXHx+v333+3zquo+7EffvhB9erVU5MmTdSnTx9lZmZKco19c15enhYtWqRBgwbJYrFYpzvjv1MBd+rXOXPmjCwWi2rUqGEz/fXXX1ft2rV1yy236M0337R5XL0ztAvXz9mzozjXcw7hDEpz/F+R2ePYvaKyxzG3s+D8wT24Yna4+vFgWfWrpaamXpVHUVFRDvv/oKyuI1S0dpZ1X2BFay9cgzNkh7Ndg3C26wLO2lfvCv3nrnSc89d+LWepN66PM2THlZxhf+BsWedsvxNytmyWnO9alrMeT5REJYd9M0rt5MmTunz5ss0fgyQFBgZq//79DqpVyeXn52vkyJG64447dPPNN0uSsrKy5OXlddXFxMDAQGVlZVnLFNbmgnmOkpiYqO3bt+vbb7+9ap4ztuvHH3/U3LlzFRcXpxdeeEHffvut/v73v8vLy0v9+/e31qmwOl/Zprp169rMr1SpkmrVquWwf6vnn39e2dnZat68uTw9PXX58mW9+uqr6tOnjyQ5bbuuZK82ZGVlKTQ09Kp1FMyrWbNmmdQfZcvZs6MsucLfv724Wkbby+7duxUREaELFy6oWrVq+vTTT9WyZUvt3LnT7beNqx0HwRbZYYt9ZNHYFxTPVc+x7MkdztfciTPnR2H7ekl66qmnFBISonr16mnXrl0aO3asMjIytHz5ckkVcz8WHh6uhQsXqlmzZjp69Khefvll3XXXXdqzZ49L7JtXrFih06dPa8CAAdZpzvjvdCV36de5cOGCxo4dq969e8vPz886/e9//7tuvfVW1apVS5s2bVJ8fLyOHj2qadOmSar47ULpOHN2FOd6zyEqutIe/1dk9jh2r6jsccztLDh/cA+umB2ufDxYlv1qRZXJzs7W+fPn5evrWxZNukpZX0eoKO2UyqcvsCK1F66jomeHs12DcMbrAs7aV+8K/eeucpxTWL+WM9Qb16+iZ8dfVfT9gTNlnTP+TsgZs9kZr2U56/FESTCwBA4TExOjPXv26Ouvv3Z0VUrt559/1ogRI5ScnCwfHx9HV8cu8vPz1b59e7322muSpFtuuUV79uzRvHnz1L9/fwfX7votXbpUixcv1pIlS9SqVSvt3LlTI0eOVL169Zy6XQBgT66U0fbUrFkz7dy5U2fOnNEnn3yi/v37a+PGjY6ulsO54nEQUBz2kYVjX3BtrnqOZU+cr6GiKGpfP3ToUOv71q1bKzg4WPfdd58OHjyoG264obyrWSIFdyyUpDZt2ig8PFwhISFaunSpS/wA5/3331fXrl1Vr1496zRn/HdyNxcvXtTjjz8uwzA0d+5cm3lxcXHW923atJGXl5f+3//7f0pISJC3t3d5VxWwC1c8h3D1439XPnbnmBuAI7liJv6Vu1xHcPVjAcCRnGlf6az7Amc93udYvmIorl8LQMk4U9Y52/G9s2azM17LctbjiZLwcHQFcP0CAgLk6empY8eO2Uw/duyYgoKCHFSrkomNjdXKlSu1fv16NWjQwDo9KChIeXl5On36tE35K9sUFBRUaJsL5jlCWlqajh8/rltvvVWVKlVSpUqVtHHjRr399tuqVKmSAgMDna5dwcHBatmypc20Fi1aWB8xVVCn4v7/CwoK0vHjx23mX7p0Sb/99pvD/q1Gjx6t559/Xk8++aRat26tp59+WqNGjVJCQoIk523XlezVhor2/yTsw5mzo6y5wt+/PbhaRtuTl5eXbrzxRoWFhSkhIUFt27bVzJkz3X7buOJxEGyRHX9iH1k09gXX5qrnWPbkDudr7sRZ86OofX1hwsPDJUkHDhyQ5Bz7sRo1auimm27SgQMHnD6/fvrpJ61du1bPPPNMseWc7d/J1ft1Ci6+//TTT0pOTrZ5WklhwsPDdenSJR0+fFhSxW0X7MNZs6M4pTmHqMjscfxfkdnj2L2isscxt7Pg/ME9uGJ2uOrxYFn3qxVVxs/Pr1x/iFTW1xEqSjvLqy+worQXrqUiZ4ezXYNw1usCztpX7wr9585+nFNcv1ZFrjdKryJnR2Eq8v7A2bLO2X4n5KzZ/FfOcC3LWY8nSoKBJU7My8tLYWFhSklJsU7Lz89XSkqKIiIiHFizohmGodjYWH366adat27dVY93CwsLU+XKlW3alJGRoczMTGubIiIitHv3bps/qIKDtb/+oZaX++67T7t379bOnTutr/bt26tPnz7W987WrjvuuEMZGRk2077//nuFhIRIkkJDQxUUFGTTpuzsbG3ZssWmTadPn1ZaWpq1zLp165Sfn2+9qF/efv/9d3l42O76PD09lZ+fL8l523Ule7UhIiJCX375pS5evGgtk5ycrGbNmvH4RSfmjNlRXlzh7780XDWjy1J+fr5yc3Pdftu44nEQbJEd7CNLgn3BtbnqOZY9ucP5mjtxtvy41r6+MDt37pT0R+ex5Bz7sZycHB08eFDBwcFOn18LFixQ3bp1FR0dXWw5Z/t3cuV+nYKL7z/88IPWrl2r2rVrX3OZnTt3ysPDw/o4+IrYLtiPs2VHcexxDlGR2eP4vyKzx7F7RWWPY25nwfmDe3Cl7CjgaseD5dWvFhERYbOOgjKO/v/A3tcRKko7y6svsKK0F66lImaHs16DcNbrAs7aV+8K/efOfJxzrX6tilpv2EdFzI7iVMT9gbNm3V9V9N8JOWs2/5UzXMty1uOJEjHg1BITEw1vb29j4cKFxr59+4yhQ4caNWrUMLKyshxdtUINHz7c8Pf3NzZs2GAcPXrU+vr999+tZYYNG2Y0atTIWLdunbFt2zYjIiLCiIiIsM6/dOmScfPNNxtdunQxdu7caSQlJRl16tQx4uPjHdGkIt19993GiBEjrJ+drV1bt241KlWqZLz66qvGDz/8YCxevNioUqWKsWjRImuZ119/3ahRo4bx2WefGbt27TK6detmhIaGGufPn7eWeeCBB4xbbrnF2LJli/H1118bTZs2NXr37u2IJhmGYRj9+/c36tevb6xcudI4dOiQsXz5ciMgIMAYM2aMtYwztOvs2bPGjh07jB07dhiSjGnTphk7duwwfvrpJ7u14fTp00ZgYKDx9NNPG3v27DESExONKlWqGP/617/KrZ0oG86WHfZUHn87zsqdMvp6PP/888bGjRuNQ4cOGbt27TKef/55w2KxGF988YVhGO69bQrj7MdBuJo7Z4dhsI+8XuwLbLnqOZY9ucr5Gv7kTPlxrX39gQMHjEmTJhnbtm0zDh06ZHz22WdGkyZNjE6dOlnXURH3Y//4xz+MDRs2GIcOHTK++eYbIzIy0ggICDCOHz9uGIbz7psvX75sNGrUyBg7dqzNdGf5d3LVfp3i2pWXl2c88sgjRoMGDYydO3fa/J3l5uYahmEYmzZtMqZPn27s3LnTOHjwoLFo0SKjTp06Rr9+/RzaLpQvZ8qO4tjjHMLZmD3+r8jsdexeEdnrmLuioL8XhuGc2eGqx4OFKa9+tR9//NGoUqWKMXr0aCM9Pd2YPXu24enpaSQlJZVbW8vjOkJFaGdRyqIvsCK3F86tomWHK12DcIbrAs7aV+8s/efOepxT2n4tR9Ub5aeiZYeznQ87Y9a5yu+EnCGbnfFalrMeT5QEA0tcwD//+U+jUaNGhpeXl9GhQwdj8+bNjq5SkSQV+lqwYIG1zPnz542//e1vRs2aNY0qVaoYjz76qHH06FGb9Rw+fNjo2rWr4evrawQEBBj/+Mc/jIsXL5Zza4r31x2yM7brP//5j3HzzTcb3t7eRvPmzY133nnHZn5+fr7x0ksvGYGBgYa3t7dx3333GRkZGTZlfv31V6N3795GtWrVDD8/P2PgwIHG2bNny7MZNrKzs40RI0YYjRo1Mnx8fIwmTZoYL774os2BvjO0a/369YX+LfXv39+ubfjuu++MO++80/D29jbq169vvP766+XVRJQxZ8oOeyqvvx1n5E4ZfT0GDRpkhISEGF5eXkadOnWM++67z3qyaBjuvW0K4wrHQbiau2aHYbCPvF7sC67miudY9uQq52uw5Sz5ca19fWZmptGpUyejVq1ahre3t3HjjTcao0ePNs6cOWOznoq2H3viiSeM4OBgw8vLy6hfv77xxBNPGAcOHLDOd9Z985o1awxJV/39O8u/k6v26xTXrkOHDhX5d7Z+/XrDMAwjLS3NCA8PN/z9/Q0fHx+jRYsWxmuvvWZcuHDBoe1C+XOW7CiOvc4hnMn1HP9XZPY4dq+I7HXMXVHQ34sCzpYdrno8WJjy7Fdbv3690a5dO8PLy8to0qSJzXeUh/K6juDodhalrPoCK2p74fwqUna40jUIZ7ku4Ix99c7Sf+6sxzml7ddyVL1RvipSdjjb+bAzZp2r/E7IGbLZWa9lOePxRElYDMMwBAAAAAAAAAAAAAAAAAAAAAAAALfj4egKAAAAAAAAAAAAAAAAAAAAAAAAwDEYWAIAAAAAAAAAAAAAAAAAAAAAAOCmGFgCAAAAAAAAAAAAAAAAAAAAAADgphhYAgAAAAAAAAAAAAAAAAAAAAAA4KYYWAIAAAAAAAAAAAAAAAAAAAAAAOCmGFgCAAAAAAAAAAAAAAAAAAAAAADgphhYAgAAAAAAAAAAAAAAAAAAAAAA4KYYWAIAAAAAAAAAAAAAAAAAAAAAAOCmGFgCAAAAAAAAAAAAAAAAAAAAAICDTZw4Ue3atXN0NeCGGFgCVHADBgxQ9+7dbaZ98skn8vHx0dSpUwudf6XGjRvLYrHIYrGoSpUqat26td57772ryhmGoXfffVcRERHy8/NTtWrV1KpVK40YMUIHDhywltu7d6969uxpXe+MGTPs1FIAQFnKysrSs88+qyZNmsjb21sNGzbUww8/rJSUFEm2eeHr66vGjRvr8ccf17p162zW891336l3795q2LChfH191aJFC82cOdOmzIABA6zruvLVqlWrcmsvAODa7JUNkvT3v/9dYWFh8vb2LrKDa9euXbrrrrvk4+Ojhg0basqUKTbzO3fuXGh+REdH273tAICyYc9sSUlJ0e23367q1asrKChIY8eO1aVLl6zzDx8+XGhubN68udzaCwAwrzzPQzIyMnTPPfcoMDBQPj4+atKkicaNG6eLFy8WWrfExERZLJZir7kAAMpWUde+N2zYIIvFotOnT9u8v5aoqCh5enrq22+/LdH3X3luUbVqVTVt2lQDBgxQWlpaofUpeNWpU0cPPvigdu/eXaLvAQCUv/K+JgIAcC7lmRMXLlzQgAED1Lp1a1WqVIm+KFQoDCwBnMx7772nPn36aO7cufrHP/5RomUmTZqko0ePas+ePerbt6+GDBmi//73v9b5hmHoqaee0t///nc9+OCD+uKLL7Rv3z69//778vHx0SuvvGIt+/vvv6tJkyZ6/fXXFRQUZPf2AQDs7/DhwwoLC9O6dev05ptvavfu3UpKStI999yjmJgYa7mCvMjIyNCHH36oGjVqKDIyUq+++qq1TFpamurWratFixZp7969evHFFxUfH69Zs2ZZy8ycOVNHjx61vn7++WfVqlVLvXr1Ktd2AwCKZs9sKDBo0CA98cQThX5fdna2unTpopCQEKWlpenNN9/UxIkT9c4771jLLF++3CY/9uzZI09PT/IDAJyEPbPlu+++04MPPqgHHnhAO3bs0Mcff6zPP/9czz///FXfu3btWpv8CAsLK5f2AgDMK+/zkMqVK6tfv3764osvlJGRoRkzZujdd9/VhAkTCq3bc889p7vuust+DQYAOFRmZqY2bdqk2NhYzZ8/v8TLLViwQEePHtXevXs1e/Zs5eTkKDw8XB9++OFVZTMyMnT06FGtWbNGubm5io6OVl5enj2bAQCwg/I+FwEAOJfyzonLly/L19dXf//73xUZGVlm7QKuRyVHVwBAyU2ZMkUTJkxQYmKiHn300RIvV3BnR0kaO3aspkyZouTkZHXt2lWS9PHHHysxMVGfffaZHnnkEetyjRo1UseOHWUYhnXabbfdpttuu02SCr2YDwCoeP72t7/JYrFo69atqlq1qnV6q1atNGjQIOvnK/OiUaNG6tSpk4KDgzV+/Hg99thjatasmU15SWrSpIlSU1O1fPlyxcbGSpL8/f3l7+9vLbNixQqdOnVKAwcOLMtmAgBMsGc2SNLbb78tSTpx4oR27dp11fctXrxYeXl5mj9/vry8vNSqVSvt3LlT06ZN09ChQyVJtWrVslkmMTFRVapUsRlY8u9//1szZ85URkaGqlatqnvvvVczZsxQ3bp17bRlAADXy57Z8vHHH6tNmzYaP368JOnGG2/UlClT9Pjjj2vChAmqXr26dX21a9fm5icA4CTK+zykSZMmatKkifVzSEiINmzYoK+++sqm3OXLl9WnTx+9/PLL+uqrr0p0B3wAQMW3YMECPfTQQxo+fLg6duyoadOmydfX95rL1ahRw5pDjRs3VpcuXdS/f3/Fxsbq4YcfVs2aNa1l69atay0/cuRIPfLII9q/f7/atGlTZu0CAJhX3ucikvTNN9/oxRdf1NatW+Xt7a0OHTooMTHRJkcAABVDeedE1apVNXfuXEl/5EVxfVH/+te/9Morr/x/7f17XJR14v//PwHl4AHMCNBSozLRPKUpomVarmNZK6tZuXnILL+60GrsatmaltbSyVNpspqnPmaavU1LDSM8tK6oiVLigdJsqdXxUAFiHEyu3x/+mJgE5JIZhpl53G+3uQnX9Zrrer0uh+s5r9c1r7n0448/6r777tPChQvtPpMFOBp3LAHcxNNPP63p06dr/fr1piaVlFVSUqL/+7//088//yx/f3/b8vfee0+tWrWym1RSlo+PzxXtDwDgej/99JOSk5MVFxdn1/kp1ahRo0qfP27cOBmGoXXr1lVYJjc395IPA5e1aNEi9enTRy1atKhyvQEAzlMT2fB7aWlp6tmzp10/xGKxKCsrSz///HO5z1m0aJEefvhhuzqeP39e06dP15dffqm1a9fqu+++06OPPlrlegAAnMPR2VJUVKTAwEC7MkFBQSosLFR6errd8j/+8Y8KCwvT7bffro8++qh6DQEAOI0r+iG/d+TIESUnJ+vOO++0Wz5t2jSFhYVp1KhRV7xtAEDtYhiGlixZoqFDhyoqKko33XSTPvjggyve3lNPPaWzZ88qJSWl3PW5ublauXKlJNmNfwEAXM8VfZGMjAzdfffdatOmjdLS0rR9+3bdf//9unDhgtnqAwCcrDaMWVXkyJEjev/99/Xxxx8rOTlZ+/bt01/+8heH7wcoizuWAG7gk08+0bp165Samqq77rrL9POffvppTZ48WUVFRfr111/VuHFjPf7447b1X3/9tW22ZKnx48fr7bfflnQxHH/44YfqNQIA4BJHjhyRYRiKioq6ouc3btxYYWFh+u6778pdv2PHDq1atUobNmwod/3x48f1ySefaMWKFVe0fwCA4zk7G8pjtVoVGRlptyw8PNy27vff0LV7925lZmZq0aJFdsvLfiPMDTfcoDfeeENdunRRfn6+GjRoYLIlAABHcXS2WCwWzZ49W++9954efPBBWa1WTZs2TZJ04sQJSVKDBg00Y8YM9ejRQ76+vvq///s/xcbGau3atRV+eQoAwHVc0Q8p1b17d+3du1dFRUUaPXq0LVMkafv27Vq0aJEyMjKuqF4AAMdbv379JeM8Zj+I+9lnn+mXX36RxWKRJA0dOlSLFi3SsGHDrqhOpfn1+xy67rrrJEnnzp2TdHHi+5VmHQDAOVzRF3n11Vd122236a233rItu+WWW65o/wAA53LlmNXlFBYW6p133tG1114rSXrzzTfVv39/zZgxgzu5w2m4YwngBtq3b6/rr79eU6dOVX5+vunnT5gwQRkZGdq8ebOio6M1a9Ys3XTTTZU+5x//+IcyMjI0ZcqUK9onAKB2MAzDIdso7+5VmZmZGjBggKZOnaq+ffuW+9xly5apUaNGio2NrXY9AACO4cxscJRFixapXbt26tq1q93y9PR03X///WrevLkaNmxo+6bh7Oxsp9UFAHB5js6Wvn376rXXXtOYMWMUEBCgm2++Wffee68kydf34pB2aGioEhISFB0drS5duujll1/W0KFD9dprr1W7LgAAx3NlP2TVqlXau3evVqxYoQ0bNuj111+XJJ09e1bDhg3TwoULFRoaWu36AQAco3fv3srIyLB7lH4hYlUtXrxYDz30kOrUufhdq0OGDNF//vMfHT16VJI0ZswYNWjQwPa4nNIc+30O/fvf/1Z6erqWLl2qm2++WUlJSabqCQBwPlf0RUrvWAIAqP1q87Xz5s2b2yaVSFJMTIxKSkqUlZXl8H0BpbhjCeAGrr32Wn3wwQfq3bu3+vXrp08++UQNGzas8vNDQ0N100036aabbtLq1avVrl073XbbbWrTpo0kqWXLlpeEzTXXXKNrrrlGYWFhDm0LAKBmtWzZUj4+Pjp8+PAVPf/HH3/U6dOnL/mW+YMHD+ruu+/W6NGjNXny5HKfaxiGFi9erGHDhnHrdwCoRZyVDZWJiIjQyZMn7ZaV/v77b1M5d+6cVq5cafctwqXLLRaLLBaL3n33XV1zzTXKzs6WxWJRcXHxFbUFAOAYzsiWhIQEPfXUUzpx4oSuuuoqfffdd5o0aZJuuOGGCrcTHR2tlJSUK6oDAMC5XNEPKdWsWTNJUps2bXThwgWNHj1af/vb33T06FF99913uv/++21lS0pKJEl16tRRVlaWbrzxxiuqLwDgytWvX/+SL0n84Ycfqvz8n376SR9++KHOnz+v+fPn25ZfuHBBixcv1ksvvaRp06bp73//e5W3eejQIUm6JIciIyPVqFEjtWrVSqdOndJDDz2kzz//vMrbBQA4nyv6IkFBQVe0LwBAzXPlmBVQG3HHEsBNtGjRQtu2bZPValW/fv109uzZK9pOs2bN9NBDD2nSpEm2ZUOGDFFWVpbWrVvnqOoCAGqJxo0by2KxaN68ebZbsZeVk5NT6fPnzJkjX19fuzuOHDhwQL1799aIESP00ksvVfjcbdu26ciRIxo1atSVVh8A4ATOyIbLiYmJ0eeff67z58/blqWkpKhVq1a66qqr7MquXr1aRUVFGjp0qN3yw4cP68cff9TLL7+sO+64Q1FRUTp16lSV6wAAcB5nZYuPj4+aNm2qoKAgvffee2rWrJk6depU4XYyMjLUpEmTK2kCAMDJXNEPKU9JSYnOnz+vkpISRUVFaf/+/XbfiP/HP/7R9k35pRNSAADu5d1339V1112nL7/80u4cP2PGDC1dulQXLlxQWFiY7YsZfz+JpTyzZ89WcHCw+vTpU2GZuLg4ZWZm6sMPP3RkcwAA1eSKvkj79u2VmppqsqYAAFeoLWNW5cnOztbx48dtv+/cuVO+vr5q1aqVw/cFlOKOJYAbadasmbZu3arevXvLYrEoOTlZkpSbm6uMjAy7sldffXWFFz3GjRuntm3bas+ePbrtttv08MMPa82aNXr44Yc1adIkWSwWhYeH67///a9WrVolPz8/23OLi4t18OBB28//+9//lJGRoQYNGlRp0A0AUPPmzZunHj16qGvXrpo2bZrat2+vX3/9VSkpKZo/f77tm7bOnj0rq9Wq8+fP69ixY1q+fLnefvttJSYm2s7xmZmZuuuuu2SxWJSQkCCr1SpJ8vPz0zXXXGO330WLFik6Olpt27at2QYDAC7LkdkgSUeOHFF+fr6sVqsKCgps/ZM2bdrI399ff/7zn/XCCy9o1KhRevrpp5WZmak5c+Zo1qxZl9Rt0aJFio2N1dVXX223vHnz5vL399ebb76pMWPGKDMzU9OnT3feQQIAmOLobHnttdfUr18/+fr6as2aNXr55Zf1/vvv28apli1bJn9/f916662SpDVr1mjx4sV6++23a77xAIAqqel+yLvvvqu6deuqXbt2CggI0J49ezRp0iQ99NBDqlu3rurWrXvJuFWjRo0kifEsAHAD+/fvV8OGDW2/+/j4qEOHDlq0aJEeeOCBS87lzZo106RJk5ScnKz+/ftXuN2cnBxZrVYVFRXp66+/1r/+9S+tXbtW77zzji0nylOvXj098cQTmjp1qmJjY+Xj41PtNgIAHKOm+yKTJk1Su3bt9Je//EVjxoyRv7+/tmzZosGDBys0NNQVhwAAUImazglJOnjwoIqLi/XTTz/p7NmztjIdO3a0bScwMFAjRozQ66+/rry8PP31r3/Vgw8+qIiIiBo5LvBSBoBabcSIEcaAAQPslv3www9Gy5YtjW7duhl/+tOfDEmXPEaNGmUYhmG0aNHCmDVr1iXbtVgsxj333GP7/cKFC0ZSUpIRHR1t1K9f3/D39zduuOEG44knnjAOHjxoK3fs2LFy93fnnXc6o/kAAAc5fvy4ERcXZ7Ro0cLw9/c3rr32WuOPf/yjsWXLFsMwLuZF6Tnd39/faN68ufHggw8amzdvttvO1KlTy82BFi1a2JXLyckxgoKCjAULFtRQCwEAZjkqGwzDMO68885y8+HYsWO2Ml9++aVx++23GwEBAca1115rvPzyy5ds5/Dhw4Yk49NPPy23zitWrDCuv/56IyAgwIiJiTE++ugjQ5Kxb98+RxwSAEA1OTJbevfubYSEhBiBgYFGdHS0sXHjRrv1S5cuNVq3bm3Uq1fPCA4ONrp27WqsXr26JpoJAKiGmuyHrFy50ujUqZPRoEEDo379+kabNm2Mf/7zn0ZBQUGF9SvvmgwAoOZUdB7esmWLIcn4+eefbT///uHn52fs2bPHkGTs3r273O3fc889xp/+9KcK9192e4GBgcaNN95ojBgxwkhPT6+wPmVlZ2cbderUMVatWmW67QAA56rpayJbt241unfvbgQEBBiNGjUyLBbLJbkBAKg9ajonym6v7KPU1KlTjQ4dOhhvvfWW0bRpUyMwMNB44IEHjJ9++snZhwJezscwDKPas1MAAAAAAAAAAAAAAAAAAAAAAADgdnxdXQEAAAAAAAAAAAAAAAAAAAAAAAC4BhNLAAAAAAAAAAAAAAAAAAAAAAAAvBQTSwAAAAAAAAAAAAAAAAAAAAAAALwUE0sAAAAAAAAAAAAAAAAAAAAAAAC8FBNLAAAAAAAAAAAAAAAAAAAAAAAAvBQTSwAAAAAAAAAAAAAAAAAAAAAAALwUE0sAAAAAAAAAAAAAAAAAAAAAAAC8FBNLAAAAAAAAAAAAAAAAAAAAAAAAvBQTSwAAAAAAAAAAAAAAAAAAAAAAALwUE0sAAAAAAAAAAAAAAAAAAAAAAAC8FBNLAAAAAAAAAAAAAAAAAAAAAAAAvFQdV1cA9kpKSnT8+HE1bNhQPj4+rq4OAFwRwzB09uxZNW3aVL6+zGF0NrIDgCcgO2oW2QHAE5AdNYvsAOAJyI6aRXYA8ARkR80iOwB4ArKjZpEdADwB2VGzyA4AnsBZ2cHEklrm+PHjatasmaurAQAO8f333+u6665zdTU8HtkBwJOQHTWD7ADgSciOmkF2APAkZEfNIDsAeBKyo2aQHQA8CdlRM8gOAJ6E7KgZZAcAT+Lo7GBiSS3TsGFDSRf/o4ODg11cGwC4Mnl5eWrWrJntnAbnIjsAeAKyo2aRHQA8AdlRs8gOAJ6A7KhZZAcAT0B21CyyA4AnIDtqFtkBwBOQHTWL7ADgCZyVHUwsqWVKb60VHBxMaAFwe9wusGaQHQA8CdlRM8gOAJ6E7KgZZAcAT0J21AyyA4AnITtqBtkBwJOQHTWD7ADgSciOmkF2APAkjs4OX4duDQAAAAAAAAAAAAAAAAAAAAAAAG6DO5Z4kOzsbJ05c0aSFBoaqubNm7u4RgCA2o7sAACYRXYAAMwiOwAAZpEdAACzyA4AgFlkBwDALLIDgKdjYomHyM7OVlRUlAoKCiRJQUFBOnz4MMEFAKgQ2QEAMIvsAACYRXYAAMwiOwAAZpEdAACzyA4AgFlkBwBv4OvqCsAxzpw5o4KCAg0cOFADBw5UQUGBbWYkAADlITsAAGaRHQAAs8gOAIBZZAcAwCyyAwBgFtkBADCL7ADgDbhjiYcJDQ11dRUAAG6G7AAAmEV2AADMIjsAAGaRHQAAs8gOAIBZZAcAwCyyA4An444lAAAAAAAAAAAAAAAAAAAAAAAAXoqJJQAAAAAAAAAAAAAAAAAAAAAAAF6KiSUAAAAAAAAAAAAAAAAAAAAAAABeioklAAAAAAAAAAAAAAAAAFBLvfzyy/Lx8dH48eNtywoLCxUXF6err75aDRo00KBBg3Ty5Em752VnZ6t///6qV6+ewsLCNGHCBP366692ZbZu3apOnTopICBAN910k5YuXXrJ/ufNm6frr79egYGBio6O1u7duy9b59WrVysqKkqBgYFq166dNm7caLfeMAxNmTJFTZo0UVBQkPr06aNvvvmm6gcFAAAAgEMxsQQAAAAAAAAAAAAAAAAAaqEvvvhC//rXv9S+fXu75U899ZQ+/vhjrV69Wtu2bdPx48c1cOBA2/oLFy6of//+Ki4u1o4dO7Rs2TItXbpUU6ZMsZU5duyY+vfvr969eysjI0Pjx4/X448/rk2bNtnKrFq1SgkJCZo6dar27t2rDh06yGKx6NSpUxXWeceOHRoyZIhGjRqlffv2KTY2VrGxscrMzLSVefXVV/XGG28oKSlJu3btUv369WWxWFRYWOiIwwYAAADAJCaWAAAAAAAAAAAAAAAAAEAtk5+fr0ceeUQLFy7UVVddZVuem5urRYsWaebMmbrrrrvUuXNnLVmyRDt27NDOnTslSZ9++qkOHjyo5cuXq2PHjrrnnns0ffp0zZs3T8XFxZKkpKQkRUZGasaMGWrdurXi4+P1wAMPaNasWbZ9zZw5U0888YRGjhypNm3aKCkpSfXq1dPixYsrrPecOXPUr18/TZgwQa1bt9b06dPVqVMnzZ07V9LFu5XMnj1bkydP1oABA9S+fXu98847On78uNauXeuEIwkAAADgcphYAgAAAAAAAAAAAAAAAAC1TFxcnPr3768+ffrYLU9PT9f58+ftlkdFRal58+ZKS0uTJKWlpaldu3YKDw+3lbFYLMrLy9OBAwdsZX6/bYvFYttGcXGx0tPT7cr4+vqqT58+tjLludx2jx07JqvValcmJCRE0dHRlW63qKhIeXl5dg8AAAAAjlHH1RUAAAAAAAAAAAAAAAAAAPxm5cqV2rt3r7744otL1lmtVvn7+6tRo0Z2y8PDw2W1Wm1lyk4qKV1fuq6yMnl5eSooKNDPP/+sCxculFvm8OHDFda9ou2W3W/Z+pRXpjyJiYl64YUXKlwPAAAA4MpxxxIAAAAAAAAAAAAAAAAAqCW+//57jRs3Tu+++64CAwNdXZ1aY9KkScrNzbU9vv/+e1dXCQAAAPAYpu9Y8p///EffffedLly4YFs2fPhwh1YKAOBZyA4AgFlkBwDALLIDAGAW2QEAMIvsAACYdaXZkZ6erlOnTqlTp062ZRcuXNDnn3+uuXPnatOmTSouLlZOTo7dXUtOnjypiIgISVJERIR2795tt92TJ0/a1pX+W7qsbJng4GAFBQXJz89Pfn5+5ZYp3UZ5Ktpu2f2WLmvSpIldmY4dO1a43YCAAAUEBFS4HgA8Af0OAICrmJpYMmTIEFmtVt16663y8/OTJPn4+DilYgAAz0B2AADMIjsAAGaRHQAAs8gOAIBZZAcAwKzqZMfdd9+t/fv32y0bOXKkoqKi9PTTT6tZs2aqW7euUlNTNWjQIElSVlaWsrOzFRMTI0mKiYnRSy+9pFOnTiksLEySlJKSouDgYLVp08ZWZuPGjXb7SUlJsW3D399fnTt3VmpqqmJjYyVJJSUlSk1NVXx8fIX1j4mJUWpqqsaPH1/udiMjIxUREaHU1FTbRJK8vDzt2rVLY8eOrdIxAgBPRL8DAOBKpiaWfPnllzp48KCz6gIA8EBkBwDALLIDAGAW2QEAMIvsAACYRXYAAMyqTnY0bNhQbdu2tVtWv359XX311bblo0aNUkJCgho3bqzg4GA9+eSTiomJUbdu3SRJffv2VZs2bTRs2DC9+uqrslqtmjx5suLi4mx3/RgzZozmzp2riRMn6rHHHtPmzZv1/vvva8OGDbb9JiQkaMSIEbrtttvUtWtXzZ49W+fOndPIkSNtZYYPH65rr71WiYmJkqRx48bpzjvv1IwZM9S/f3+tXLlSe/bs0YIFCyRd/JD0+PHj9eKLL6ply5aKjIzUc889p6ZNm9omsACAN6LfAQBwJV8zhbt27aqsrCxn1QUA4IHIDgCAWWQHAMAssgMAYBbZAQAwi+wAAJjl7OyYNWuW7rvvPg0aNEg9e/ZURESE1qxZY1vv5+en9evXy8/PTzExMRo6dKiGDx+uadOm2cpERkZqw4YNSklJUYcOHTRjxgy9/fbbslgstjIPPfSQXn/9dU2ZMkUdO3ZURkaGkpOTFR4ebiuTnZ2tEydO2H7v3r27VqxYoQULFqhDhw764IMPtHbtWrvJMhMnTtSTTz6p0aNHq0uXLsrPz1dycrICAwOddcgAoNaj3wEAcCVTdyzJyMhQhw4d1KpVKwUEBMgwDPn4+Gj37t3Oqh8AwM2RHQAAs8gOAIBZZAcAwCyyAwBgFtkBADDL0dmxdetWu98DAwM1b948zZs3r8LntGjRQhs3bqx0u7169dK+ffsqLRMfH6/4+Pgq102SBg8erMGDB1f4HB8fH02bNs1uogsAeDv6HQAAVzI1sWTdunXOqgcAwEORHQAAs8gOAIBZZAcAwCyyAwBgFtkBADCL7AAAmEV2AABcydTEkhYtWmjfvn3avn27JOmOO+5Qx44dnVEvAICHIDsAAGaRHQAAs8gOAIBZZAcAwCyyAwBgFtkBADCL7AAAuJKvmcKvv/66Hn/8ceXn5ys/P19PPPGEZs6c6ay6AQA8ANkBADCL7AAAmEV2AADMIjsAAGaRHQAAs8gOAIBZZAcAwJVM3bHknXfe0RdffKGAgABJUkJCgrp06aKEhASnVA4A4P7IDgCAWWQHAMAssgMAYBbZAQAwi+wAAJhFdgAAzCI7AACuZOqOJZJUWFhY7s8AAFSE7AAAmEV2AADMIjsAAGaRHQAAs8gOAIBZZAcAwCyyAwDgKqbuWDJhwgR17txZffr0kWEY2rx5s6ZOneqsugEAPADZAQAwi+xwL4cOHZIkhYaGqnnz5i6uDQBvRXYAAMwiOwAAZpEdAACzyA4AgFlkBwDAlUzdsWTYsGH6/PPPdc899+jee+/V559/rqFDhzqrbgAAD0B2AADMIjvcQ35+vnx8fDR06FB17txZUVFRys7OdnW1AHgpsgMAYBbZAQAwi+wAAJhFdgAAzKpudjz//PPy8fGxe0RFRdnWFxYWKi4uTldffbUaNGigQYMG6eTJk3bbyM7OVv/+/VWvXj2FhYVpwoQJ+vXXX+3KbN26VZ06dVJAQIBuuukmLV269JK6zJs3T9dff70CAwMVHR2t3bt3X7b+q1evVlRUlAIDA9WuXTtt3LjRbr1hGJoyZYqaNGmioKAg9enTR998802Vjw8AoHJVmlhy7NgxSdLBgweVk5Ojli1bqmXLlvr555918OBBp1YQAODeyA4AgFlkh3soLCyUYRgaOHCgBg4cqIKCAp05c8bV1QLgpcgOAIBZZAcAwCyyAwBgFtkBADDLEdlxyy236MSJE7bH9u3bbeueeuopffzxx1q9erW2bdum48ePa+DAgbb1Fy5cUP/+/VVcXKwdO3Zo2bJlWrp0qaZMmWIrc+zYMfXv31+9e/dWRkaGxo8fr8cff1ybNm2ylVm1apUSEhI0depU7d27Vx06dJDFYtGpU6cqrPeOHTs0ZMgQjRo1Svv27VNsbKxiY2OVmZlpK/Pqq6/qjTfeUFJSknbt2qX69evLYrGosLDQ1DECAJSvTlUKJSYmasGCBYqLi7tknY+PjzZv3uzwigEAPIMjs+Pll1/WpEmTNG7cOM2ePVvSxQ+1/u1vf9PKlStVVFQki8Wit956S+Hh4bbnZWdna+zYsdqyZYsaNGigESNGKDExUXXq/BaDW7duVUJCgg4cOKBmzZpp8uTJevTRR+32P2/ePL322muyWq3q0KGD3nzzTXXt2rXSOq9evVrPPfecvvvuO7Vs2VKvvPKK7r33Xtt6wzA0depULVy4UDk5OerRo4fmz5+vli1bmj4+AOAp6He4l9DQUFdXAQDIDgCAaYxZMWYFAGbR7wAAmEV2AADMckR21KlTRxEREZcsz83N1aJFi7RixQrdddddkqQlS5aodevW2rlzp7p166ZPP/1UBw8e1Geffabw8HB17NhR06dP19NPP63nn39e/v7+SkpKUmRkpGbMmCFJat26tbZv365Zs2bJYrFIkmbOnKknnnhCI0eOlCQlJSVpw4YNWrx4sZ555ply6z1nzhz169dPEyZMkCRNnz5dKSkpmjt3rpKSkmQYhmbPnq3JkydrwIABkqR33nlH4eHhWrt2rR5++OEqHyMAQPmqdMeSBQsWSJLef/99bdmyxe6xatWqK9rxyy+/LB8fH40fP962jNtsAYDncVR2fPHFF/rXv/6l9u3b2y1nJj0AeJ7qZkdiYqK6dOmihg0bKiwsTLGxscrKyrIrQ98DADyLI8esAADegTErxqwAwCz6HQAAs8gOAIBZjsiOb775Rk2bNtUNN9ygRx55RNnZ2ZKk9PR0nT9/Xn369LGVjYqKUvPmzZWWliZJSktLU7t27ey+HMVisSgvL08HDhywlSm7jdIypdsoLi5Wenq6XRlfX1/16dPHVqY8l9vusWPHZLVa7cqEhIQoOjq60u0WFRUpLy/P7gEAKF+VJpaUKp1NeLlll8OFFgDwHo7Ijvz8fD3yyCNauHChrrrqKtvy0pn0M2fO1F133aXOnTtryZIl2rFjh3bu3ClJtpn0y5cvV8eOHXXPPfdo+vTpmjdvnoqLiyXJbiZ969atFR8frwceeECzZs2y7avsTPo2bdooKSlJ9erV0+LFiyusd9mZ9K1bt9b06dPVqVMnzZ07V5IumUnfvn17vfPOOzp+/LjWrl1r6hgBgCepbnZs27ZNcXFx2rlzp1JSUnT+/Hn17dtX586ds5Wh7wEAnsVRY1YAAO/BmBVjVgBgFv0OAIBZZAcAwKzqZkd0dLSWLl2q5ORkzZ8/X8eOHdMdd9yhs2fPymq1yt/fX40aNbJ7Tnh4uKxWqyTJarXaTSopXV+6rrIyeXl5Kigo0JkzZ3ThwoVyy5RuozwVbbfsfsvWp6rbTUxMVEhIiO3RrFmzCssCgLer0sSSI0eOaMOGDcrLy9PGjRttj9JbuJvBhRYA8B6bNm1ySHbExcWpf//+l8xKZyY9M+kBeB5HZEdycrIeffRR3XLLLerQoYOWLl2q7OxspaenS6LvAQCexlH9DgCA92DMyjljVgDgyRyRHc8//7x8fHzsHlFRUbb13GEXADwLY1YAALMckR333HOPBg8erPbt28tisWjjxo3KycnR+++/78Sa126TJk1Sbm6u7fH999+7ukoAUGvVqUqhAwcOaO3atfr555+1evVq2/KGDRtq4cKFpnZY9kLLiy++aFt+uQst3bp1q/BCy9ixY3XgwAHdeuutFV4QGT9+vKTfLrRMmjTJtr6qF1oSEhIu2W7pB7cud6Hl4YcfLne7RUVFdsHPh4MBeJJ169ZVOztWrlypvXv36osvvrhkXU3NpP/5558rnEl/+PDhCuvuzJn0L7zwQoXrAcCdOSI7fi83N1eS1LhxY0ne2/cAAE/ljOwAAHg2xqycM2bF9Q4AnsxR/Y5bbrlFn332me33OnV+u1z/1FNPacOGDVq9erVCQkIUHx+vgQMH6j//+Y+k3+6wGxERoR07dujEiRMaPny46tatq3/+85+SfrvD7pgxY/Tuu+8qNTVVjz/+uJo0aWL7luPSO+wmJSUpOjpas2fPlsViUVZWlsLCwsqtd+kddhMTE3XfffdpxYoVio2N1d69e9W2bVtJv91hd9myZYqMjNRzzz0ni8WigwcPKjAw0NRxAgBPwJgVAMAsZ2RHo0aNdPPNN+vIkSP6wx/+oOLiYuXk5NiNW508eVIRERGSpIiIiEsmnpdOeC9b5veT4E+ePKng4GAFBQXJz89Pfn5+5ZYp3UZ5Ktpu2f2WLmvSpIldmY4dO1a43YCAAAUEBFS4HgDwmypNLBkwYIAGDBig3bt3q2vXrle8My60XIoPBwPwZG+99ZYOHz58xdnx/fffa9y4cUpJSeGiQxmTJk2y+8BxXl4et2kE4DGqmx2/V1JSovHjx6tHjx62i9ze2PfgA14APJmjswMA4PkYs3IOrncA8GSO6nfUqVOn3A9Sld5hd8WKFbrrrrskSUuWLFHr1q21c+dOdevWzXaH3c8++0zh4eHq2LGjpk+frqefflrPP/+8/P397e6wK0mtW7fW9u3bNWvWLNvEkrJ32JUu3pV3w4YNWrx4sZ555ply6132DruSNH36dKWkpGju3LlKSkq65A67kvTOO+8oPDxca9eu5YtQAHglxqwAAGY5Izvy8/N19OhRDRs2TJ07d1bdunWVmpqqQYMGSZKysrKUnZ2tmJgYSVJMTIxeeuklnTp1yjbxPCUlRcHBwWrTpo2tzO/vYJiSkmLbhr+/vzp37qzU1FTFxsZKunjdPjU1VfHx8RXWNSYmRqmpqbYvcvz9diMjIxUREaHU1FTbRJK8vDzt2rVLY8eOrd6BAgBIquLEklJRUVFKTEzUwYMH7T6UVJXbZHGhpXx8OBiAp6tOdqSnp+vUqVPq1KmTbdmFCxf0+eefa+7cudq0aRMz6QHAA1UnO34vLi5OmZmZ2r59uyOr6Hb4gBcAT+fI7AAAeAfGrBw/ZsX1DgCezhH9jm+++UZNmzZVYGCgYmJilJiYqObNm3vtHXb5MhQAno4xKwCAWdXNjr///e+6//771aJFCx0/flxTp06Vn5+fhgwZopCQEI0aNUoJCQlq3LixgoOD9eSTTyomJkbdunWTJPXt21dt2rTRsGHD9Oqrr8pqtWry5MmKi4uzfVZpzJgxmjt3riZOnKjHHntMmzdv1vvvv68NGzbY6pGQkKARI0botttuU9euXTV79mydO3fONsFdkoYPH65rr71WiYmJkqRx48bpzjvv1IwZM9S/f3+tXLlSe/bs0YIFCyRJPj4+Gj9+vF588UW1bNnSdqfEpk2b2iawAACqx9dM4UceeUQNGjTQrl27NGLECPn4+KhFixZVem7ZCy116tRRnTp1tG3bNr3xxhuqU6eOwsPDbRdayvr9xYzyLnaUrqusTOmFltDQUKdfaDGz3YCAAAUHB9s9AMCTVCc77r77bu3fv18ZGRm2x2233aZHHnnE9nPpTPpS5c2k379/v06dOmUrU95M+rLbKC1T3kz6UqUz6UvLlOdy2y07k75U6Uz6yrYLAJ6uOtlRVnx8vNavX68tW7bouuuusy2PiIjwur7HpEmTlJuba3t8//33Fe4fANyRo7IDAOA9GLNy/JgV1zsAeLrq9juio6O1dOlSJScna/78+Tp27JjuuOMOnT17tsbusHvmzJkK77Bb0Z1wK9tude6wK138MpSQkBDbgwmJADwNY1YAALOqmx0//PCDhgwZolatWunBBx/U1VdfrZ07d+qaa66RJM2aNUv33XefBg0apJ49eyoiIkJr1qyxPd/Pz0/r16+Xn5+fYmJiNHToUA0fPlzTpk2zlYmMjNSGDRuUkpKiDh06aMaMGXr77bdtd0mUpIceekivv/66pkyZoo4dOyojI0PJycl2fYbs7GydOHHC9nv37t21YsUKLViwQB06dNAHH3ygtWvXqm3btrYyEydO1JNPPqnRo0erS5cuys/PV3JyMl92DwAOYmpiyfHjx/Xkk08qMDDQNiNw27ZtVXouF1oAwDtVJzsaNmyotm3b2j3q16+vq6++Wm3btrWbSb9lyxalp6dr5MiRFc6k//LLL7Vp06ZyZ9J/++23mjhxog4fPqy33npL77//vp566ilbXRISErRw4UItW7ZMhw4d0tixY8udSV/2W77GjRun5ORkzZgxQ4cPH9bzzz+vPXv22G7rWHYm/UcffaT9+/dr+PDhzKQH4PWqkx2SZBiG4uPj9eGHH2rz5s2KjIy0W1/2Fr+lPL3vwQe8AHi66mYHAMD7MGbFmBUAmFXdfsc999yjwYMHq3379rJYLNq4caNycnK8+lvr+TIUAJ6OMSsAgFnVzY6VK1fq+PHjKioq0g8//KCVK1fqxhtvtK0PDAzUvHnz9NNPP+ncuXNas2bNJV9e2KJFC23cuFG//PKLTp8+rddff1116tSxK9OrVy/t27dPRUVFOnr0qB599NFL6hIfH6///ve/Kioq0q5duxQdHW23fuvWrVq6dKndssGDBysrK0tFRUXKzMzUvffea7fex8dH06ZNk9VqVWFhoT777DPdfPPNVT4+AIDK1bl8kTKF///hEB4ertTUVDVt2lQ//vhjlZ5beqGlrLIXWiRxmy0A8EDVyY6qmDVrlnx9fTVo0CAVFRXJYrHorbfesq0vnUk/duxYxcTEqH79+hoxYkS5M+mfeuopzZkzR9ddd125M+lPnz6tKVOmyGq1qmPHjuXOpPf1/W3OZulM+smTJ+vZZ59Vy5Yty51Jf+7cOY0ePVo5OTm6/fbbmUkPwOtVNzvi4uK0YsUKrVu3Tg0bNrR9K2JISIiCgoK4xS8AeCBn9zsAAJ6HMSvGrADALEdnR6NGjXTzzTfryJEj+sMf/mC7w27Zu5b8/i62u3fvttuG2Tvs+vn5Of0Ou02aNLEr07Fjxwq3GxAQYBtrAwBPxJgVAMAssgMA4EqmJpY8++yzys3N1YwZM/TXv/5VZ8+e1cyZMx1WGS60AIDncXR2bN261e730pn08+bNq/A5pTPpK1M6k74y8fHxtm9urErdpIsz6QcPHlzhc0pn0pfNMgDwdtXNjvnz50u6eG4va8mSJbZvSqHvAQCexdljVgAAz8OYFWNWAGCWo7MjPz9fR48e1bBhw+zusDto0CBJ5d9h96WXXtKpU6cUFhYmqfw77P4+Wyq6w27pF5SU3mG3siwpvcPu+PHjy91u2Tvslk4kKb3D7tixY6/4GAGAu2PMCgBgFtkBAHAlUxNLBgwYIElq3759uRcizOJCCwB4PkdnBwDA81U3OwzDuGwZ+h4A4FnodwAAzCI7AABmVTc7/v73v+v+++9XixYtdPz4cU2dOlV+fn4aMmQId9gFAA9FvwMAYBbZAQBwJVMTS44ePaq5c+fqu+++04ULF2zLP/roI4dXDADgGcgOAIBZZAcAwCyyAwBgFtkBADCrutnxww8/aMiQIfrxxx91zTXX6Pbbb9fOnTt1zTXXSOIOuwDgieh3AADMIjsAAK5kamLJn/70J8XHx+vBBx+0G0gCAKAiZAcAwCyyAwBgFtkBADCL7AAAmFXd7Fi5cmWl67nDLgB4HvodAACzyA4AgCuZmlhSr149jR492ll1AQB4ILIDAGAW2QEAMIvsAACYRXYAAMwiOwAAZpEdAACzyA4AgCuZmlgyadIkPf300+rTp48CAgJsy3v27OnwigEAPAPZAQAwi+wAAJhFdgAAzCI7AABmkR0AALPIDgCAWWQHAMCVTE0s2bRpk7Zu3aojR47YbrPl4+NDaAEAKkR2AADMIjsAAGaRHQAAs8gOAIBZZAcAwCyyAwBgFtkBAHAlUxNLPvvsM2VlZcnHx8dZ9QEAeBiyAwBgFtkBADCrutmRmJioNWvW6PDhwwoKClL37t31yiuvqFWrVrYyhYWF+tvf/qaVK1eqqKhIFotFb731lsLDw21lsrOzNXbsWG3ZskUNGjTQiBEjlJiYqDp1fhuC27p1qxISEnTgwAE1a9ZMkydP1qOPPmpXn3nz5um1116T1WpVhw4d9Oabb6pr166VtmH16tV67rnn9N1336lly5Z65ZVXdO+999rWG4ahqVOnauHChcrJyVGPHj00f/58tWzZ8oqOGQC4O/odAACzyA4AgFlkBwDALLIDAOBKvmYKd+3aVUePHnVWXQAAHojsAACYRXYAAMyqbnZs27ZNcXFx2rlzp1JSUnT+/Hn17dtX586ds5V56qmn9PHHH2v16tXatm2bjh8/roEDB9rWX7hwQf3791dxcbF27NihZcuWaenSpZoyZYqtzLFjx9S/f3/17t1bGRkZGj9+vB5//HFt2rTJVmbVqlVKSEjQ1KlTtXfvXnXo0EEWi0WnTp2qsP47duzQkCFDNGrUKO3bt0+xsbGKjY1VZmamrcyrr76qN954Q0lJSdq1a5fq168vi8WiwsLCKz5uAODO6HcAAMwiOwAAZpEdAACzyA4AgCuZumNJZmam2rZtq1atWikgIECGYcjHx0e7d+92Vv0AAG6O7AAAmEV2AADMqm52JCcn2/2+dOlShYWFKT09XT179lRubq4WLVqkFStW6K677pIkLVmyRK1bt9bOnTvVrVs3ffrppzp48KA+++wzhYeHq2PHjpo+fbqefvppPf/88/L391dSUpIiIyM1Y8YMSVLr1q21fft2zZo1SxaLRZI0c+ZMPfHEExo5cqQkKSkpSRs2bNDixYv1zDPPlFv/OXPmqF+/fpowYYIkafr06UpJSdHcuXOVlJQkwzA0e/ZsTZ48WQMGDJAkvfPOOwoPD9fatWv18MMPmzziAOD+6HcAAMwiOwAAZpEdAACzyA4AgCuZmliybt06Z9UDAOChyA4AgFlkBwDALEdnR25uriSpcePGkqT09HSdP39effr0sZWJiopS8+bNlZaWpm7duiktLU3t2rVTeHi4rYzFYtHYsWN14MAB3XrrrUpLS7PbRmmZ8ePHS5KKi4uVnp6uSZMm2db7+vqqT58+SktLq7C+aWlpSkhIuGS7a9eulXTxTilWq9Vu3yEhIYqOjlZaWhoTSwB4JfodAACzyA4AgFlkBwDALLIDAOBKVZpYUlRUpICAAF1zzTXOrg8AwMOQHQAAs8gOAIBZjsyOkpISjR8/Xj169FDbtm0lSVarVf7+/mrUqJFd2fDwcFmtVluZspNKSteXrqusTF5engoKCvTzzz/rwoUL5ZY5fPhwhXWuaLtl91u2PuWV+b2ioiIVFRXZfs/Ly6tw/wDgjuh3AADMIjsAAGaRHQAAs8gOAIArVWliyaBBg7R+/Xrdcsst8vHxsd1eq/Tfb7/91tn1BAC4KbIDAGAW2QEAMMuR2REXF6fMzExt377dCTV1H4mJiXrhhRdcXQ0AcBr6HQAAs8gOAIBZZAcAwCyyAwDgSlWaWLJ+/XpJ0rFjx5xaGQCA5yE7AABmkR0AALMclR3x8fFav369Pv/8c1133XW25RERESouLlZOTo7dXUtOnjypiIgIW5ndu3fbbe/kyZO2daX/li4rWyY4OFhBQUHy8/OTn59fuWVKt1GeirZbdr+ly5o0aWJXpmPHjuVuc9KkSUpISLD9npeXp2bNmlVYBwBwN/Q7AABmkR0AALPIDgCAWWQHAMCVfM0U7tq1a5WWAQBQiuwAAJhFdgAAzKpudhiGofj4eH344YfavHmzIiMj7dZ37txZdevWVWpqqm1ZVlaWsrOzFRMTI0mKiYnR/v37derUKVuZlJQUBQcHq02bNrYyZbdRWqZ0G/7+/urcubNdmZKSEqWmptrKlOdy242MjFRERIRdmby8PO3atavC7QYEBCg4ONjuAQCehH4HAMAssgMAYBbZAQAwi+wAALhSle5YcubMGZ08eVL5+fk6dOiQDMOQdPECdF5enlMrCABwX4cOHSI7AACmkB0AALMckR1xcXFasWKF1q1bp4YNG8pqtUqSQkJCFBQUpJCQEI0aNUoJCQlq3LixgoOD9eSTTyomJkbdunWTJPXt21dt2rTRsGHD9Oqrr8pqtWry5MmKi4tTQECAJGnMmDGaO3euJk6cqMcee0ybN2/W+++/rw0bNtjqkpCQoBEjRui2225T165dNXv2bJ07d04jR460lRk+fLiuvfZaJSYmSpLGjRunO++8UzNmzFD//v21cuVK7dmzRwsWLJAk+fj4aPz48XrxxRfVsmVLRUZG6rnnnlPTpk0VGxt75QcfANwU/Q4AgFlkBwDALLIDAGAW2QEAcLUqTSzZsGGDli5dqu+//15xcXG20GrYsKH++c9/OrWCAAD3NWHCBLIDAGAK2QEAMMsR2TF//nxJUq9eveyWL1myRI8++qgkadasWfL19dWgQYNUVFQki8Wit956y1bWz89P69ev19ixYxUTE6P69etrxIgRmjZtmq1MZGSkNmzYoKeeekpz5szRddddp7ffflsWi8VW5qGHHtLp06c1ZcoUWa1WdezYUcnJyQoPD7eVyc7Olq/vbzci7t69u1asWKHJkyfr2WefVcuWLbV27Vq1bdvWVmbixIk6d+6cRo8erZycHN1+++1KTk5WYGBglY+Toxw6dEiSFBoaqubNm9f4/gGAfgcAwCyyAwBgFtkBADCL7AAAuFqVJpaMGDFCI0aM0Nq1a/kWQwBAla1fv16bN28mOwAAVUZ2AADMckR2lF6gqUxgYKDmzZunefPmVVimRYsW2rhxY6Xb6dWrl/bt21dpmfj4eMXHx1e4fuvWrZcsGzx4sAYPHlzhc3x8fDRt2jS7iS41LT8/Xz4+Pho6dKgkKSgoSIcPH2ZyCYAaR78DAGAW2QEAMMsR2ZGYmKg1a9bo8OHDCgoKUvfu3fXKK6+oVatWtjKFhYX629/+ppUrV9p9Gcrvv6Rk7Nix2rJlixo0aKARI0YoMTFRder89rGxrVu3KiEhQQcOHFCzZs00efJk2xeulJo3b55ee+01Wa1WdejQQW+++aa6du1aaRtWr16t5557Tt99951atmypV155Rffee69tvWEYmjp1qhYuXKicnBz16NFD8+fPV8uWLa/4uAGAu6LfAQBwNd/LF/nNwYMHdfbsWV24cEGDBw/WzTffrLVr1zqpagAAT0B2AADMIjsAAGaRHe6hsLBQhmFo4MCBGjhwoAoKCnTmzBlXVwuAlyI7AABmkR0AALOqmx3btm1TXFycdu7cqZSUFJ0/f159+/bVuXPnbGWeeuopffzxx1q9erW2bdum48ePa+DAgbb1Fy5cUP/+/VVcXKwdO3Zo2bJlWrp0qaZMmWIrc+zYMfXv31+9e/dWRkaGxo8fr8cff1ybNm2ylVm1apUSEhI0depU7d27Vx06dJDFYtGpU6cqrP+OHTs0ZMgQjRo1Svv27VNsbKxiY2OVmZlpK/Pqq6/qjTfeUFJSknbt2qX69evLYrGosLCwyscJADwJ/Q4AgCuZmliyevVqNWzYUOvXr1dgYKC2b9+uF154wVl1AwB4ALIDAGAW2QEAMIvscC+hoaEKDQ11dTUAeDmyAwBgFtkBADCrutmRnJysRx99VLfccos6dOigpUuXKjs7W+np6ZKk3NxcLVq0SDNnztRdd92lzp07a8mSJdqxY4d27twpSfr000918OBBLV++XB07dtQ999yj6dOna968eSouLpYkJSUlKTIyUjNmzFDr1q0VHx+vBx54QLNmzbLVZebMmXriiSc0cuRItWnTRklJSapXr54WL15cYf3nzJmjfv36acKECWrdurWmT5+uTp06ae7cuZIu3q1k9uzZmjx5sgYMGKD27dvrnXfe0fHjx/kQNQCvRb8DAOBKpiaWFBQUSJLWrVunhx9+WGFhYTIMwykVAwB4BrIDAGAW2QEAMIvsAACYRXYAAMwiOwAAZjk6O3JzcyVJjRs3liSlp6fr/Pnz6tOnj61MVFSUmjdvrrS0NElSWlqa2rVrp/DwcFsZi8WivLw8HThwwFam7DZKy5Ruo7i4WOnp6XZlfH191adPH1uZ8lxuu8eOHZPVarUrExISoujo6Aq3W1RUpLy8PLsHAHgS+h0AAFcyNbHk/vvvV4sWLZSenq6+ffvq9OnTCggIcFbdAAAegOwAAJhFdgAAzCI7AABmkR0AALPIDgCAWY7MjpKSEo0fP149evRQ27ZtJUlWq1X+/v5q1KiRXdnw8HBZrVZbmbKTSkrXl66rrExeXp4KCgp05swZXbhwodwypdsoT0XbLbvfsvWpynYTExMVEhJiezRr1qzC/QOAO6LfAQBwJVMTS1577TXt27dPe/fuVd26dVWvXj2tW7fOWXUDAHgAsgMAYBbZAQAwi+wAAJhFdgAAzCI7AABmOTI74uLilJmZqZUrVzq4lu5l0qRJys3NtT2+//57V1cJAByKfgcAwJVMTSzJycnRyy+/rGHDhkmSfvjhB/373/92SsUAAJ6B7AAAmEV2AADMIjsAAGaRHQAAs8gOAIBZjsqO+Ph4rV+/Xlu2bNF1111nWx4REaHi4mLl5OTYlT958qQiIiJsZU6ePHnJ+tJ1lZUJDg5WUFCQQkND5efnV26Z0m2Up6Ltlt1v2fpUZbsBAQEKDg62ewCAJ6HfAQBwJVMTS0aMGKHWrVsrMzNTkhQZGanp06c7pWIAAM9AdgAAzCI7AABmkR0AALPIDgCAWWQHAMCs6maHYRiKj4/Xhx9+qM2bNysyMtJufefOnVW3bl2lpqbalmVlZSk7O1sxMTGSpJiYGO3fv1+nTp2ylUlJSVFwcLDatGljK1N2G6VlSrfh7++vzp0725UpKSlRamqqrUx5LrfdyMhIRURE2JXJy8vTrl27Kt0uAHgy+h0AAFcyNbHk+PHjGjlypPz8/CRd7Dj4+praBADAy5AdAACzyA4AgFlkBwDALLIDAGAW2QEAMKu62REXF6fly5drxYoVatiwoaxWq6xWqwoKCiRJISEhGjVqlBISErRlyxalp6dr5MiRiomJUbdu3SRJffv2VZs2bTRs2DB9+eWX2rRpkyZPnqy4uDgFBARIksaMGaNvv/1WEydO1OHDh/XWW2/p/fff11NPPWWrS0JCghYuXKhly5bp0KFDGjt2rM6dO6eRI0faygwfPlyTJk2y/T5u3DglJydrxowZOnz4sJ5//nnt2bNH8fHxkiQfHx+NHz9eL774oj766CPt379fw4cPV9OmTRUbG3tlBx0A3Fx1syMxMVFdunRRw4YNFRYWptjYWGVlZdmV6dWrl3x8fOweY8aMsSuTnZ2t/v37q169egoLC9OECRP066+/2pXZunWrOnXqpICAAN10001aunTpJfWZN2+err/+egUGBio6Olq7d+++bBtWr16tqKgoBQYGql27dtq4caPdesMwNGXKFDVp0kRBQUHq06ePvvnmmyoeIQBAZUyNdNWvX185OTny8fGRJO3du1cNGzZ0SsUAAJ6hutlRlQ5PYWGh4uLidPXVV6tBgwYaNGjQJbfLpcMDAO6DfgcAwCyyAwBgFmNWjFkBgFn0OwAAZlU3O+bPn6/c3Fz16tVLTZo0sT1WrVplKzNr1izdd999GjRokHr27KmIiAitWbPGtt7Pz0/r16+Xn5+fYmJiNHToUA0fPlzTpk2zlYmMjNSGDRuUkpKiDh06aMaMGXr77bdlsVhsZR566CG9/vrrmjJlijp27KiMjAwlJycrPDzcViY7O1snTpyw/d69e3etWLFCCxYsUIcOHfTBBx9o7dq1atu2ra3MxIkT9eSTT2r06NHq0qWL8vPzlZycrMDAwCofJwDwJNXNjm3btikuLk47d+5USkqKzp8/r759++rcuXN25Z544gmdOHHC9nj11Vdt6y5cuKD+/furuLhYO3bs0LJly7R06VJNmTLFVubYsWPq37+/evfurYyMDI0fP16PP/64Nm3aZCuzatUqJSQkaOrUqdq7d686dOggi8Vidxet39uxY4eGDBmiUaNGad++fYqNjVVsbKztDi6S9Oqrr+qNN95QUlKSdu3apfr168tisaiwsLDKxwkAUD5TE0tmzJih2NhYHTt2THfffbcefvhhvfHGG1V+PhdaAMD7VDc7qtLheeqpp/Txxx9r9erV2rZtm44fP66BAwfa1tPhAQD3Ut3sAAB4H7IDAGAWY1aMWQGAWfQ7AABmVTc7DMMo9/Hoo4/aygQGBmrevHn66aefdO7cOa1Zs0YRERF222nRooU2btyoX375RadPn9brr7+uOnXq2JXp1auX9u3bp6KiIh09etRuH6Xi4+P13//+V0VFRdq1a5eio6Pt1m/duvWSz2cNHjxYWVlZKioqUmZmpu6991679T4+Ppo2bZqsVqsKCwv12Wef6eabb67yMXKkQ4cOae/evcrOznbJ/gFAqn52JCcn69FHH9Utt9yiDh06aOnSpcrOzlZ6erpduXr16ikiIsL2CA4Otq379NNPdfDgQS1fvlwdO3bUPffco+nTp2vevHkqLi6WJCUlJSkyMlIzZsxQ69atFR8frwceeECzZs2ybWfmzJl64oknNHLkSLVp00ZJSUmqV6+eFi9eXGH958yZo379+mnChAlq3bq1pk+frk6dOmnu3LmSLmbj7NmzNXnyZA0YMEDt27fXO++8o+PHj2vt2rVVPk4AgPLVuXyR33Tu3FmfffaZsrKyVFJSoqioKNWtW7fKzy+90NKlSxf9+uuvevbZZ9W3b18dPHhQ9evXl3TxQsuGDRu0evVqhYSEKD4+XgMHDtR//vMfSb9daImIiNCOHTt04sQJDR8+XHXr1tU///lPSb9daBkzZozeffddpaam6vHHH1eTJk1ss+lLL7QkJSUpOjpas2fPlsViUVZWlsLCwsqtf+mFlsTERN13331asWKFYmNjtXfvXtts+tILLcuWLVNkZKSee+45WSwWHTx4kNn0ALxSdbMjOTnZ7velS5cqLCxM6enp6tmzp3Jzc7Vo0SKtWLFCd911lyRpyZIlat26tXbu3Klu3brZOjyfffaZwsPD1bFjR02fPl1PP/20nn/+efn7+9t1eCSpdevW2r59u2bNmmXLjrIdHuliJ2nDhg1avHixnnnmmXLrX7bDI0nTp09XSkqK5s6dq6SkpEs6PJL0zjvvKDw8XGvXrtXDDz9s4mgDgGeobnYAALwP2QEAMIsxK8asAMAs+h0AALPIDveQn58vHx8fDR06VJIUFBSkw4cPq3nz5i6uGQBv5OjsyM3NlSQ1btzYbvm7776r5cuXKyIiQvfff7+ee+451atXT5KUlpamdu3a2d2VymKxaOzYsTpw4IBuvfVWpaWlqU+fPnbbtFgsGj9+vCSpuLhY6enpmjRpkm29r6+v+vTpo7S0tArrm5aWpoSEhEu2Wzpp5NixY7JarXb7DgkJUXR0tNLS0sodsyoqKlJRUZHt97y8vAr3DwDeztQdSySpTp06uuWWW9SuXTvTgXW52ZClF1pmzpypu+66S507d9aSJUu0Y8cO7dy5UxKzIQHAHVUnO37v9x2e9PR0nT9/3q7DEBUVpebNm9s6IhV1ePLy8nTgwAFbmfI6PKXbKO3wlC1T1Q5PZdu9XIcHALyVI7MDAOAdyA4AgFmMWTFmBQBm0e8AAJhFdtR+hYWFMgxDAwcO1MCBA1VQUKAzZ864uloAvJijsqOkpETjx49Xjx49bF+cLkl//vOftXz5cm3ZskWTJk3S//t//882uU6SrFar3XiVJNvvVqu10jJ5eXm28+iFCxfKLVO6jfJUtN2y+y1bn6psNzExUSEhIbZHs2bNKtw/AHg70xNLHIkLLRdnQ+bl5dk9AADlK6/DY7Va5e/vr0aNGtmV/X2nwpM6PGQHAAAAAABA7cGY1UWMWQEAAABwZ6GhoQoNDXV1NQDAYeLi4pSZmamVK1faLR89erQsFovatWunRx55RO+8844+/PBDHT161EU1da5JkyYpNzfX9vj+++9dXSUAqLVcNrGECy0XMRsSAKquog6PtyE7AAAAAAAAag/GrC5izAoAAAAAAKB2iI+P1/r167VlyxZdd911lZaNjo6WJB05ckSSFBERoZMnT9qVKf09IiKi0jLBwcEKCgpSaGio/Pz8yi1Tuo3yVLTdsvstW5+qbDcgIEDBwcF2DwBA+ao0sWTOnDm2n/fu3euQHXOh5SJmQwLwBo7Ijoo6PBERESouLlZOTo5d+d93Kjypw0N2APAGjup3oGYdOnRI2dnZrq4GAC9FdgAAzGLMijErADCLfgcAwCyyAwBgVnWywzAMxcfH68MPP9TmzZsVGRl52edkZGRIkpo0aSJJiomJ0f79+3Xq1ClbmZSUFAUHB6tNmza2MqmpqXbbSUlJUUxMjCTJ399fnTt3titTUlKi1NRUW5nyXG67kZGRioiIsCuTl5enXbt2VbpdAEDVVGliybJly2w/P/7449XeKRdafsNsSADeoDrZcbkOT+fOnVW3bl27DkNWVpays7NtHQZP6/CQHQC8gSP6Hag5+fn58vHx0dChQxUVFcXkEgAuQXYAAMxizIoxKwAwi34HAMAssgMAYFZ1siMuLk7Lly/XihUr1LBhQ1mtVlmtVhUUFEiSjh49qunTpys9PV3fffedPvroIw0fPlw9e/ZU+/btJUl9+/ZVmzZtNGzYMH355ZfatGmTJk+erLi4OAUEBEiSxowZo2+//VYTJ07U4cOH9dZbb+n999/XU089ZatLQkKCFi5cqGXLlunQoUMaO3aszp07p5EjR9rKDB8+XJMmTbL9Pm7cOCUnJ2vGjBk6fPiwnn/+ee3Zs0fx8fGSJB8fH40fP14vvviiPvroI+3fv1/Dhw9X06ZNFRsbe8XHDQBwUZUmljgKF1oAAGZdrsMTEhKiUaNGKSEhQVu2bFF6erpGjhypmJgYdevWTRIdHgAAnK2wsFCGYahnz54qKCjQmTNnXF0lAAAAwKkYswIAAAAAAEBtM3/+fOXm5qpXr15q0qSJ7bFq1SpJFz87+9lnn6lv376KiorS3/72Nw0aNEgff/yxbRt+fn5av369/Pz8FBMTo6FDh2r48OGaNm2arUxkZKQ2bNiglJQUdejQQTNmzNDbb78ti8ViK/PQQw/p9ddf15QpU9SxY0dlZGQoOTlZ4eHhtjLZ2dk6ceKE7ffu3btrxYoVWrBggTp06KAPPvhAa9euVdu2bW1lJk6cqCeffFKjR49Wly5dlJ+fr+TkZAUGBjrlmAKAN6lTlUKnT5/WW2+9JcMwbD+X9Ze//KVKO4uLi9OKFSu0bt0624UW6eIFlqCgILsLLY0bN1ZwcLCefPLJCi+0vPrqq7JareVeaJk7d64mTpyoxx57TJs3b9b777+vDRs22OqSkJCgESNG6LbbblPXrl01e/bsci+0XHvttUpMTJR08ULLnXfeqRkzZqh///5auXKl9uzZowULFkiyv9DSsmVLRUZG6rnnnuNCCwCvtXDhQgUGBlYrO+bPny9J6tWrl93yJUuW6NFHH5UkzZo1S76+vho0aJCKiopksVjs9lfa4Rk7dqxiYmJUv359jRgxotwOz1NPPaU5c+bouuuuK7fDc/r0aU2ZMkVWq1UdO3Yst8Pj6/vbvM3SDs/kyZP17LPPqmXLluV2eM6dO6fRo0crJydHt99+Ox0eAF7LEdkB1wkJCXF1FQB4IbIDAGAWY1aMWQGAWfQ7AABmkR0AALMckR2GYVS6vlmzZtq2bdtlt9OiRQtt3Lix0jK9evXSvn37Ki0THx9v+yKT8mzduvWSZYMHD9bgwYMrfI6Pj4+mTZtmN4YGAHCMKk0sefzxx3X69OlLfjaLCy0A4F1+/PFHBQQEVCs7LtfhkaTAwEDNmzdP8+bNq7AMHR4AcA+OyA4AgHchOwAAZjFmdRFjVgBQdfQ7AABmkR0AALPIDgCAq1VpYsnUqVMdsjMutACAd3nmmWcUHBzs6moAANwI2QEAMIvsAACYRXYAAMwiOwAAZpEdAACzyA4AgKtVaWLJ5SZJTJkyxSGVAQB4lldeeUUBAQHlriM7AADlITsAAGaRHQAAs8gOAIBZZAcAwCyyAwBgFtkBAHA136oUmjZtmtasWSNJCg0N1dVXX233AACgPB9//LEkssOdHDp0SHv37lV2drarqwLAS5EdAACzyA4AgFlkBwDALLIDAGAW2QEAMIvsAAC4WpXuWPLDDz/ogw8+0Icffih/f38NHjxYf/rTn3TVVVc5u34AADc2fPhwffLJJ2SHG8jPz5ePj4+GDh0qSQoKCtLhw4fVvHlzF9cMgLchOwAAZpEdAACzyA4AgFlkBwDALLIDAGAW2QEAcLUq3bEkIiJC8fHxSk1N1eLFi5Wbm6vWrVtr2bJlzq4fAMCNjR49muxwE4WFhTIMQwMHDtTAgQNVUFCgM2fOuLpaALwQ2QEAMIvsAACYRXYAAMwiOwAAZpEdAACzyA4AgKtV6Y4lkmQYhrZt26ZVq1Zp9+7dGjJkiHr06OHMugEA3JxhGNq6dSvZ4UZCQ0NdXQUAXo7s8AyHDh2SdDFXuPsVAGcjOwAAZpEdAACzyA4AgFlkBwDALLIDAOBqVZpYEh8fr507d+qOO+7Q8OHDNX/+fGfXCwDgAXr16qVevXqRHQCAKiM73Nsvv/wiHx8fDR06VJIUFBSkw4cPM7kEgFORHe7t0KFDTEQEUOPIDgCAWWQHAMAssgMAYBbZAQBwtSpNLHnrrbfUuHFj/fe//9Xy5cvl4+Mj6eIMSR8fH506dcqplQQAuKfs7GwtX76c7AAAVBnZ4d6Ki4tlGIYGDhwoSVqzZo3OnDnDh4UBOBXZ4Z7y8/NtkxGZiAigppEdAACzyA4AgFlkBwDALLIDAOBqVZpYUlJS4ux6AAA80LFjxxQcHOzqagAA3AjZ4RlCQ0NdXQUAXoTscE+FhYUyDEM9e/bU559/zkREADWK7AAAmEV2AADMIjsAAGaRHQAAV6vSxJLCwkIlJSXpyJEjat++vR577DHVqVOlpwIAvNhbb72lH374gewAAFQZ2QEAMIvscG8hISGurgIAL0R2AADMIjsAAGaRHQAAs8gOAICr+Val0IgRI7Rnzx61a9dOGzdu1N///ndn1wsA4AH27dtHdgAATCE7AABmkR0AALPIDgCAWWQHAMAssgMAYBbZAQBwtSpNaTx48KD2798vSRo1apS6du3q1EoBADzDwoULFRwcTHYAAKqM7AAAmEV2AADMIjsAAGaRHQAAs8gOAIBZZAcAwNWqdMeSunXr2n7m9loAALPIDgCAWWQHAMAssgMAYBbZAQAwi+wAAJhFdgAAzCI7AACuUqUE+uqrrxQWFiZJMgxDOTk5CgsLk2EY8vHx0alTp5xaSQCAe7rxxhvl4+NDdgAAqozsAACYRXYAAMwiOwAAZpEdAACzyA4AgFlkBwDA1ao0seTXX391dj3gBIcOHZIkhYaGqnnz5i6uDQBvdPToUQUHB7u6GgAAN0J2AADMIjsAAGaRHQAAs8gOAIBZZId7O3ToEJ+3AlDjyA4AgKtxzywPlJ+fLx8fHw0dOlSSFBQUpMOHD9PZAQAAAAAAAAAAbocv0gIAAABQE8p+5orPWwEAAMDb+Lq6AnC8wsJCGYahgQMHauDAgSooKNCZM2dcXS0AAAAAAAAAAIAqK/uhrs6dOysqKkrZ2dmurhYAAAAAD1X6mauePXvyeSsAAAB4He5Y4sFCQ0NdXQUAAAAAAADgsvgmegBAecp+kZYkrVmzRmfOnCErAAAAADhVSEiIq6sAAAAA1DgmlgAAAAAAnIYPCgMAKvPLL7/YvolekoKCgnT48GEyAwBghy/SAgAAAAAAAADAuZhYAgAAAABwuPz8fD4oDAC4rOLiYr6JHgAAAAAAAAAAAABczNfVFQAAAAAAeJ7CwkLbB4UHDhyogoICnTlzxtXVAgDUUqGhoXwbPQAAAAAAAAAAAAC4CBNLvMShQ4eUnZ3t6moAAAAA8DJ8UBgAAACAI3G9AwAAAAAAAAAAx2NiiYfLz8+Xj4+Phg4dqqioKC62AAAAAAAAAAAAt8P1DgAAAAAAAAAAnIeJJR6usLBQhmGoZ8+eKigo0JkzZ1xdJQAAAABe6tChQ9q7dy8fAAMAAABgGtc7AAAAAAAAUJtw/RuAp6nj6gqgZoSEhLi6CgAAN3Po0CGFhoaqefPmrq4KAMDNlf1mYUkKCgrS4cOHyRgAQLkOHTokSfRHAADl4noHAAAAgJrCOBUAoDxc/wbgqZhY4mXo8AAALqds54eODwDAEUq/WXjgwIGSpDVr1ujMmTPkCwDADhdiAABmcL0DAAAAgLP88ssvduNUAQEB+r//+z81adKEPggAgOvfADyWr6sr4Grz5s3T9ddfr8DAQEVHR2v37t2Vll+9erWioqIUGBiodu3aaePGjXbrDcPQlClT1KRJEwUFBalPnz765ptvnNmEKinb4encubOioqK4/RYAXCFPz47Szk/Pnj1VUFCgM2fOuKwuAOApPD07qio0NFShoaGSuC0wAFyON2ZH2QsxAwcOVEFBgf7973+TFwBQRd6SHVzvAADH8ZbsAAA4jrdkR3FxsW2cql+/fiouLtZ9991HHwQAroAnZ0fZ698A4Am8emLJqlWrlJCQoKlTp2rv3r3q0KGDLBaLTp06VW75HTt2aMiQIRo1apT27dun2NhYxcbGKjMz01bm1Vdf1RtvvKGkpCTt2rVL9evXl8ViUWFhYU01q1xlOzxcmAeAK+dN2RESEiKJD/4CQHV5U3ZURdlvo+/cubNuvvlmbdiwgZwBgDK8PTtCQ0MVGBhYbl7QNwGA8nlTdnC9AwAcw5uyAwDgGN6YHaGhoapXrx59EAC4Qt6UHYcOHSIXALi9Oq6ugCvNnDlTTzzxhEaOHClJSkpK0oYNG7R48WI988wzl5SfM2eO+vXrpwkTJkiSpk+frpSUFM2dO1dJSUkyDEOzZ8/W5MmTNWDAAEnSO++8o/DwcK1du1YPP/xwzTWuAqGhoXYf5JLsb9dYVFSkgIAASbL97OhbOGZnZ9u+/Z7bQwJwN96UHZXd3rdsXnAuB4DKeVN2VEXZb6P/5ZdftGnTJt13332X7ZeU/fly6x31PDIOgKuQHRXnhfRb36Rx48ZOywBHPo88AVATvDE7ruR6h6PzgHM8AHfm6dlx6NAhSc675g0A3sjTs+NyqtoHYTwJAH7jDdlRNhv4bBUAd+e1E0uKi4uVnp6uSZMm2Zb5+vqqT58+SktLK/c5aWlpSkhIsFtmsVi0du1aSdKxY8dktVrVp08f2/qQkBBFR0crLS2t3NAqKipSUVGR7ffc3FxJUl5enqn25OfnS5JOnDihnJycS34u3W7pMsMw1L17dxUVFSk9Pd12Yb48AQEB+n//7/8pPDxcvr6+KikpkaRyf77c+pMnT2rYsGG2Npduu0mTJpU+70r354jn1cQ+aBPHoja3KSIiQhERETKj9BxmGIap59V23pYdp0+frlJelJcTte3voqafV5vrxrGgTWRHzfK27Ph9v6Oyn8+fP69z587JMAzdfPPN+vrrryvtl7hCTfZXavM5oqafV5vrRpvIjppAdlScF1Udy6ptHDm25ojn1eZzC21yj7rVlmNBdvzG27PDlRlR3XGxsj/X5ufV5rrRJveoW205FmTHbzw5OwoKCiTJ9oHfUmbel5f9mb9f2uQOdeNYkB01wZOzw+yYVU30QS6XW7X57+lKn1eb68axoE1kx5Xxpuy43DXv2nBer81/T7SJY+FudXN0m2pTdnjtxJIzZ87owoULCg8Pt1seHh6uw4cPl/scq9Vabnmr1WpbX7qsojK/l5iYqBdeeOGS5c2aNataQ37n448/Lvfnr7766pJlO3bsqNI2i4qK9OCDD15RfVy5bQCud/bsWYWEhLi6Gg7jrdlxubzgXA7AkcgOz8iOitZX9PPXX399RfVwNjIOcA9kh/dkR1XHsmob8gSofcgOz8sOV2UE53jAe5Ad7pcdv8c5G0BNIzvcLzvMjFk5uw9CbgHeiexw7+yo7Jo353UAzuLo7PDaiSW1xaRJk+xmWJaUlOinn37S1VdfLR8fnypvJy8vT82aNdP333+v4OBgZ1S11uMYXMRx4BiUcuVxMAxDZ8+eVdOmTWt0v96C7Kgc7XIvtMu9OLNdZIdzeXN2uFud3a2+kvvV2d3qK7lfnWuqvmSHc3lzdlSVJ7dN8uz20Tb3Vd32kR3ORXZcOW9rs7e1V/K+NntSe8kO5yI7agbHp3Icn8pxfCpX3vEhO5yL7LgUbamdaEvtVFvbQnY4F9lRu3FcnYPj6hy16bg6Kzu8dmJJaGio/Pz8dPLkSbvlJ0+erPB2MhEREZWWL/335MmTatKkiV2Zjh07lrvNgIAABQQE2C1r1KiRmabYCQ4OdvmL1dU4BhdxHDgGpVx1HDxpBn0pssO90C73Qrvci7PaRXZcRHY4h7vV2d3qK7lfnd2tvpL71bkm6kt2XER2uJYnt03y7PbRNvdVnfaRHReRHbWTt7XZ29oreV+bPaW9ZMdFZIf74/hUjuNTOY5P5X5/fMiOi8iOmkVbaifaUjvVxraQHReRHd6L4+ocHFfnqC3H1RnZ4evwLboJf39/de7cWampqbZlJSUlSk1NVUxMTLnPiYmJsSsvSSkpKbbykZGRioiIsCuTl5enXbt2VbhNAID7IDsAAGaRHQAAs8gOAIBZZAcAwCyyAwBgFtkBADCL7AAA9+O1dyyRpISEBI0YMUK33XabunbtqtmzZ+vcuXMaOXKkJGn48OG69tprlZiYKEkaN26c7rzzTs2YMUP9+/fXypUrtWfPHi1YsECS5OPjo/Hjx+vFF19Uy5YtFRkZqeeee05NmzZVbGysq5oJAHAgsgMAYBbZAQAwi+wAAJhFdgAAzCI7AABmkR0AALPIDgBwL149seShhx7S6dOnNWXKFFmtVnXs2FHJyckKDw+XJGVnZ8vX97ebunTv3l0rVqzQ5MmT9eyzz6ply5Zau3at2rZtayszceJEnTt3TqNHj1ZOTo5uv/12JScnKzAw0KltCQgI0NSpUy+5ZZc34RhcxHHgGJTiODgH2VH70S73Qrvci6e2y9nIDtdytzq7W30l96uzu9VXcr86u1t9ayOywz14ctskz24fbXNfnt6+6iA73Ju3tdnb2it5X5u9rb3uiuzwHhyfynF8KsfxqZy3HR+yo3aiLbUTbamdPKkt7oLswOVwXJ2D4+oc3nBcfQzDMFxdCQAAAAAAAAAAAAAAAAAAAAAAANQ838sXAQAAAAAAAAAAAAAAAAAAAAAAgCdiYgkAAAAAAAAAAAAAAAAAAAAAAICXYmIJAAAAAAAAAAAAAAAAAAAAAACAl2JiCQAAAAAAAAAAAAAAAAAAAAAAgJdiYokHmDdvnq6//noFBgYqOjpau3fvdnWVnOr555+Xj4+P3SMqKsq2vrCwUHFxcbr66qvVoEEDDRo0SCdPnnRhjavv888/1/3336+mTZvKx8dHa9eutVtvGIamTJmiJk2aKCgoSH369NE333xjV+ann37SI488ouDgYDVq1EijRo1Sfn5+Dbai+i53HB599NFLXhv9+vWzK+PuxyExMVFdunRRw4YNFRYWptjYWGVlZdmVqcrfQHZ2tvr376969eopLCxMEyZM0K+//lqTTYGLuVt2OOLcXxte9zV1Pv/qq690xx13KDAwUM2aNdOrr77q0nY56vxc0+2qyXPu1q1b1alTJwUEBOimm27S0qVLXdquXr16XfJ/NmbMmFrdLjhfbcoOd3t/7I7v4ebPn6/27dsrODhYwcHBiomJ0SeffFJr6/t7L7/8snx8fDR+/PhaW2d3fH/zv//9T0OHDtXVV1+toKAgtWvXTnv27LGtr21/e6gdalN+VJW75YwZ7phJVeXu2WWGO+ScGe6YiXAud8yO8nj6a9tTx7kq46ljYBXx1LExeCZPyY7KeON51wzOWZWrqf6SOx6b33Nmf8sTjo8ncbfscOfPSnnSWJsnfW7Jk8YJa/L6N7ybu2WHK3n6uFhNoR/oHN42xmeaAbe2cuVKw9/f31i8eLFx4MAB44knnjAaNWpknDx50tVVc5qpU6cat9xyi3HixAnb4/Tp07b1Y8aMMZo1a2akpqYae/bsMbp162Z0797dhTWuvo0bNxr/+Mc/jDVr1hiSjA8//NBu/csvv2yEhIQYa9euNb788kvjj3/8oxEZGWkUFBTYyvTr18/o0KGDsXPnTuPf//63cdNNNxlDhgyp4ZZUz+WOw4gRI4x+/frZvTZ++uknuzLufhwsFouxZMkSIzMz08jIyDDuvfdeo3nz5kZ+fr6tzOX+Bn799Vejbdu2Rp8+fYx9+/YZGzduNEJDQ41Jkya5oklwAXfMjuqe+2vL674mzue5ublGeHi48cgjjxiZmZnGe++9ZwQFBRn/+te/XNYuR5yfXdGumjrnfvvtt0a9evWMhIQE4+DBg8abb75p+Pn5GcnJyS5r15133mk88cQTdv9nubm5tbpdcK7alh3u9v7YHd/DffTRR8aGDRuMr7/+2sjKyjKeffZZo27dukZmZmatrG9Zu3fvNq6//nqjffv2xrhx42zLa1ud3e39zU8//WS0aNHCePTRR41du3YZ3377rbFp0ybjyJEjtjK17W8Prlfb8qOq3C1nzHDHTKoqd84uM9wl58xwt0yEc7lrdpTH01/bnjrOVRlPHQOriKeOjcHzeFJ2VMYbz7tmcM6qXE30l9z12JTlzP6WJxwfT+KO2eHOn5XypLE2T/rckieNE9bU9W94N3fMDlfy9HGxmkI/0Dm8bYzPLCaWuLmuXbsacXFxtt8vXLhgNG3a1EhMTHRhrZxr6tSpRocOHcpdl5OTY9StW9dYvXq1bdmhQ4cMSUZaWloN1dC5fn8iKykpMSIiIozXXnvNtiwnJ8cICAgw3nvvPcMwDOPgwYOGJOOLL76wlfnkk08MHx8f43//+1+N1d2RKjqhDxgwoMLneOJxOHXqlCHJ2LZtm2EYVfsb2Lhxo+Hr62tYrVZbmfnz5xvBwcFGUVFRzTYALuGO2VHdc39tfN0763z+1ltvGVdddZVdu55++mmjVatWTm7RRc46P7u6XYbhvHPuxIkTjVtuucVuXw899JBhsVic3STDMC5tl2FcHFgre9Hk99yhXXCs2pwd7vj+2F3fw1111VXG22+/Xavre/bsWaNly5ZGSkqK3bmsNtbZ3d7fPP3008btt99e4Xp3+NtDzavN+VFV7pgzZrhrJlWVO2SXGe6Uc2a4WybCuTwhO0p502vbU8e5KuPJY2AV8dSxMbg/T8qOqvLG865ZnLMuz9H9JXc/Ns7ub7n78fE07pgdnvJZKU8aa/O0zy150jihs65/w7u5Y3a4kjeNi9UU+oHO4Y1jfJfjW63bncCliouLlZ6erj59+tiW+fr6qk+fPkpLS3NhzZzvm2++UdOmTXXDDTfokUceUXZ2tiQpPT1d58+ftzsmUVFRat68uccek2PHjslqtdq1OSQkRNHR0bY2p6WlqVGjRrrttttsZfr06SNfX1/t2rWrxuvsTFu3blVYWJhatWqlsWPH6scff7St88TjkJubK0lq3LixpKr9DaSlpaldu3YKDw+3lbFYLMrLy9OBAwdqsPZwBXfOjuqc+93hde+o83laWpp69uwpf39/WxmLxaKsrCz9/PPPNdSaS1X3/Fwb2uWsc25aWprdNkrL1NTf5O/bVerdd99VaGio2rZtq0mTJumXX36xrXOHdsFx3C073OH9sbu9h7tw4YJWrlypc+fOKSYmplbXNy4uTv3797/k/FNb6+xO728++ugj3XbbbRo8eLDCwsJ06623auHChbb17vC3h5rlbvlRVZ72Wne3TKoqd8ouM9wt58xwp0yE83hidnjra9vTx7kq4wljYBXx1LExuDdPzI4r4c3n3YpwzqqYs/pL7n5snN3fcvfj40ncOTs88bNSnjbWJrnv55Y8aZzQWde/4b3cOTtcyVvHxWoK/UDn8uQxvsup4+oK4MqdOXNGFy5csDt5SlJ4eLgOHz7solo5X3R0tJYuXapWrVrpxIkTeuGFF3THHXcoMzNTVqtV/v7+atSokd1zwsPDZbVaXVNhJyttV3mvg9J1VqtVYWFhduvr1Kmjxo0be9Rx6devnwYOHKjIyEgdPXpUzz77rO655x6lpaXJz8/P445DSUmJxo8frx49eqht27aSVKW/AavVWu7rpXQdPJu7Zkd1z/3u8Lp31PncarUqMjLykm2UrrvqqqucUv/KOOL87Op2OfOcW1GZvLw8FRQUKCgoyBlNklR+uyTpz3/+s1q0aKGmTZvqq6++0tNPP62srCytWbPGLdoFx3K37Kjt74/d6T3c/v37FRMTo8LCQjVo0EAffvih2rRpo4yMjFpZ35UrV2rv3r364osvLllXG4+xu72/+fbbbzV//nwlJCTo2Wef1RdffKG//vWv8vf314gRI2r93x5qnrvlR1V50mvdnTKpqtwtu8xwt5wzw90yEc7jadnhza9tTx7nqownjIFVxFPHxuD+PC07rpS3nncrwjmrfM7uL7nzsamJ/pY7Hx9P467Z4amflfKksTbJfT+35EnjhM68/g3v5a7Z4UrePC5WU+gHOo8nj/FVBRNL4Hbuuece28/t27dXdHS0WrRooffff5/Otpd7+OGHbT+3a9dO7du314033qitW7fq7rvvdmHNnCMuLk6ZmZnavn27q6sCOB3nfvfmCednTz3nVtSu0aNH235u166dmjRporvvvltHjx7VjTfeWNPVBDyKO51PWrVqpYyMDOXm5uqDDz7QiBEjtG3bNldXq1zff/+9xo0bp5SUFAUGBrq6OlXibu9vSkpKdNttt+mf//ynJOnWW29VZmamkpKSNGLECBfXDsCVcKdMqip3yi4z3DHnzHC3TASqite29/GEMbCKeOL7BgCei3NW+Ty1v1Rdnt7fguegf+Ee3LVP4EnZyfVvoHYgt+DO3DXPHcXX1RXAlQsNDZWfn59Onjxpt/zkyZOKiIhwUa1qXqNGjXTzzTfryJEjioiIUHFxsXJycuzKePIxKW1XZa+DiIgInTp1ym79r7/+qp9++sljj4sk3XDDDQoNDdWRI0ckedZxiI+P1/r167VlyxZdd911tuVV+RuIiIgo9/VSug6ezVOyw+y53x1e9446n7tDW6/k/OzKdjn7nFtRmeDgYKd2qCtqV3mio6Mlye7/rLa2C47nbtlRm98fu9t7OH9/f910003q3LmzEhMT1aFDB82ZM6dW1jc9PV2nTp1Sp06dVKdOHdWpU0fbtm3TG2+8oTp16ig8PLzW1fn3avv7myZNmqhNmzZ2y1q3bm27bXVt/tuDa7hbflSVp7zW3S2TqsqdsssMT8g5M2p7JsJ5PDU7SnnTa9ubxrkq425jYBXx1LExeAZPz46q4rz7G85ZFXN2f8ldj01N9bfc9fh4Ik/JDk/5rJSnjLVVxB0+t+RJ44TOvv4N7+Up2eFK3jQuVlPoB9YcTxnjqyomlrgxf39/de7cWampqbZlJSUlSk1NVUxMjAtrVrPy8/N19OhRNWnSRJ07d1bdunXtjklWVpays7M99phERkYqIiLCrs15eXnatWuXrc0xMTHKyclRenq6rczmzZtVUlJie6PsiX744Qf9+OOPatKkiSTPOA6GYSg+Pl4ffvihNm/efMntsqryNxATE6P9+/fbhVtKSoqCg4Mv+aAYPI+nZIfZc787vO4ddT6PiYnR559/rvPnz9vKpKSkqFWrVrXmNnpXcn52Rbtq6pwbExNjt43SMs76m7xcu8qTkZEhSXb/Z7WtXXAed8uO2vj+2FPew5WUlKioqKhW1vfuu+/W/v37lZGRYXvcdttteuSRR2w/17Y6/15tf3/To0cPZWVl2S37+uuv1aJFC0m1828PruVu+VFV7v5a95RMqqranF1meELOmVHbMxHO46nZUcqbXtveNM5VGXcZA6uIp46NwbN4enZUFeddzllXwtH9JXc9NjXV33LX4+OJPCU7POWzUu4+1nY5tflzS540TlhT17/hvTwlO1zJm8bFagr9wJrj7mN8phlwaytXrjQCAgKMpUuXGgcPHjRGjx5tNGrUyLBara6umtP87W9/M7Zu3WocO3bM+M9//mP06dPHCA0NNU6dOmUYhmGMGTPGaN68ubF582Zjz549RkxMjBETE+PiWlfP2bNnjX379hn79u0zJBkzZ8409u3bZ/z3v/81DMMwXn75ZaNRo0bGunXrjK+++soYMGCAERkZaRQUFNi20a9fP+PWW281du3aZWzfvt1o2bKlMWTIEFc16YpUdhzOnj1r/P3vfzfS0tKMY8eOGZ999pnRqVMno2XLlkZhYaFtG+5+HMaOHWuEhIQYW7duNU6cOGF7/PLLL7Yyl/sb+PXXX422bdsaffv2NTIyMozk5GTjmmuuMSZNmuSKJsEF3DE7qnvury2v+5o4n+fk5Bjh4eHGsGHDjMzMTGPlypVGvXr1jH/9618uaZejzs+uaFdNnXO//fZbo169esaECROMQ4cOGfPmzTP8/PyM5ORkl7TryJEjxrRp04w9e/YYx44dM9atW2fccMMNRs+ePWt1u+BctS073O39sTu+h3vmmWeMbdu2GceOHTO++uor45lnnjF8fHyMTz/9tFbWtzx33nmnMW7cONvvta3O7vb+Zvfu3UadOnWMl156yfjmm2+Md99916hXr56xfPlyW5na9rcH16tt+VFV7pYzZrhjJlWVJ2SXGbU958xwt0yEc7lrdpTH01/bnjrOVRlPHQOriKeOjcHzeFJ2VMYbz7tmcM6qXE30l9z12JTHGf0tTzo+nsAds8OdPyvlSWNtnvS5JU8aJ6yp69/wbu6YHa7k6eNiNYV+oHN42xifWUws8QBvvvmm0bx5c8Pf39/o2rWrsXPnTldXyakeeugho0mTJoa/v79x7bXXGg899JBx5MgR2/qCggLjL3/5i3HVVVcZ9erVM/70pz8ZJ06ccGGNq2/Lli2GpEseI0aMMAzDMEpKSoznnnvOCA8PNwICAoy7777byMrKstvGjz/+aAwZMsRo0KCBERwcbIwcOdI4e/asC1pz5So7Dr/88ovRt29f45prrjHq1q1rtGjRwnjiiScuefPm7sehvPZLMpYsWWIrU5W/ge+++8645557jKCgICM0NNT429/+Zpw/f76GWwNXcrfscMS5vza87mvqfP7ll18at99+uxEQEGBce+21xssvv+yydjny/FzT7arJc+6WLVuMjh07Gv7+/sYNN9xgt4+abld2drbRs2dPo3HjxkZAQIBx0003GRMmTDByc3NrdbvgfLUpO9zt/bE7vod77LHHjBYtWhj+/v7GNddcY9x99922C821sb7l+f0F4NpWZ3d8f/Pxxx8bbdu2NQICAoyoqChjwYIFdutr298eaofalB9V5W45Y4Y7ZlJVeUJ2mVHbc84Md8xEOJc7Zkd5PP217anjXJXx1DGwinjq2Bg8k6dkR2W88bxrBuesytVUf8kdj015nNXf8pTj4yncLTvc+bNSnjTW5kmfW/KkccKavP4N7+Zu2eFKnj4uVlPoBzqHt43xmeVjGIYhAAAAAAAAAAAAAAAAAAAAAAAAeB1fV1cAAAAAAAAAAAAAAAAAAAAAAAAArsHEEgAAAAAAAAAAAAAAAAAAAAAAAC/FxBIAAAAAAAAAAAAAAAAAAAAAAAAvxcQSAAAAAAAAAAAAAAAAAAAAAAAAL8XEEgAAAAAAAAAAAAAAAAAAAAAAAC/FxBIAAAAAAAAAAAAAAAAAAAAAAAAvxcQSAAAAAAAAAAAAAAAAAAAAAAAAL8XEEgAAAAAAUOssXbpUjRo1cnU1AAAAAAAAAAAAAAAAPB4TSwA3ZLVa9eSTT+qGG25QQECAmjVrpvvvv1+pqamSpOuvv14+Pj7y8fFRUFCQrr/+ej344IPavHlzudtbunSp2rdvr8DAQIWFhSkuLq7cckeOHFHDhg35cBcAuAFHZsVf//pXde7cWQEBAerYsWOl+60oKw4cOKBBgwbZ9jt79mwHtRQA4CyuyhIAgPtwVFb8+OOP6tevn5o2bWrbTnx8vPLy8mxlTpw4oT//+c+6+eab5evrq/Hjx1dat5UrV8rHx0exsbGObjYAwIFqMku2bt1q21bZh9VqrdE2AwCqx5FjVuXlwsqVK23rH3300XLL3HLLLTXWXgCAeY7Kii+//FJDhgxRs2bNFBQUpNatW2vOnDl2ZaqSFYmJierSpYsaNmyosLAwxcbGKisry/kHAgBQZbUtOy5cuKDnnntOkZGRCgoK0o033qjp06fLMAznHwx4NSaWAG7mu+++U+fOnbV582a99tpr2r9/v5KTk9W7d2+7CSHTpk3TiRMnlJWVpXfeeUeNGjVSnz599NJLL9ltb+bMmfrHP/6hZ555RgcOHNBnn30mi8VyyX7Pnz+vIUOG6I477nB6GwEA1ePorJCkxx57TA899FCl+60sK3755RfdcMMNevnllxUREVH9RgIAnMpVWQIAcB+OzApfX18NGDBAH330kb7++mstXbpUn332mcaMGWMrU1RUpGuuuUaTJ09Whw4dLlu3v//974xjAUAtV9NZUiorK0snTpywPcLCwmqkvQCA6nPGmNWSJUvscqHs5PQ5c+bYrfv+++/VuHFjDR48uCaaCwC4Ao7MivT0dIWFhWn58uU6cOCA/vGPf2jSpEmaO3eurUxVsmLbtm2Ki4vTzp07lZKSovPnz6tv3746d+5czRwUAEClamN2vPLKK5o/f77mzp2rQ4cO6ZVXXtGrr76qN998s2YOCrxWHVdXAIA5f/nLX+Tj46Pdu3erfv36tuW33HKLHnvsMdvvDRs2tH1wt3nz5urZs6eaNGmiKVOm6IEHHlCrVq30888/a/Lkyfr444919913257bvn37S/Y7efJkRUVF6e6779aOHTuc2EIAQHU5Misk6Y033pAknT59Wl999VWF+60sK7p06aIuXbpIkp555hnHNBQA4DSuyJKlS5dqypQpOnPmjCwWi26//XZnNQ8A4ACOzIqrrrpKY8eOtT2nRYsW+stf/qLXXnvNtuz666+3favX4sWLK6zXhQsX9Mgjj+iFF17Qv//9b+Xk5DiqyQAAB6vpLCkVFhbGndkBwE05esxKkho1alThF2KFhIQoJCTE9vvatWv1888/a+TIkY5uGgDAQRyZFWXLS9INN9ygtLQ0rVmzRvHx8ZKqlhXJycl221m6dKnCwsKUnp6unj17Oq7xAIArUhuzY8eOHRowYID69+8v6eI1kvfee0+7d+92/AEAyuCOJYAb+emnn5ScnKy4uDi7ACt1uQsh48aNk2EYWrdunSQpJSVFJSUl+t///qfWrVvruuuu04MPPqjvv//e7nmbN2/W6tWrNW/ePIe1BQDgHI7OiqoiKwDAc7giS3bt2qVRo0YpPj5eGRkZ6t27t1588UWzVQcA1BBnZ8Xx48e1Zs0a3XnnnabrNm3aNIWFhWnUqFGmnwsAqDmuzJKOHTuqSZMm+sMf/qD//Oc/V1R/AEDNc1Z2xMXFKTQ0VF27dtXixYtlGEaF21i0aJH69OmjFi1aXFEbAADOVRPXN3Jzc9W4ceMK11clK3JzcyWp0u0AAGpGbc2O7t27KzU1VV9//bUk6csvv9T27dt1zz33XKZFQPVwxxLAjRw5ckSGYSgqKuqKnt+4cWOFhYXpu+++kyR9++23Kikp0T//+U/NmTNHISEhmjx5sv7whz/oq6++kr+/v3788Uc9+uijWr58uYKDgx3YGgCAMzg6K6qCrAAAz+KKLJkzZ4769euniRMnSpJuvvlm7dix45Jv8QIA1A7OyoohQ4Zo3bp1Kigo0P3336+3337b1Ha3b9+uRYsWKSMj44rqBQCoOa7IkiZNmigpKUm33XabioqK9Pbbb6tXr17atWuXOnXqVJ3mAABqgDOyY9q0abrrrrtUr149ffrpp/rLX/6i/Px8/fWvf73k+cePH9cnn3yiFStWXGkTAABO5uzrGzt27NCqVau0YcOGctdXJStKSko0fvx49ejRQ23btr2iegIAHKe2ZsczzzyjvLw8RUVFyc/PTxcuXNBLL72kRx555IrqCVQVdywB3Ehl345iZhs+Pj6SLnZWzp8/rzfeeEMWi0XdunXTe++9p2+++UZbtmyRJD3xxBP685//zK0XAcBNODorqoKsAADP4oosOXTokKKjo+2WxcTEVLseAADncFZWzJo1S3v37tW6det09OhRJSQkVHl7Z8+e1bBhw7Rw4UKFhoZWu34AAOdyRZa0atVK/9//9/+pc+fO6t69uxYvXqzu3btr1qxZ1a4LAMD5nJEdzz33nHr06KFbb71VTz/9tCZOnKjXXnut3OcuW7ZMjRo1UmxsbLXrAQBwDmde38jMzNSAAQM0depU9e3bt9znViUr4uLilJmZqZUrV1a7rgCA6qut2fH+++/r3Xff1YoVK7R3714tW7ZMr7/+upYtW1bt+gKV4Y4lgBtp2bKlfHx8dPjw4St6/o8//qjTp08rMjJS0sVv55KkNm3a2Mpcc801Cg0NVXZ2tiRp8+bN+uijj/T6669LuhiCJSUlqlOnjhYsWKDHHnusOk0CADiYo7OiKsgKAPAsrsgSAIB7cVZWREREKCIiQlFRUWrcuLHuuOMOPffcc7YxrMocPXpU3333ne6//37bspKSEklSnTp1lJWVpRtvvPGK6gsAcLzakiVdu3bV9u3br6gOAICaVRNjVtHR0Zo+fbqKiooUEBBgW24YhhYvXqxhw4bJ39//ivYPAHA+Z2XFwYMHdffdd2v06NGaPHlyuc+tSlbEx8dr/fr1+vzzz3XdddddUR0BAI5VW7NjwoQJeuaZZ/Twww9Lktq1a6f//ve/SkxM1IgRI66orkBVcMcSwI00btxYFotF8+bN07lz5y5Zn5OTU+nz58yZI19fX9vsxh49ekiSsrKybGV++uknnTlzRi1atJAkpaWlKSMjw/aYNm2aGjZsqIyMDP3pT39yTMMAAA7j6KyoCrICADyLK7KkdevW2rVrl92ynTt3Vvn5AICaVRNZUToppKioqEp1ioqK0v79++36Jn/84x/Vu3dvZWRkqFmzZlXaDgCgZtSWLMnIyKjSBEYAgOvVRHZkZGToqquusptUIknbtm3TkSNHNGrUqCupOgCghjgjKw4cOKDevXtrxIgReumllyp8bmVZYRiG4uPj9eGHH2rz5s18MRcA1CK1NTt++eUX+fraf8Tfz8/PNt4FOAt3LAHczLx589SjRw917dpV06ZNU/v27fXrr78qJSVF8+fP16FDhyRJZ8+eldVq1fnz53Xs2DEtX75cb7/9thITE3XTTTdJkm6++WYNGDBA48aN04IFCxQcHKxJkyYpKipKvXv3lnTxA15l7dmzR76+vmrbtm3NNhwAUGWOzApJOnLkiPLz82W1WlVQUKCMjAxJF+945e/vX6WsKC4u1sGDB20//+9//1NGRoYaNGhgty8AQO1Q01ny17/+VT169NDrr7+uAQMGaNOmTUpOTnZF0wEAVeTIrNi4caNOnjypLl26qEGDBjpw4IAmTJigHj166Prrr7ftszQ/8vPzdfr0aWVkZMjf319t2rRRYGDgJeNVjRo1kiTGsQCglqrpLJk9e7YiIyN1yy23qLCwUG+//bY2b96sTz/91FWHAABgkiOz4+OPP9bJkyfVrVs3BQYGKiUlRf/85z/197///ZL9Llq0SNHR0fQtAMANODIrMjMzddddd8lisSghIUFWq1XSxQ/2XnPNNXb7rSwr4uLitGLFCq1bt04NGza0bSckJERBQUHOPBwAgCqojdlx//3366WXXlLz5s11yy23aN++fZo5c6Yee+wxJx8NeD0DgNs5fvy4ERcXZ7Ro0cLw9/c3rr32WuOPf/yjsWXLFsMwDKNFixaGJEOS4e/vbzRv3tx48MEHjc2bN1+yrdzcXOOxxx4zGjVqZDRu3Nj405/+ZGRnZ1e47yVLlhghISFOahkAwFEcmRV33nmnrWzZx7Fjx8rdd3lZcezYsXK3ceeddzq24QAAh6npLFm0aJFx3XXXGUFBQcb9999vvP766/Q9AKCWc1RWbN682YiJiTFCQkKMwMBAo2XLlsbTTz9t/Pzzz3blysuSFi1aVFi/ESNGGAMGDHBsowEADlWTWfLKK68YN954oxEYGGg0btzY6NWrV7n9FwBA7eao7Pjkk0+Mjh07Gg0aNDDq169vdOjQwUhKSjIuXLhgVy4nJ8cICgoyFixYUFNNBABUk6OyYurUqVUaj7pcVpS3DUnGkiVLnNB6AMCVqG3ZkZeXZ4wbN85o3ry5ERgYaNxwww3GP/7xD6OoqMgZzQdsfAzDMBw7VQUAAAAAAAAAAAAAAAAAAAAAAADuwNfVFQAAAAAAAAAAAAAAAAAAAAAAAIBrMLEEAAAAAAAAAAAAAAAAAAAAAADASzGxBAAAAAAAAAAAAAAAAAAAAAAAwEsxsQQAAAAAAAAAAAAAAAAAAAAAAMBLMbEEAAAAAAAAAAAAAAAAAAAAAADASzGxBAAAAAAAAAAAAAAAAAAAAAAAwEsxsQQAAAAAAAAAAAAAAAAAAAAAAMBLMbEEAAAAAAAAAAAAAAAAAAAAAADASzGxBAAAAAAAAAAAAAAAAAAAAAAAwEsxsQQAAAAAAAAAAAAAAAAAAAAAAMBLMbEEAAAAAAAAAAAAAAAAAAAAAADASzGxBAAAAAAAAAAAAAAAAAAAAAAAwEv9/wBUv5wCkoyDyAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "make_histograms(\n", + " adt_expressions,\n", + " adt_expressions.columns,\n", + " \"ADT expressions\",\n", + " subplots_shape=(8, 8),\n", + " display_desc=True,\n", + " title_shift=1.05,\n", + " bins=100,\n", + " y_label=\"PMF estimation\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import nbinom\n", + "\n", + "# Define the parameters of the negative binomial distribution\n", + "r = 5 # Number of failures\n", + "p = 0.9 # Probability of success\n", + "\n", + "# Generate x values\n", + "x = np.arange(nbinom.ppf(0.01, r, p), nbinom.ppf(0.99, r, p))\n", + "\n", + "# Calculate the pmf\n", + "pmf = nbinom.pmf(x, r, p)\n", + "\n", + "# Plot the pmf\n", + "plt.plot(x, pmf, \"bo\", ms=8)\n", + "plt.vlines(x, 0, pmf, colors=\"b\", lw=5)\n", + "plt.xlabel(\"Number of successes\")\n", + "plt.ylabel(\"Probability\")\n", + "plt.title(\"Negative Binomial Distribution (r={}, p={})\".format(r, p))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(75195, 13953)" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "expressions[:, gex_indicator].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.0105, 0.0385, 0.0617, ..., 0.0371, 0.0070, 0.0045])" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torch\n", + "\n", + "torch.tensor(expressions[:, gex_indicator]).mean(dim=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Pearson residuals preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\experimental\\pp\\_normalization.py:132: UserWarning: Received a view of an AnnData. Making a copy.\n", + " view_to_actual(adata)\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\experimental\\pp\\_normalization.py:52: UserWarning: `normalize_pearson_residuals()` expects raw count data, but non-integers were found.\n", + " warn(\n" + ] + } + ], + "source": [ + "import scanpy as sc\n", + "\n", + "sc.experimental.pp.normalize_pearson_residuals(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "module 'anndata' has no attribute 'write_h5ad'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[9], line 3\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01manndata\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mad\u001b[39;00m\n\u001b[1;32m----> 3\u001b[0m \u001b[43mad\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwrite_h5ad\u001b[49m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdata.h5ad\u001b[39m\u001b[38;5;124m'\u001b[39m, data)\n", + "\u001b[1;31mAttributeError\u001b[0m: module 'anndata' has no attribute 'write_h5ad'" + ] + } + ], + "source": [ + "import anndata as ad\n", + "\n", + "ad.write(\"data.h5ad\", data)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(75195, 14087)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.layers" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/old_code/old_notebooks/pp-try-out.ipynb b/old_code/old_notebooks/pp-try-out.ipynb new file mode 100644 index 0000000..bd84733 --- /dev/null +++ b/old_code/old_notebooks/pp-try-out.ipynb @@ -0,0 +1,594 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n" + ] + } + ], + "source": [ + "import os\n", + "\n", + "os.chdir(\"../src\")\n", + "\n", + "from utils import data_utils\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import anndata as ad\n", + "import scanpy as sc\n", + "\n", + "pd.set_option(\"display.max_columns\", None)\n", + "\n", + "import torch\n", + "\n", + "torch.manual_seed(100)\n", + "import torch.nn as nn\n", + "import torch.utils\n", + "import torch.distributions\n", + "import torchvision\n", + "from torchvision import datasets, transforms\n", + "import math\n", + "import numpy as np\n", + "\n", + "np.random.seed(100)\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.rcParams[\"figure.dpi\"] = 200\n", + "import scanpy as sc\n", + "from collections import OrderedDict\n", + "from collections import Counter\n", + "\n", + "# select the right device, depending on whether your Colab runs on GPU or CPU\n", + "### IMPORTANT: we recommend to change your runtime to GPU, otherwise the training takes much longer\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "print(device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "TODO\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading precomputed log1p...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + } + ], + "source": [ + "adata = data_utils.load_anndata(\n", + " mode=\"train\", plus_iid_holdout=False, preprocessing=\"log1p\"\n", + ")\n", + "# sc.pp.scale(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['GEX_n_genes_by_counts', 'GEX_pct_counts_mt', 'GEX_size_factors',\n", + " 'GEX_phase', 'ADT_n_antibodies_by_counts', 'ADT_total_counts',\n", + " 'ADT_iso_count', 'cell_type', 'batch', 'ADT_pseudotime_order',\n", + " 'GEX_pseudotime_order', 'Samplename', 'Site', 'DonorNumber', 'Modality',\n", + " 'VendorLot', 'DonorID', 'DonorAge', 'DonorBMI', 'DonorBloodType',\n", + " 'DonorRace', 'Ethnicity', 'DonorGender', 'QCMeds', 'DonorSmoker',\n", + " 'is_train'],\n", + " dtype='object')" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adata.obs.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "sc.pp.normalize_total(adata, target_sum=1e4)\n", + "sc.pp.log1p(adata)\n", + "sc.pp.pca(adata, n_comps=50)\n", + "sc.external.pp.bbknn(adata, batch_key=\"Site\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "sc.tl.umap(adata)\n", + "# sc.tl.leiden(adata)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(66175, 14087)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adata.X.toarray().shape" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(66175, 50)" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adata.obsm[\"X_pca\"].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting harmonypy\n", + " Downloading harmonypy-0.0.9-py3-none-any.whl.metadata (3.7 kB)\n", + "Requirement already satisfied: pandas in d:\\dlls-hack\\.venv\\lib\\site-packages (from harmonypy) (2.2.2)\n", + "Requirement already satisfied: numpy in d:\\dlls-hack\\.venv\\lib\\site-packages (from harmonypy) (1.26.4)\n", + "Requirement already satisfied: scipy in d:\\dlls-hack\\.venv\\lib\\site-packages (from harmonypy) (1.13.1)\n", + "Requirement already satisfied: scikit-learn in d:\\dlls-hack\\.venv\\lib\\site-packages (from harmonypy) (1.5.0)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in d:\\dlls-hack\\.venv\\lib\\site-packages (from pandas->harmonypy) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in d:\\dlls-hack\\.venv\\lib\\site-packages (from pandas->harmonypy) (2024.1)\n", + "Requirement already satisfied: tzdata>=2022.7 in d:\\dlls-hack\\.venv\\lib\\site-packages (from pandas->harmonypy) (2024.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in d:\\dlls-hack\\.venv\\lib\\site-packages (from scikit-learn->harmonypy) (1.4.2)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in d:\\dlls-hack\\.venv\\lib\\site-packages (from scikit-learn->harmonypy) (3.5.0)\n", + "Requirement already satisfied: six>=1.5 in d:\\dlls-hack\\.venv\\lib\\site-packages (from python-dateutil>=2.8.2->pandas->harmonypy) (1.16.0)\n", + "Downloading harmonypy-0.0.9-py3-none-any.whl (20 kB)\n", + "Installing collected packages: harmonypy\n", + "Successfully installed harmonypy-0.0.9\n" + ] + } + ], + "source": [ + "!pip install harmonypy" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "ename": "KeyError", + "evalue": "'X_pca'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[12], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43msc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexternal\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mharmony_integrate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkey\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mbatch\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\legacy_api_wrap\\__init__.py:80\u001b[0m, in \u001b[0;36mlegacy_api..wrapper..fn_compatible\u001b[1;34m(*args_all, **kw)\u001b[0m\n\u001b[0;32m 77\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(fn)\n\u001b[0;32m 78\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfn_compatible\u001b[39m(\u001b[38;5;241m*\u001b[39margs_all: P\u001b[38;5;241m.\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkw: P\u001b[38;5;241m.\u001b[39mkwargs) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m R:\n\u001b[0;32m 79\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(args_all) \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m n_positional:\n\u001b[1;32m---> 80\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs_all\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 82\u001b[0m args_pos: P\u001b[38;5;241m.\u001b[39margs\n\u001b[0;32m 83\u001b[0m args_pos, args_rest \u001b[38;5;241m=\u001b[39m args_all[:n_positional], args_all[n_positional:]\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\external\\pp\\_harmony_integrate.py:93\u001b[0m, in \u001b[0;36mharmony_integrate\u001b[1;34m(adata, key, basis, adjusted_basis, **kwargs)\u001b[0m\n\u001b[0;32m 90\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mImportError\u001b[39;00m:\n\u001b[0;32m 91\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mImportError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124mplease install harmonypy:\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\t\u001b[39;00m\u001b[38;5;124mpip install harmonypy\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m---> 93\u001b[0m X \u001b[38;5;241m=\u001b[39m \u001b[43madata\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mobsm\u001b[49m\u001b[43m[\u001b[49m\u001b[43mbasis\u001b[49m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39mastype(np\u001b[38;5;241m.\u001b[39mfloat64)\n\u001b[0;32m 95\u001b[0m harmony_out \u001b[38;5;241m=\u001b[39m harmonypy\u001b[38;5;241m.\u001b[39mrun_harmony(X, adata\u001b[38;5;241m.\u001b[39mobs, key, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m 97\u001b[0m adata\u001b[38;5;241m.\u001b[39mobsm[adjusted_basis] \u001b[38;5;241m=\u001b[39m harmony_out\u001b[38;5;241m.\u001b[39mZ_corr\u001b[38;5;241m.\u001b[39mT\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\aligned_mapping.py:150\u001b[0m, in \u001b[0;36mAlignedViewMixin.__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m 148\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__getitem__\u001b[39m(\u001b[38;5;28mself\u001b[39m, key: \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m V:\n\u001b[0;32m 149\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m as_view(\n\u001b[1;32m--> 150\u001b[0m _subset(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparent_mapping\u001b[49m\u001b[43m[\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m]\u001b[49m, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msubset_idx),\n\u001b[0;32m 151\u001b[0m ElementRef(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparent, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mattrname, (key,)),\n\u001b[0;32m 152\u001b[0m )\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\aligned_mapping.py:196\u001b[0m, in \u001b[0;36mAlignedActualMixin.__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m 195\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__getitem__\u001b[39m(\u001b[38;5;28mself\u001b[39m, key: \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m V:\n\u001b[1;32m--> 196\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_data\u001b[49m\u001b[43m[\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m]\u001b[49m\n", + "\u001b[1;31mKeyError\u001b[0m: 'X_pca'" + ] + } + ], + "source": [ + "sc.external.pp.harmony_integrate(data, key=\"batch\")" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "BATCH_SIZE = 128" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "train_dataloader = data_utils.get_dataloader_from_anndata(\n", + " data[:-1000, :],\n", + " first_modality_dim=10,\n", + " second_modality_dim=134,\n", + " batch_size=BATCH_SIZE,\n", + " shuffle=True,\n", + ")\n", + "val_dataloader = data_utils.get_dataloader_from_anndata(\n", + " data[-1000:, :],\n", + " first_modality_dim=10,\n", + " second_modality_dim=134,\n", + " batch_size=BATCH_SIZE,\n", + " shuffle=True,\n", + ")\n", + "del data" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "class Encoder(nn.Module):\n", + " def __init__(\n", + " self, latent_dims, input_dims, dropout, z_dropout\n", + " ): # dropout, z_dropout define the dropout rates of the encoder/latent space\n", + " super(Encoder, self).__init__()\n", + " self.encoder = nn.Sequential(\n", + " nn.Linear(input_dims, 800),\n", + " nn.ReLU(),\n", + " nn.Dropout(p=dropout),\n", + " nn.Linear(800, 800),\n", + " nn.ReLU(),\n", + " nn.Dropout(p=dropout),\n", + " ) # two layer, fully connected encoder with dropout\n", + "\n", + " self.mu = nn.Sequential(nn.Linear(800, latent_dims), nn.Dropout(p=z_dropout))\n", + "\n", + " self.sigma = nn.Sequential(nn.Linear(800, latent_dims), nn.Dropout(p=z_dropout))\n", + "\n", + " self.N = torch.distributions.Normal(0, 1)\n", + " self.N.loc = self.N.loc.to(device)\n", + " self.N.scale = self.N.scale.to(device)\n", + " self.kl = 0\n", + "\n", + " def forward(self, x):\n", + " x = self.encoder(x)\n", + " mu = self.mu(x)\n", + " sigma = torch.exp(self.mu(x)) # exp for numeric stability\n", + " z = mu + sigma * self.N.sample(mu.shape)\n", + " self.kl = (\n", + " 0.5 * sigma**2 + 0.5 * mu**2 - torch.log(sigma) - 1 / 2\n", + " ).sum() # calculation of kullback-leibler divergence\n", + "\n", + " return z\n", + "\n", + "\n", + "class Decoder(nn.Module):\n", + " def __init__(self, latent_dims, input_dims, dropout):\n", + " super(Decoder, self).__init__()\n", + " self.decoder = nn.Sequential(\n", + " nn.Linear(latent_dims, 800),\n", + " nn.ReLU(),\n", + " nn.Dropout(p=dropout),\n", + " nn.Linear(800, input_dims),\n", + " )\n", + "\n", + " def forward(self, z):\n", + " z = self.decoder(z)\n", + " return z\n", + "\n", + "\n", + "class VariationalAutoencoder(nn.Module):\n", + " def __init__(self, latent_dims, input_dims, dropout=0.3, z_dropout=0.3):\n", + " super(VariationalAutoencoder, self).__init__()\n", + " self.encoder = Encoder(latent_dims, input_dims, dropout, z_dropout)\n", + " self.decoder = Decoder(latent_dims, input_dims, dropout)\n", + "\n", + " def forward(self, x):\n", + " z = self.encoder(x)\n", + " return self.decoder(z)\n", + "\n", + "\n", + "def train(vae, data, epochs=50, beta=0.001, learning_rate=0.0001):\n", + " opt = torch.optim.Adam(vae.parameters(), lr=learning_rate) # ADAM optimizer\n", + " losses = []\n", + " klds = []\n", + " mses = []\n", + " vae.train() # train mode (then, dropout layers are considered)\n", + "\n", + " for epoch in range(epochs):\n", + " loss_e = 0\n", + " kld_e = 0\n", + " mse_e = 0\n", + "\n", + " for _, x in data: # we only care about the second modality\n", + " x = x.to(device)\n", + " opt.zero_grad()\n", + " x_hat = vae(x)\n", + " mse = ((x - x_hat) ** 2).sum()\n", + " kld = beta * vae.encoder.kl\n", + " loss = mse + kld # loss calculation\n", + " loss.backward()\n", + " opt.step()\n", + " loss_e += loss.to(\"cpu\").detach().numpy()\n", + " kld_e += kld.to(\"cpu\").detach().numpy()\n", + " mse_e += mse.to(\"cpu\").detach().numpy()\n", + "\n", + " losses.append(loss_e / (len(data) * BATCH_SIZE))\n", + " klds.append(kld_e / (len(data) * BATCH_SIZE))\n", + " mses.append(mse_e / (len(data) * BATCH_SIZE))\n", + "\n", + " print(\"epoch: \", epoch, \" loss: \", loss_e / (len(data) * BATCH_SIZE))\n", + "\n", + " return vae, losses, klds, mses" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "latent_dims = 5 # choose the number of latent variables" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([128, 134])" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "next(iter(train_dataloader))[1].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 1., 2., 3., ..., 34., 5., 13.],\n", + " [ 1., 1., 7., ..., 1., 5., 4.],\n", + " [ 2., 9., 32., ..., 31., 17., 7.],\n", + " ...,\n", + " [ 1., 2., 9., ..., 151., 5., 7.],\n", + " [ 0., 1., 19., ..., 143., 3., 27.],\n", + " [ 4., 0., 2., ..., 13., 7., 9.]])" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "next(iter(train_dataloader))[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch: 0 loss: nan\n", + "epoch: 1 loss: nan\n", + "epoch: 2 loss: nan\n", + "epoch: 3 loss: nan\n", + "epoch: 4 loss: nan\n", + "epoch: 5 loss: nan\n", + "epoch: 6 loss: nan\n", + "epoch: 7 loss: nan\n", + "epoch: 8 loss: nan\n", + "epoch: 9 loss: nan\n", + "epoch: 10 loss: nan\n", + "epoch: 11 loss: nan\n", + "epoch: 12 loss: nan\n", + "epoch: 13 loss: nan\n", + "epoch: 14 loss: nan\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[44], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m vae \u001b[38;5;241m=\u001b[39m VariationalAutoencoder(latent_dims \u001b[38;5;241m=\u001b[39m latent_dims, input_dims \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m134\u001b[39m)\u001b[38;5;241m.\u001b[39mto(device)\n\u001b[1;32m----> 2\u001b[0m vae, losses, klds, mses \u001b[38;5;241m=\u001b[39m \u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvae\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_dataloader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbeta\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.001\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# takes about 1 min on GPU\u001b[39;00m\n", + "Cell \u001b[1;32mIn[41], line 75\u001b[0m, in \u001b[0;36mtrain\u001b[1;34m(vae, data, epochs, beta, learning_rate)\u001b[0m\n\u001b[0;32m 73\u001b[0m loss \u001b[38;5;241m=\u001b[39m mse \u001b[38;5;241m+\u001b[39m kld \u001b[38;5;66;03m# loss calculation\u001b[39;00m\n\u001b[0;32m 74\u001b[0m loss\u001b[38;5;241m.\u001b[39mbackward()\n\u001b[1;32m---> 75\u001b[0m \u001b[43mopt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 76\u001b[0m loss_e \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m loss\u001b[38;5;241m.\u001b[39mto(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcpu\u001b[39m\u001b[38;5;124m'\u001b[39m)\u001b[38;5;241m.\u001b[39mdetach()\u001b[38;5;241m.\u001b[39mnumpy()\n\u001b[0;32m 77\u001b[0m kld_e \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m kld\u001b[38;5;241m.\u001b[39mto(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcpu\u001b[39m\u001b[38;5;124m'\u001b[39m)\u001b[38;5;241m.\u001b[39mdetach()\u001b[38;5;241m.\u001b[39mnumpy()\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\torch\\optim\\optimizer.py:391\u001b[0m, in \u001b[0;36mOptimizer.profile_hook_step..wrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 386\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 387\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\n\u001b[0;32m 388\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfunc\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m must return None or a tuple of (new_args, new_kwargs), but got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mresult\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 389\u001b[0m )\n\u001b[1;32m--> 391\u001b[0m out \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 392\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_optimizer_step_code()\n\u001b[0;32m 394\u001b[0m \u001b[38;5;66;03m# call optimizer step post hooks\u001b[39;00m\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\torch\\optim\\optimizer.py:76\u001b[0m, in \u001b[0;36m_use_grad_for_differentiable.._use_grad\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 74\u001b[0m torch\u001b[38;5;241m.\u001b[39mset_grad_enabled(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdefaults[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdifferentiable\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[0;32m 75\u001b[0m torch\u001b[38;5;241m.\u001b[39m_dynamo\u001b[38;5;241m.\u001b[39mgraph_break()\n\u001b[1;32m---> 76\u001b[0m ret \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 77\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[0;32m 78\u001b[0m torch\u001b[38;5;241m.\u001b[39m_dynamo\u001b[38;5;241m.\u001b[39mgraph_break()\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\torch\\optim\\adam.py:168\u001b[0m, in \u001b[0;36mAdam.step\u001b[1;34m(self, closure)\u001b[0m\n\u001b[0;32m 157\u001b[0m beta1, beta2 \u001b[38;5;241m=\u001b[39m group[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mbetas\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[0;32m 159\u001b[0m has_complex \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_init_group(\n\u001b[0;32m 160\u001b[0m group,\n\u001b[0;32m 161\u001b[0m params_with_grad,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 165\u001b[0m max_exp_avg_sqs,\n\u001b[0;32m 166\u001b[0m state_steps)\n\u001b[1;32m--> 168\u001b[0m \u001b[43madam\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 169\u001b[0m \u001b[43m \u001b[49m\u001b[43mparams_with_grad\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 170\u001b[0m \u001b[43m \u001b[49m\u001b[43mgrads\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 171\u001b[0m \u001b[43m \u001b[49m\u001b[43mexp_avgs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 172\u001b[0m \u001b[43m \u001b[49m\u001b[43mexp_avg_sqs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 173\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_exp_avg_sqs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 174\u001b[0m \u001b[43m \u001b[49m\u001b[43mstate_steps\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 175\u001b[0m \u001b[43m \u001b[49m\u001b[43mamsgrad\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mamsgrad\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 176\u001b[0m \u001b[43m \u001b[49m\u001b[43mhas_complex\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhas_complex\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 177\u001b[0m \u001b[43m \u001b[49m\u001b[43mbeta1\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbeta1\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 178\u001b[0m \u001b[43m \u001b[49m\u001b[43mbeta2\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbeta2\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 179\u001b[0m \u001b[43m \u001b[49m\u001b[43mlr\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mlr\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 180\u001b[0m \u001b[43m \u001b[49m\u001b[43mweight_decay\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mweight_decay\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 181\u001b[0m \u001b[43m \u001b[49m\u001b[43meps\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43meps\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 182\u001b[0m \u001b[43m \u001b[49m\u001b[43mmaximize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mmaximize\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 183\u001b[0m \u001b[43m \u001b[49m\u001b[43mforeach\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mforeach\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 184\u001b[0m \u001b[43m \u001b[49m\u001b[43mcapturable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mcapturable\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 185\u001b[0m \u001b[43m \u001b[49m\u001b[43mdifferentiable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mdifferentiable\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 186\u001b[0m \u001b[43m \u001b[49m\u001b[43mfused\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mfused\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 187\u001b[0m \u001b[43m \u001b[49m\u001b[43mgrad_scale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mgetattr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mgrad_scale\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 188\u001b[0m \u001b[43m \u001b[49m\u001b[43mfound_inf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mgetattr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfound_inf\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 189\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 191\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m loss\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\torch\\optim\\adam.py:318\u001b[0m, in \u001b[0;36madam\u001b[1;34m(params, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, foreach, capturable, differentiable, fused, grad_scale, found_inf, has_complex, amsgrad, beta1, beta2, lr, weight_decay, eps, maximize)\u001b[0m\n\u001b[0;32m 315\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 316\u001b[0m func \u001b[38;5;241m=\u001b[39m _single_tensor_adam\n\u001b[1;32m--> 318\u001b[0m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 319\u001b[0m \u001b[43m \u001b[49m\u001b[43mgrads\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 320\u001b[0m \u001b[43m \u001b[49m\u001b[43mexp_avgs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 321\u001b[0m \u001b[43m \u001b[49m\u001b[43mexp_avg_sqs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 322\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_exp_avg_sqs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 323\u001b[0m \u001b[43m \u001b[49m\u001b[43mstate_steps\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 324\u001b[0m \u001b[43m \u001b[49m\u001b[43mamsgrad\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mamsgrad\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 325\u001b[0m \u001b[43m \u001b[49m\u001b[43mhas_complex\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhas_complex\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 326\u001b[0m \u001b[43m \u001b[49m\u001b[43mbeta1\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbeta1\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 327\u001b[0m \u001b[43m \u001b[49m\u001b[43mbeta2\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbeta2\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 328\u001b[0m \u001b[43m \u001b[49m\u001b[43mlr\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlr\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 329\u001b[0m \u001b[43m \u001b[49m\u001b[43mweight_decay\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mweight_decay\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 330\u001b[0m \u001b[43m \u001b[49m\u001b[43meps\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43meps\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 331\u001b[0m \u001b[43m \u001b[49m\u001b[43mmaximize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmaximize\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 332\u001b[0m \u001b[43m \u001b[49m\u001b[43mcapturable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcapturable\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 333\u001b[0m \u001b[43m \u001b[49m\u001b[43mdifferentiable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdifferentiable\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 334\u001b[0m \u001b[43m \u001b[49m\u001b[43mgrad_scale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgrad_scale\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 335\u001b[0m \u001b[43m \u001b[49m\u001b[43mfound_inf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfound_inf\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\torch\\optim\\adam.py:393\u001b[0m, in \u001b[0;36m_single_tensor_adam\u001b[1;34m(params, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, grad_scale, found_inf, amsgrad, has_complex, beta1, beta2, lr, weight_decay, eps, maximize, capturable, differentiable)\u001b[0m\n\u001b[0;32m 390\u001b[0m param \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mview_as_real(param)\n\u001b[0;32m 392\u001b[0m \u001b[38;5;66;03m# Decay the first and second moment running average coefficient\u001b[39;00m\n\u001b[1;32m--> 393\u001b[0m \u001b[43mexp_avg\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlerp_\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgrad\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mbeta1\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 394\u001b[0m exp_avg_sq\u001b[38;5;241m.\u001b[39mmul_(beta2)\u001b[38;5;241m.\u001b[39maddcmul_(grad, grad\u001b[38;5;241m.\u001b[39mconj(), value\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m-\u001b[39m beta2)\n\u001b[0;32m 396\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m capturable \u001b[38;5;129;01mor\u001b[39;00m differentiable:\n", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "vae = VariationalAutoencoder(latent_dims=latent_dims, input_dims=134).to(device)\n", + "vae, losses, klds, mses = train(\n", + " vae, train_dataloader, beta=0.001\n", + ") # takes about 1 min on GPU" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data.obs" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\preprocessing\\_scale.py:299: UserWarning: Received a view of an AnnData. Making a copy.\n", + " view_to_actual(adata)\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + }, + { + "ename": "MemoryError", + "evalue": "Unable to allocate 3.47 GiB for an array with shape (66175, 14087) and data type float32", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mMemoryError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[51], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m scaled_data \u001b[38;5;241m=\u001b[39m \u001b[43msc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mscale\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\_utils\\__init__.py:153\u001b[0m, in \u001b[0;36mrenamed_arg..decorator..wrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 151\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 152\u001b[0m kwargs[new_name] \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mpop(old_name)\n\u001b[1;32m--> 153\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\legacy_api_wrap\\__init__.py:80\u001b[0m, in \u001b[0;36mlegacy_api..wrapper..fn_compatible\u001b[1;34m(*args_all, **kw)\u001b[0m\n\u001b[0;32m 77\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(fn)\n\u001b[0;32m 78\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfn_compatible\u001b[39m(\u001b[38;5;241m*\u001b[39margs_all: P\u001b[38;5;241m.\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkw: P\u001b[38;5;241m.\u001b[39mkwargs) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m R:\n\u001b[0;32m 79\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(args_all) \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m n_positional:\n\u001b[1;32m---> 80\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs_all\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 82\u001b[0m args_pos: P\u001b[38;5;241m.\u001b[39margs\n\u001b[0;32m 83\u001b[0m args_pos, args_rest \u001b[38;5;241m=\u001b[39m args_all[:n_positional], args_all[n_positional:]\n", + "File \u001b[1;32m~\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\functools.py:909\u001b[0m, in \u001b[0;36msingledispatch..wrapper\u001b[1;34m(*args, **kw)\u001b[0m\n\u001b[0;32m 905\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m args:\n\u001b[0;32m 906\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfuncname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m requires at least \u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m 907\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m1 positional argument\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m--> 909\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mdispatch\u001b[49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;18;43m__class__\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkw\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\preprocessing\\_scale.py:301\u001b[0m, in \u001b[0;36mscale_anndata\u001b[1;34m(adata, zero_center, max_value, copy, layer, obsm, mask_obs)\u001b[0m\n\u001b[0;32m 299\u001b[0m view_to_actual(adata)\n\u001b[0;32m 300\u001b[0m X \u001b[38;5;241m=\u001b[39m _get_obs_rep(adata, layer\u001b[38;5;241m=\u001b[39mlayer, obsm\u001b[38;5;241m=\u001b[39mobsm)\n\u001b[1;32m--> 301\u001b[0m X, adata\u001b[38;5;241m.\u001b[39mvar[str_mean_std[\u001b[38;5;241m0\u001b[39m]], adata\u001b[38;5;241m.\u001b[39mvar[str_mean_std[\u001b[38;5;241m1\u001b[39m]] \u001b[38;5;241m=\u001b[39m \u001b[43mscale\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 302\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 303\u001b[0m \u001b[43m \u001b[49m\u001b[43mzero_center\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mzero_center\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 304\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_value\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_value\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 305\u001b[0m \u001b[43m \u001b[49m\u001b[43mcopy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# because a copy has already been made, if it were to be made\u001b[39;49;00m\n\u001b[0;32m 306\u001b[0m \u001b[43m \u001b[49m\u001b[43mreturn_mean_std\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[0;32m 307\u001b[0m \u001b[43m \u001b[49m\u001b[43mmask_obs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmask_obs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 308\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 309\u001b[0m _set_obs_rep(adata, X, layer\u001b[38;5;241m=\u001b[39mlayer, obsm\u001b[38;5;241m=\u001b[39mobsm)\n\u001b[0;32m 310\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m adata \u001b[38;5;28;01mif\u001b[39;00m copy \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\_utils\\__init__.py:153\u001b[0m, in \u001b[0;36mrenamed_arg..decorator..wrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 151\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 152\u001b[0m kwargs[new_name] \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mpop(old_name)\n\u001b[1;32m--> 153\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\legacy_api_wrap\\__init__.py:80\u001b[0m, in \u001b[0;36mlegacy_api..wrapper..fn_compatible\u001b[1;34m(*args_all, **kw)\u001b[0m\n\u001b[0;32m 77\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(fn)\n\u001b[0;32m 78\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfn_compatible\u001b[39m(\u001b[38;5;241m*\u001b[39margs_all: P\u001b[38;5;241m.\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkw: P\u001b[38;5;241m.\u001b[39mkwargs) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m R:\n\u001b[0;32m 79\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(args_all) \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m n_positional:\n\u001b[1;32m---> 80\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs_all\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 82\u001b[0m args_pos: P\u001b[38;5;241m.\u001b[39margs\n\u001b[0;32m 83\u001b[0m args_pos, args_rest \u001b[38;5;241m=\u001b[39m args_all[:n_positional], args_all[n_positional:]\n", + "File \u001b[1;32m~\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\functools.py:909\u001b[0m, in \u001b[0;36msingledispatch..wrapper\u001b[1;34m(*args, **kw)\u001b[0m\n\u001b[0;32m 905\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m args:\n\u001b[0;32m 906\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfuncname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m requires at least \u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m 907\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m1 positional argument\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m--> 909\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mdispatch\u001b[49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;18;43m__class__\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkw\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\preprocessing\\_scale.py:229\u001b[0m, in \u001b[0;36mscale_sparse\u001b[1;34m(X, zero_center, max_value, copy, return_mean_std, mask_obs)\u001b[0m\n\u001b[0;32m 224\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m zero_center:\n\u001b[0;32m 225\u001b[0m logg\u001b[38;5;241m.\u001b[39minfo(\n\u001b[0;32m 226\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m... as `zero_center=True`, sparse input is \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 227\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdensified and may lead to large memory consumption\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 228\u001b[0m )\n\u001b[1;32m--> 229\u001b[0m X \u001b[38;5;241m=\u001b[39m \u001b[43mX\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtoarray\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 230\u001b[0m copy \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m \u001b[38;5;66;03m# Since the data has been copied\u001b[39;00m\n\u001b[0;32m 231\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m scale_array(\n\u001b[0;32m 232\u001b[0m X,\n\u001b[0;32m 233\u001b[0m zero_center\u001b[38;5;241m=\u001b[39mzero_center,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 237\u001b[0m mask_obs\u001b[38;5;241m=\u001b[39mmask_obs,\n\u001b[0;32m 238\u001b[0m )\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\scipy\\sparse\\_compressed.py:1106\u001b[0m, in \u001b[0;36m_cs_matrix.toarray\u001b[1;34m(self, order, out)\u001b[0m\n\u001b[0;32m 1104\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m out \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m order \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 1105\u001b[0m order \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_swap(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcf\u001b[39m\u001b[38;5;124m'\u001b[39m)[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m-> 1106\u001b[0m out \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_process_toarray_args\u001b[49m\u001b[43m(\u001b[49m\u001b[43morder\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1107\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (out\u001b[38;5;241m.\u001b[39mflags\u001b[38;5;241m.\u001b[39mc_contiguous \u001b[38;5;129;01mor\u001b[39;00m out\u001b[38;5;241m.\u001b[39mflags\u001b[38;5;241m.\u001b[39mf_contiguous):\n\u001b[0;32m 1108\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mOutput array must be C or F contiguous\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\scipy\\sparse\\_base.py:1327\u001b[0m, in \u001b[0;36m_spbase._process_toarray_args\u001b[1;34m(self, order, out)\u001b[0m\n\u001b[0;32m 1325\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m out\n\u001b[0;32m 1326\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1327\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mzeros\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43morder\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43morder\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[1;31mMemoryError\u001b[0m: Unable to allocate 3.47 GiB for an array with shape (66175, 14087) and data type float32" + ] + } + ], + "source": [ + "scaled_data = sc.pp.scale(data)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "scaled_data.layers" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "ename": "ImportError", + "evalue": "Please install bbknn: `pip install bbknn`.", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\external\\pp\\_bbknn.py:132\u001b[0m, in \u001b[0;36mbbknn\u001b[1;34m(adata, batch_key, use_rep, approx, use_annoy, metric, copy, neighbors_within_batch, n_pcs, trim, annoy_n_trees, pynndescent_n_neighbors, pynndescent_random_state, use_faiss, set_op_mix_ratio, local_connectivity, **kwargs)\u001b[0m\n\u001b[0;32m 131\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 132\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mbbknn\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m bbknn\n\u001b[0;32m 133\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mImportError\u001b[39;00m:\n", + "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'bbknn'", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[1;31mImportError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[47], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43msc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexternal\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbbknn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_key\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mbatch\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\legacy_api_wrap\\__init__.py:80\u001b[0m, in \u001b[0;36mlegacy_api..wrapper..fn_compatible\u001b[1;34m(*args_all, **kw)\u001b[0m\n\u001b[0;32m 77\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(fn)\n\u001b[0;32m 78\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfn_compatible\u001b[39m(\u001b[38;5;241m*\u001b[39margs_all: P\u001b[38;5;241m.\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkw: P\u001b[38;5;241m.\u001b[39mkwargs) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m R:\n\u001b[0;32m 79\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(args_all) \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m n_positional:\n\u001b[1;32m---> 80\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs_all\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 82\u001b[0m args_pos: P\u001b[38;5;241m.\u001b[39margs\n\u001b[0;32m 83\u001b[0m args_pos, args_rest \u001b[38;5;241m=\u001b[39m args_all[:n_positional], args_all[n_positional:]\n", + "File \u001b[1;32md:\\dlls-hack\\.venv\\Lib\\site-packages\\scanpy\\external\\pp\\_bbknn.py:134\u001b[0m, in \u001b[0;36mbbknn\u001b[1;34m(adata, batch_key, use_rep, approx, use_annoy, metric, copy, neighbors_within_batch, n_pcs, trim, annoy_n_trees, pynndescent_n_neighbors, pynndescent_random_state, use_faiss, set_op_mix_ratio, local_connectivity, **kwargs)\u001b[0m\n\u001b[0;32m 132\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mbbknn\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m bbknn\n\u001b[0;32m 133\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mImportError\u001b[39;00m:\n\u001b[1;32m--> 134\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mImportError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPlease install bbknn: `pip install bbknn`.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 135\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m bbknn(\n\u001b[0;32m 136\u001b[0m adata\u001b[38;5;241m=\u001b[39madata,\n\u001b[0;32m 137\u001b[0m batch_key\u001b[38;5;241m=\u001b[39mbatch_key,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 152\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[0;32m 153\u001b[0m )\n", + "\u001b[1;31mImportError\u001b[0m: Please install bbknn: `pip install bbknn`." + ] + } + ], + "source": [ + "sc.external.pp.bbknn(data, batch_key=\"batch\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/old_code/old_notebooks/project_description.ipynb b/old_code/old_notebooks/project_description.ipynb new file mode 100644 index 0000000..eac2891 --- /dev/null +++ b/old_code/old_notebooks/project_description.ipynb @@ -0,0 +1,53 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Project: a coupled variational autoencoder for multimodal data\n", + "\n", + "### Introduction \n", + "\n", + "Single-cell genomics allows to profile not only a single data modality (gene expression, chromatin accessibility,...) but multiple modalities at once from the same cell (\"multimodal data\"). This allows to gain a better understanding of the cellular state by looking at different biological processes within the same cell, and to characterize better the cell state. This includes for example profiling of gene expression and chromatin accessibility (scRNA-seq and scATAC-seq) or gene expression and DNA methylation. Another type of multimodal data is [CITE-seq](https://cite-seq.com/), in which gene expression is simultaneously profiled with the expression of proteins expressed at the surface of the cell. This is for example used used to profile immune cells, which are often characterized by a combination of surface proteins.\n", + "\n", + "### Goal\n", + "\n", + "The goal of this project is to build a VAE based model to couple the two data modalities from CITE-seq data, i.e. gene expression and durface protein expression. The aim is to compare the embedding obtained from the joint processing of the two data modalities with the embedding obtained from each modality individually. This should be done in a two step process:\n", + "\n", + "1. build single VAEs for each modality, and perform the embedding in each modality individually (RNA-seq and protein expression)\n", + "2. couple the two VAE to obtain a joint embedding.\n", + "\n", + "Regarding this second point, multiple approaches can be used, listed here in order of increasing complexity: (1) the concatenation of hidden layers to learn a shared latent space between the modalities (as is done for example in [OmiVAE for bulk data](https://arxiv.org/abs/1908.06278)), (2) training cross-modality VAEs as is done in [BABEL](https://www.pnas.org/doi/full/10.1073/pnas.2023070118) or (3) learning a shared latent space using an adversarial approach (see [here](https://www.nature.com/articles/s41467-020-20249-2)).\n", + "\n", + "We expect you to compare the embeddings obtained either by the single-modality VAE and the multimodal VAE and discuss the differences. For example, are certain cell population better separated in the multimodal model compare to the single modalities? Also compare the behavior of the single models in terms of loss, ...\n", + "\n", + "### Data and model\n", + "\n", + "The data to be used is a CITE-seq dataset provided by 10x genomics. Check the tutorial of [scanpy of CITE-seq](https://scanpy-tutorials.readthedocs.io/en/multiomics/cite-seq/pbmc5k.html) to see how to obtain the dataset and convert it into the AnnData format.\n", + "Alternatively, you can also use the CITE-seq dataset provided [as part of the NeurIPS21 competition](https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE194122). This is the [link](https://www.ncbi.nlm.nih.gov/geo/download/?acc=GSE194122&format=file&file=GSE194122%5Fopenproblems%5Fneurips2021%5Fcite%5FBMMC%5Fprocessed%2Eh5ad%2Egz) to the CITE-seq data in anndata format.\n", + "\n", + "You can use snippets of code from the lab of week 7 (C. Herrmann) on VAE in genomics as a starting point for single-cell VAEs, and modify the architecture as needed.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/old_code/old_notebooks/road-to-equivalence.ipynb b/old_code/old_notebooks/road-to-equivalence.ipynb new file mode 100644 index 0000000..b8248db --- /dev/null +++ b/old_code/old_notebooks/road-to-equivalence.ipynb @@ -0,0 +1,415 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.chdir(\"../src\")\n", + "\n", + "from utils import data_utils\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import anndata as ad\n", + "import scanpy as sc\n", + "\n", + "\n", + "pd.set_option(\"display.max_columns\", None)\n", + "\n", + "import argparse" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + } + ], + "source": [ + "train_data = data_utils.load_anndata(\n", + " mode=\"train\", normalize=True, remove_batch_effect=False, preload_subsample_frac=None\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "View of AnnData object with n_obs × n_vars = 66175 × 14087\n", + " obs: 'GEX_n_genes_by_counts', 'GEX_pct_counts_mt', 'GEX_size_factors', 'GEX_phase', 'ADT_n_antibodies_by_counts', 'ADT_total_counts', 'ADT_iso_count', 'cell_type', 'batch', 'ADT_pseudotime_order', 'GEX_pseudotime_order', 'Samplename', 'Site', 'DonorNumber', 'Modality', 'VendorLot', 'DonorID', 'DonorAge', 'DonorBMI', 'DonorBloodType', 'DonorRace', 'Ethnicity', 'DonorGender', 'QCMeds', 'DonorSmoker', 'is_train'\n", + " var: 'feature_types', 'gene_id'\n", + " uns: 'dataset_id', 'genome', 'organism', 'log1p'\n", + " obsm: 'ADT_X_pca', 'ADT_X_umap', 'ADT_isotype_controls', 'GEX_X_pca', 'GEX_X_umap'\n", + " layers: 'counts'" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch.utils.data import DataLoader\n", + "\n", + "train_loader = DataLoader(\n", + " torch.tensor(train_data.X.toarray()).float(), batch_size=128, shuffle=True\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import pytorch_lightning as pl\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "class Encoder(nn.Module):\n", + " def __init__(\n", + " self, latent_dims, hidden_dims, input_dims, dropout, z_dropout\n", + " ): # dropout, z_dropout define the dropout rates of the encoder/latent space\n", + " super(Encoder, self).__init__()\n", + " self.encoder = nn.Sequential(\n", + " nn.Linear(input_dims, hidden_dims),\n", + " nn.BatchNorm1d(hidden_dims),\n", + " nn.ReLU(),\n", + " nn.Dropout(p=dropout),\n", + " nn.Linear(hidden_dims, hidden_dims),\n", + " nn.BatchNorm1d(hidden_dims),\n", + " nn.ReLU(),\n", + " nn.Dropout(p=dropout),\n", + " nn.Linear(hidden_dims, hidden_dims),\n", + " nn.ReLU(),\n", + " nn.Dropout(p=dropout),\n", + " ) # two layer, fully connected encoder with dropout\n", + "\n", + " self.mu = nn.Sequential(nn.Linear(hidden_dims, latent_dims))\n", + "\n", + " def forward(self, x):\n", + " x = self.encoder(x)\n", + " mu = self.mu(x)\n", + " z = mu\n", + " return z\n", + "\n", + "\n", + "class Decoder(nn.Module):\n", + " def __init__(self, latent_dims, hidden_dims, input_dims, dropout):\n", + " super(Decoder, self).__init__()\n", + " self.decoder = nn.Sequential(\n", + " nn.Linear(latent_dims, hidden_dims),\n", + " nn.BatchNorm1d(hidden_dims),\n", + " nn.ReLU(),\n", + " nn.Dropout(p=dropout),\n", + " nn.Linear(hidden_dims, hidden_dims),\n", + " nn.BatchNorm1d(hidden_dims),\n", + " nn.ReLU(),\n", + " nn.Dropout(p=dropout),\n", + " nn.Linear(hidden_dims, input_dims),\n", + " )\n", + "\n", + " def forward(self, z):\n", + " decoded = self.decoder(z)\n", + " return decoded\n", + "\n", + "\n", + "class AE(nn.Module):\n", + " def __init__(self, latent_dims, hidden_dims, input_dims, dropout, z_dropout):\n", + " super(AE, self).__init__()\n", + " self.encoder = Encoder(latent_dims, hidden_dims, input_dims, dropout, z_dropout)\n", + " self.decoder = Decoder(latent_dims, hidden_dims, input_dims, dropout)\n", + "\n", + " def forward(self, x):\n", + " z = self.encoder(x)\n", + " x_hat = self.decoder(z)\n", + " return x_hat, z\n", + "\n", + "\n", + "def train(model, dataloader, optimizer, epochs):\n", + " model.train()\n", + " for epoch in range(epochs):\n", + " sum_loss = 0.0\n", + " for i, data in enumerate(dataloader):\n", + " optimizer.zero_grad()\n", + " x = data.to(device)\n", + " x_hat, z = model(x)\n", + " loss = F.mse_loss(x_hat, x)\n", + " loss.backward()\n", + " optimizer.step()\n", + " sum_loss += loss.item()\n", + " print(f\"Epoch {epoch+1}, Loss: {sum_loss/len(dataloader)}\")\n", + "\n", + "\n", + "class AE_Lightning(pl.LightningModule):\n", + " def __init__(self, latent_dims, hidden_dims, input_dims, dropout, z_dropout):\n", + " super(AE_Lightning, self).__init__()\n", + " self.model = AE(latent_dims, hidden_dims, input_dims, dropout, z_dropout)\n", + " self.latent_dims = latent_dims\n", + " self.hidden_dims = hidden_dims\n", + " self.input_dims = input_dims\n", + " self.dropout = dropout\n", + " self.z_dropout = z_dropout\n", + "\n", + " def forward(self, x):\n", + " return self.model(x)\n", + "\n", + " def training_step(self, batch, batch_idx):\n", + " x = batch\n", + " x_hat, z = self.model(x)\n", + " loss = F.mse_loss(x_hat, x)\n", + " self.log(\"Train loss\", loss, on_epoch=True, prog_bar=True)\n", + " return loss\n", + "\n", + " def configure_optimizers(self):\n", + " optimizer = torch.optim.Adam(self.parameters(), lr=1e-3)\n", + " return optimizer" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: False, used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n" + ] + } + ], + "source": [ + "latent_dims = 10\n", + "hidden_dims = 128\n", + "input_dims = train_data.shape[1]\n", + "dropout = 0.2\n", + "z_dropout = 0.2\n", + "epochs = 2\n", + "\n", + "ae = AE(latent_dims, hidden_dims, input_dims, dropout, z_dropout).to(device)\n", + "optimizer = torch.optim.Adam(ae.parameters(), lr=1e-3)\n", + "\n", + "ae_lightning = AE_Lightning(latent_dims, hidden_dims, input_dims, dropout, z_dropout)\n", + "trainer = pl.Trainer(max_epochs=epochs)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1, Loss: 0.08302881627756115\n", + "Epoch 2, Loss: 0.0670985062417486\n" + ] + } + ], + "source": [ + "train(ae, train_loader, optimizer, epochs)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + " | Name | Type | Params\n", + "-------------------------------\n", + "0 | model | AE | 3.7 M \n", + "-------------------------------\n", + "3.7 M Trainable params\n", + "0 Non-trainable params\n", + "3.7 M Total params\n", + "14.695 Total estimated model params size (MB)\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=3` in the `DataLoader` to improve performance.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1: 100%|██████████| 517/517 [00:38<00:00, 13.55it/s, v_num=5, Train loss_step=0.0634, Train loss_epoch=0.0671]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=2` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1: 100%|██████████| 517/517 [00:38<00:00, 13.48it/s, v_num=5, Train loss_step=0.0634, Train loss_epoch=0.0671]\n" + ] + } + ], + "source": [ + "trainer.fit(model=ae_lightning, train_dataloaders=train_loader)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "train_data_tensor = torch.tensor(train_data.X.toarray()).float()\n", + "latent_embeddings = ae.encoder(train_data_tensor).detach().numpy()\n", + "latent_embeddings_lightning = (\n", + " ae_lightning.model.encoder(train_data_tensor).detach().numpy()\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\przem\\AppData\\Local\\Temp\\ipykernel_3652\\2997097216.py:1: ImplicitModificationWarning: Setting element `.obsm['latent_embeddings']` of view, initializing view as actual.\n", + " train_data.obsm[\"latent_embeddings\"] = latent_embeddings\n", + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + } + ], + "source": [ + "train_data.obsm[\"latent_embeddings\"] = latent_embeddings\n", + "train_data.obsm[\"latent_embeddings_lightning\"] = latent_embeddings_lightning" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\dlls-hack\\.venv\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pp.neighbors(train_data, n_neighbors=10, use_rep=\"latent_embeddings\")\n", + "sc.tl.umap(train_data)\n", + "sc.pl.umap(train_data, color=\"cell_type\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pp.neighbors(train_data, n_neighbors=10, use_rep=\"latent_embeddings_lightning\")\n", + "sc.tl.umap(train_data)\n", + "sc.pl.umap(train_data, color=\"cell_type\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/old_code/old_notebooks/transformer-dev.ipynb b/old_code/old_notebooks/transformer-dev.ipynb new file mode 100644 index 0000000..d89b436 --- /dev/null +++ b/old_code/old_notebooks/transformer-dev.ipynb @@ -0,0 +1,661 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.chdir(\"../src\")\n", + "\n", + "from utils import data_utils\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import anndata as ad\n", + "\n", + "pd.set_option(\"display.max_columns\", None)" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import pytorch_lightning as pl\n", + "from torch import Tensor\n", + "from typing import List, Tuple, Optional\n", + "from argparse import Namespace" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\bioml\\.venv\\Lib\\site-packages\\anndata\\_core\\anndata.py:1820: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n", + " utils.warn_names_duplicates(\"var\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Subsampling anndata with fraction 1.0...\n" + ] + } + ], + "source": [ + "# Note: only preprosessing, which keeps 0 as 0 is allowed as 0 means no expression\n", + "data = data_utils.load_anndata(mode=\"train\")\n", + "tensor_data = torch.tensor(data.X.A)\n", + "del data" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [], + "source": [ + "nonzero_median = tensor_data[tensor_data > 0].median(dim=0, keepdim=True).values\n", + "tensor_data = tensor_data / nonzero_median\n", + "del nonzero_median" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Description of the model\n", + "I do embedding via small neural network taking small gene emebddings and expression level and creates an embedding - the combination here is more complex than just adding the \"positional embedding = gene embeddings\" and the gene expression level embedding. The reconstruction allows then to treat the values as continous after attaching the regression head to the output token embeddings. \n", + "\n", + "Note, that at no time we have to predict tokens.\n", + "Other methods for doing embeddings:\n", + "1) binning and quantization of the expression values into discrete tokens: + we have convenient tokens for both genes and expressions separately, - we lose information\n", + "2) network for embedding scalar as vector and adding it to learned gene embeddings\n", + "Pooled token is added to the gene embeddings at the decoder input to allow the model to condition on the gene expression values. The model is trained to predict the gene expression values from the decoder output. So we are not attaching classification head to the decoder output but regression head.\n", + "\n", + "I choose to do a simmilar thing as was done to create coembeddings od genes and expressions in the encoder part with the hiddens state and the gene embedding. Note, that different choices in the prvious point would result in different possibilities here. Especially solution 1 allows for just taking gene embeddings without adding the token embedding fo the quantized expression values.\n", + "\n", + "The approach is considered to be more robust to sparsity of data and allow to create representations for different sets of genes.\n", + "\n", + "Masked modelling does not make too much sense as the info about having a gene or not is a matter of acces to data and should not impact the token embedding process. Adding additional genes makes sense in the decoder part and is important to ensure that nonexpressed genes are indeed nonexpressed and the ones not included in the input are reconstructed as well and that rarely expressed genes token embeddings are influenced by the training.\n", + "\n", + "The question concering the GeneChoice Module is weathe we should make the model robust to differing numbers of inputs - this seems reasonable, but I leave it for simplicity for now." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "TODO: Consider different stabilising methods like Layer Norm of the embeddings." + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x: tensor([[0, 1, 3, 9, 4, 6, 8, 5, 7, 2],\n", + " [8, 6, 2, 1, 3, 7, 4, 9, 5, 0]])\n", + "input_gene_idxs: tensor([[3, 6, 8, 5, 7],\n", + " [7, 0, 5, 1, 8]])\n", + "aux_gene_idxs: tensor([[9, 0, 4],\n", + " [9, 4, 3]])\n" + ] + } + ], + "source": [ + "# This class relies on the fixed order of the genes in the input tensor, but it may be extended to support a more general case\n", + "# in practice it would be great to be independent of the order and only pass labels of the genes we have acces to\n", + "# (but actually the model is not trained to handle lack of highly expressed genes, so random removal of such genes supported by perhaps another mechanism would be needed to gain robustness to sparse inputs)\n", + "# the same for the number of genes\n", + "class GeneChoiceModule():\n", + " def __init__(self, num_genes_total: int, default_num_input_genes: int, default_num_auxilary_decoded_genes: int, auxilary_gene_choice_mode: str) -> None:\n", + " self.num_genes_total = num_genes_total\n", + " self.default_num_input_genes = default_num_input_genes\n", + " self.default_num_auxilary_decoded_genes = default_num_auxilary_decoded_genes\n", + " self.auxilary_gene_choice_mode = auxilary_gene_choice_mode\n", + " \n", + " def choose(self, x: Tensor, num_input_genes: Optional[int] = None, num_auxilary_decoded_genes: Optional[int] = None) -> Tuple[List[int], List[int]]:\n", + " assert x.shape[1] == self.num_genes_total, f\"Expected {self.num_genes_total} genes, got {x.shape[1]}. Something is wrong with the input tensor.\"\n", + " num_input_genes = num_input_genes if num_input_genes is not None else self.default_num_input_genes\n", + " num_auxilary_decoded_genes = num_auxilary_decoded_genes if num_auxilary_decoded_genes is not None else self.default_num_auxilary_decoded_genes\n", + "\n", + " idxs = x.argsort(descending=True, dim=1) # order by expression level\n", + " input_gene_idxs = idxs[:, :num_input_genes] # choose the most expressed genes\n", + " rest_gene_idxs = idxs[:, num_input_genes:] # separate the rest of the genes\n", + " if self.auxilary_gene_choice_mode == \"sample_from_left\":\n", + " permutation_idxs = torch.argsort(torch.randn(x.shape[0], self.num_genes_total - num_input_genes), dim=1) # random permutation for each sample independentyly\n", + " aux_gene_idxs = torch.gather(rest_gene_idxs, dim=1, index=permutation_idxs)[:, :num_auxilary_decoded_genes]\n", + " # elif self.auxilary_gene_choice_mode == \"sample_from_nonexpressed\":\n", + " else:\n", + " raise ValueError(\"Invalid auxilary_gene_choice\")\n", + " return input_gene_idxs, aux_gene_idxs\n", + "\n", + "def test_gene_choice_module():\n", + " gene_choice_module = GeneChoiceModule(10, 5, 3, \"sample_from_left\")\n", + " x = torch.randn(2, 10).argsort(dim=1)\n", + " input_gene_idxs, aux_gene_idxs = gene_choice_module.choose(x)\n", + " print('x:', x)\n", + " print('input_gene_idxs:', input_gene_idxs)\n", + " print('aux_gene_idxs:', aux_gene_idxs)\n", + "\n", + "test_gene_choice_module()" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "genes: torch.Size([2, 10])\n", + "z: torch.Size([2, 2])\n", + "pool: torch.Size([1, 3])\n", + "embed_genes: torch.Size([2, 10, 5])\n", + "embed_genes_and_expression_levels: torch.Size([2, 10, 3])\n", + "embed_genes_and_latent_vars: torch.Size([2, 10, 3])\n" + ] + } + ], + "source": [ + "class EmbeddingModule():\n", + " def __init__(self, num_gene_embeddings: int, gene_embedding_dim: int, embedding_dim: int, latent_dim: int) -> None:\n", + " # gene encoder is used for creating embeddings in both encoder and decoder\n", + " self.gene_embed = nn.Embedding(num_gene_embeddings, gene_embedding_dim) # we take smaller gene embedding dim to reduce the number of parameters\n", + " self.pool_embed = nn.Parameter(torch.empty((1, embedding_dim))) # used for pooling of the embeddings in the encoder\n", + " nn.init.xavier_normal_(self.pool_embed)\n", + " # cross encoder used for combining gene embeddings with expression levels in the encoder\n", + " self.cross_embed_gene_express_lvl = nn.Sequential(\n", + " nn.Linear(in_features=1 + gene_embedding_dim, out_features=embedding_dim),\n", + " nn.SELU(),\n", + " nn.Linear(in_features=embedding_dim, out_features=embedding_dim),\n", + " )\n", + " # cross encoder used for combining gene embeddings with latent variables in the decoder\n", + " # actually it could be named latent decoder, but there are some naming conflicts\n", + " self.cross_embed_gene_latent = nn.Sequential(\n", + " nn.Linear(in_features=gene_embedding_dim + latent_dim, out_features=embedding_dim),\n", + " nn.SELU(),\n", + " nn.Linear(in_features=embedding_dim, out_features=embedding_dim),\n", + " )\n", + "\n", + " def embed_genes(self, genes_idxs: Tensor) -> Tensor:\n", + " return self.gene_embed(genes_idxs)\n", + "\n", + " def embed_genes_and_expression_levels(self, genes_idxs: Tensor, expressions: Tensor) -> Tensor:\n", + " return self.cross_embed_gene_express_lvl(torch.cat([self.embed_genes(genes_idxs), expressions.unsqueeze(-1)], dim=2))\n", + " \n", + " def embed_genes_and_latent_vars(self, genes_idxs: Tensor, z: Tensor) -> Tensor:\n", + " _, num_bow_genes = genes_idxs.shape\n", + " return self.cross_embed_gene_latent(torch.cat([self.embed_genes(genes_idxs), z.unsqueeze(dim=1).repeat(1, num_bow_genes, 1)], dim=2)) # the dim=1 in unsqueeze is important, because we want to add the latent variable to each gene separately\n", + "\n", + "def test_embedding_module():\n", + " embedding_module = EmbeddingModule(10, 5, 3, 2)\n", + " genes = torch.randint(0, 10, (2, 10))\n", + " expressions = torch.randn(2, 10)\n", + " z = torch.randn(2, 2)\n", + " print('genes:', genes.shape)\n", + " print('z:', z.shape)\n", + " print('pool:', embedding_module.pool_embed.shape)\n", + " print('embed_genes:', embedding_module.embed_genes(genes).shape)\n", + " print('embed_genes_and_expression_levels:', embedding_module.embed_genes_and_expression_levels(genes, expressions).shape)\n", + " print('embed_genes_and_latent_vars:', embedding_module.embed_genes_and_latent_vars(genes, z).shape)\n", + "\n", + "test_embedding_module()" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x: torch.Size([2, 10, 10])\n", + "encoder_block: torch.Size([2, 10, 10])\n" + ] + } + ], + "source": [ + "class CustomTransformerBlock(nn.Module):\n", + " def __init__(self, embedding_dim: int, num_heads: int, hidden_dim: int) -> None:\n", + " super().__init__()\n", + " self.multi_head_attention = nn.MultiheadAttention(embed_dim=embedding_dim, num_heads=num_heads)\n", + " self.qkv = nn.Linear(in_features=embedding_dim, out_features=embedding_dim * 3)\n", + " self.ffn = nn.Sequential(\n", + " nn.Linear(in_features=embedding_dim, out_features=hidden_dim),\n", + " nn.SELU(),\n", + " nn.Linear(in_features=hidden_dim, out_features=embedding_dim)\n", + " )\n", + " self.lnorm1 = nn.LayerNorm(embedding_dim)\n", + " self.lnorm2 = nn.LayerNorm(embedding_dim)\n", + " \n", + " def forward(self, x: Tensor) -> Tensor:\n", + " # expected input shape (batch_size, set_size, embedding_dim)\n", + " x = self.lnorm1(x) # pre-norm\n", + " q, k, v = self.qkv(x).chunk(3, dim=-1)\n", + " x = self.multi_head_attention(q, k, v)[0] + x\n", + " x = self.lnorm2(x) # pre-norm\n", + " x = self.ffn(x) + x\n", + " return x\n", + "\n", + "def test_encoder_block():\n", + " encoder_block = CustomTransformerBlock(10, 2, 5)\n", + " x = torch.randn(2, 10, 10)\n", + " print('x:', x.shape)\n", + " print('encoder_block:', encoder_block(x).shape)\n", + "\n", + "test_encoder_block() " + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x: torch.Size([2, 10])\n", + "z: torch.Size([2, 4])\n", + "mu: torch.Size([2, 4])\n", + "sigma: torch.Size([2, 4])\n" + ] + } + ], + "source": [ + "class VAEEncoderHead(nn.Module):\n", + " def __init__(self, embedding_dim: int, latent_dim) -> None:\n", + " super().__init__()\n", + " self.encoder = nn.Sequential(\n", + " nn.Linear(in_features=embedding_dim, out_features=embedding_dim),\n", + " nn.SELU(),\n", + " nn.Linear(in_features=embedding_dim, out_features=embedding_dim)\n", + " )\n", + " self.mulogvar = nn.Linear(in_features=embedding_dim, out_features=2 * latent_dim)\n", + " \n", + " def forward(self, x: Tensor) -> Tuple[Tensor, Tensor]:\n", + " x = self.encoder(x)\n", + " mu, logvar = self.mulogvar(x).chunk(2, dim=-1)\n", + " sigma = logvar.exp()**0.5\n", + " eps = torch.randn_like(mu)\n", + " z = mu + sigma * eps\n", + " return z, mu, sigma\n", + " \n", + " def kld(self, mu: Tensor, logvar: Tensor) -> Tensor:\n", + " return -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\n", + "\n", + "def test_latent_encoder():\n", + " latent_encoder = VAEEncoderHead(10, 4)\n", + " x = torch.randn(2, 10)\n", + " print('x:', x.shape)\n", + " z, mu, sigma = latent_encoder(x)\n", + " print('z:', z.shape)\n", + " print('mu:', mu.shape)\n", + " print('sigma:', sigma.shape)\n", + "\n", + "test_latent_encoder()" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x: torch.Size([2, 10, 10])\n", + "regression_head: torch.Size([2, 10, 1])\n" + ] + } + ], + "source": [ + "class RegressionHead(nn.Module):\n", + " def __init__(self, embedding_dim: int) -> None:\n", + " super().__init__()\n", + " self.regressor = nn.Sequential(\n", + " nn.Linear(in_features=embedding_dim, out_features=embedding_dim),\n", + " nn.SELU(),\n", + " nn.Linear(in_features=embedding_dim, out_features=1)\n", + " )\n", + " \n", + " def forward(self, x: Tensor) -> Tensor:\n", + " # expected input shape (batch_size, num_genes, embedding_dim)\n", + " return self.regressor(x)\n", + "\n", + "def test_regression_head():\n", + " regression_head = RegressionHead(10)\n", + " x = torch.randn(2, 10, 10)\n", + " print('x:', x.shape)\n", + " print('regression_head:', regression_head(x).shape)\n", + "\n", + "test_regression_head()" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [], + "source": [ + "class TransformerAE(pl.LightningModule):\n", + " def __init__(self, cfg: Namespace):\n", + " super().__init__()\n", + " self.cfg = cfg\n", + " self.gene_choice_module = GeneChoiceModule(num_genes_total=cfg.model.num_genes, default_num_input_genes=cfg.gene_choice.default_num_input_genes, default_num_auxilary_decoded_genes=cfg.gene_choice.default_num_auxilary_decoded_genes, auxilary_gene_choice_mode=cfg.gene_choice.auxilary_gene_choice_mode)\n", + " self.embedding_module = EmbeddingModule(num_gene_embeddings=cfg.model.num_genes, gene_embedding_dim=cfg.model.gene_embedding_dim, embedding_dim=cfg.model.embedding_dim, latent_dim=cfg.model.latent_dim)\n", + " self.encoder_body = nn.Sequential(*[CustomTransformerBlock(embedding_dim=cfg.model.embedding_dim, num_heads=cfg.model.num_heads, hidden_dim=cfg.model.feedforward_hidden_dim) for _ in range(cfg.model.num_blocks_encoder)])\n", + " self.encoder_head = VAEEncoderHead(embedding_dim=cfg.model.embedding_dim, latent_dim=cfg.model.latent_dim)\n", + " self.decoder = nn.Sequential(*[CustomTransformerBlock(embedding_dim=cfg.model.embedding_dim, num_heads=cfg.model.num_heads, hidden_dim=cfg.model.feedforward_hidden_dim) for _ in range(cfg.model.num_blocks_decoder)])\n", + " self.regression_head = RegressionHead(embedding_dim=cfg.model.embedding_dim)\n", + "\n", + " def encode(self, gene_idxs: Tensor, expression_lvls: Tensor) -> Tuple[Tensor, Tensor, Tensor]:\n", + " batch_size, _ = gene_idxs.shape\n", + " x = self.embedding_module.embed_genes_and_expression_levels(gene_idxs, expression_lvls) # (batch_size, num_genes, embedding_dim)\n", + " # adding the pool embedding to the input. potentially more expressive than just averaging the embeddings, but more computations required\n", + " # I am concerned, that it is not the best though as the embeddings for the genes may collapse to the same value perhaps to pass more info through the pool embedding\n", + " x = torch.cat([self.embedding_module.pool_embed.repeat(batch_size, 1, 1), x], dim=1) # (batch_size, num_genes + 1, embedding_dim)\n", + " pooled_representation = self.encoder_body(x)[:, 0, :]\n", + " z, mu, sigma = self.encoder_head(pooled_representation)\n", + " return z, mu, sigma\n", + " \n", + " def decode(self, gene_idxs: Tensor, z: Tensor) -> Tensor:\n", + " # gene_idxs: (batch_size, num_genes), z: (batch_size, latent_dim)\n", + " x = self.embedding_module.embed_genes_and_latent_vars(gene_idxs, z) # (batch_size, num_genes, embedding_dim)\n", + " x = self.decoder(x)\n", + " x = self.regression_head(x)\n", + " return x\n", + "\n", + " def training_step(self, x: Tensor) -> Tensor:\n", + " # x: (batch_size, num_genes) - contains normalized sparse expression levels for all genes\n", + " # choosing the genes to be passed to the encoder and decoder as well as auxilary ones to be just decoded\n", + " x = x[0] # extract the tensor from the one element list\n", + " encoder_input_gene_idxs, aux_gene_idxs = self.gene_choice_module.choose(x)\n", + " encoder_input_exprs_lvls = torch.gather(x, dim=1, index=encoder_input_gene_idxs)\n", + " aux_exprs_lvls = torch.gather(x, dim=1, index=aux_gene_idxs)\n", + " z, mu, sigma = self.encode(encoder_input_gene_idxs, encoder_input_exprs_lvls)\n", + " decoder_input_gene_idxs = torch.cat([encoder_input_gene_idxs, aux_gene_idxs], dim=1)\n", + " decoder_input_exprs_lvls = torch.cat([encoder_input_exprs_lvls, aux_exprs_lvls], dim=1)\n", + " exprs_hat = self.decode(decoder_input_gene_idxs, z)\n", + " kld_loss = self.encoder_head.kld(mu, sigma)\n", + " reconstr_loss = nn.functional.mse_loss(exprs_hat, decoder_input_exprs_lvls)\n", + " \n", + " self.log('train_reconstr_loss', reconstr_loss, on_step=True, on_epoch=True, prog_bar=True, logger=True)\n", + " self.log('train_kld_loss', kld_loss, on_step=True, on_epoch=True, prog_bar=True, logger=True)\n", + "\n", + " return reconstr_loss + self.cfg.losses.kld_weight * kld_loss\n", + " \n", + " def validation_step(self, x: Tensor) -> Tensor:\n", + " # x: (batch_size, num_genes) - contains normalized sparse expression levels for all genes\n", + " encoder_input_gene_idxs, aux_gene_idxs = self.gene_choice_module.choose(x)\n", + " encoder_input_exprs_lvls = torch.gather(x, dim=1, index=encoder_input_gene_idxs)\n", + " aux_exprs_lvls = torch.gather(x, dim=1, index=aux_gene_idxs)\n", + " z, mu, sigma = self.encode(encoder_input_gene_idxs, encoder_input_exprs_lvls)\n", + " decoder_input_gene_idxs = torch.cat([encoder_input_gene_idxs, aux_gene_idxs], dim=1)\n", + " decoder_input_exprs_lvls = torch.cat([encoder_input_exprs_lvls, aux_exprs_lvls], dim=1)\n", + " exprs_hat = self.decode(decoder_input_gene_idxs, z)\n", + " kld_loss = self.encoder_head.kld(mu, sigma)\n", + " assert exprs_hat.shape == decoder_input_exprs_lvls.shape, f\"Expected {decoder_input_exprs_lvls.shape}, got {exprs_hat.shape}. Something is wrong with the decoder.\"\n", + " reconstr_loss = nn.functional.mse_loss(exprs_hat, decoder_input_exprs_lvls)\n", + " \n", + " self.log('val_reconstr_loss', reconstr_loss, on_step=True, on_epoch=True, prog_bar=True, logger=True)\n", + " self.log('val_kld_loss', kld_loss, on_step=True, on_epoch=True, prog_bar=True, logger=True)\n", + "\n", + " return reconstr_loss + self.cfg.losses.kld_weight * kld_loss\n", + " \n", + " def configure_optimizers(self):\n", + " optimizer = torch.optim.Adam(self.parameters(), lr=self.cfg.training.optimizer.lr)\n", + " return optimizer" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [], + "source": [ + "# be flexible about the configuration\n", + "# the goal is to move to hydra configuration, but for now it is a bit too much. yet hydra uses yaml so moving to it would be easy after learning the basics\n", + "# regression loss could be configurable as well\n", + "cfg_dict = {\n", + " \"model\": {\n", + " \"num_genes\": 14087,\n", + " \"gene_embedding_dim\": 32,\n", + " \"embedding_dim\": 256,\n", + " \"latent_dim\": 128,\n", + " \"num_heads\": 2,\n", + " \"feedforward_hidden_dim\": 256,\n", + " \"num_blocks_encoder\": 2,\n", + " \"num_blocks_decoder\": 2,\n", + " },\n", + " \"gene_choice\": {\n", + " \"default_num_input_genes\": 256,\n", + " \"default_num_auxilary_decoded_genes\": 128,\n", + " \"auxilary_gene_choice_mode\": \"sample_from_left\"\n", + " },\n", + " \"training\": {\n", + " \"batch_size\": 128,\n", + " \"optimizer\": {\n", + " \"lr\": 1e-3,\n", + " },\n", + " \"n_epochs\": 2,\n", + " },\n", + " \"losses\": {\n", + " \"kld_weight\": 0.01,\n", + " }\n", + "}\n", + "\n", + "def dict_to_namespace(d):\n", + " \"\"\"\n", + " Recursively converts a dictionary into a Namespace object.\n", + " \"\"\"\n", + " for key, value in d.items():\n", + " if isinstance(value, dict):\n", + " d[key] = dict_to_namespace(value)\n", + " return Namespace(**d)\n", + "\n", + "cfg = dict_to_namespace(cfg_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "TODO verify weather the dimensions are processed correctly in the model." + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [], + "source": [ + "train_tensor_dataset = torch.utils.data.TensorDataset(tensor_data)\n", + "train_loader = torch.utils.data.DataLoader(train_tensor_dataset, batch_size=cfg.training.batch_size, shuffle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([128, 14087])" + ] + }, + "execution_count": 115, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "next(iter(train_loader))[0].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: False, used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n" + ] + } + ], + "source": [ + "trainer = pl.Trainer(max_epochs=cfg.training.n_epochs)\n", + "model = TransformerAE(cfg)" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\configuration_validator.py:74: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n", + "\n", + " | Name | Type | Params\n", + "---------------------------------------------------\n", + "0 | encoder_body | Sequential | 1.2 M \n", + "1 | encoder_head | VAEEncoderHead | 197 K \n", + "2 | decoder | Sequential | 1.2 M \n", + "3 | regression_head | RegressionHead | 66.0 K\n", + "---------------------------------------------------\n", + "2.6 M Trainable params\n", + "0 Non-trainable params\n", + "2.6 M Total params\n", + "10.544 Total estimated model params size (MB)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=3` in the `DataLoader` to improve performance.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 0%| | 0/517 [00:00 1\u001b[0m \u001b[43mtrainer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_loader\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\trainer.py:544\u001b[0m, in \u001b[0;36mTrainer.fit\u001b[1;34m(self, model, train_dataloaders, val_dataloaders, datamodule, ckpt_path)\u001b[0m\n\u001b[0;32m 542\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate\u001b[38;5;241m.\u001b[39mstatus \u001b[38;5;241m=\u001b[39m TrainerStatus\u001b[38;5;241m.\u001b[39mRUNNING\n\u001b[0;32m 543\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtraining \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m--> 544\u001b[0m \u001b[43mcall\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_and_handle_interrupt\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 545\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_fit_impl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_dataloaders\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mval_dataloaders\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdatamodule\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mckpt_path\u001b[49m\n\u001b[0;32m 546\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\call.py:44\u001b[0m, in \u001b[0;36m_call_and_handle_interrupt\u001b[1;34m(trainer, trainer_fn, *args, **kwargs)\u001b[0m\n\u001b[0;32m 42\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m trainer\u001b[38;5;241m.\u001b[39mstrategy\u001b[38;5;241m.\u001b[39mlauncher \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m trainer\u001b[38;5;241m.\u001b[39mstrategy\u001b[38;5;241m.\u001b[39mlauncher\u001b[38;5;241m.\u001b[39mlaunch(trainer_fn, \u001b[38;5;241m*\u001b[39margs, trainer\u001b[38;5;241m=\u001b[39mtrainer, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m---> 44\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtrainer_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 46\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m _TunerExitException:\n\u001b[0;32m 47\u001b[0m _call_teardown_hook(trainer)\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\trainer.py:580\u001b[0m, in \u001b[0;36mTrainer._fit_impl\u001b[1;34m(self, model, train_dataloaders, val_dataloaders, datamodule, ckpt_path)\u001b[0m\n\u001b[0;32m 573\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate\u001b[38;5;241m.\u001b[39mfn \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m 574\u001b[0m ckpt_path \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_checkpoint_connector\u001b[38;5;241m.\u001b[39m_select_ckpt_path(\n\u001b[0;32m 575\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate\u001b[38;5;241m.\u001b[39mfn,\n\u001b[0;32m 576\u001b[0m ckpt_path,\n\u001b[0;32m 577\u001b[0m model_provided\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[0;32m 578\u001b[0m model_connected\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlightning_module \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[0;32m 579\u001b[0m )\n\u001b[1;32m--> 580\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_run\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mckpt_path\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mckpt_path\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 582\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate\u001b[38;5;241m.\u001b[39mstopped\n\u001b[0;32m 583\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtraining \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\trainer.py:987\u001b[0m, in \u001b[0;36mTrainer._run\u001b[1;34m(self, model, ckpt_path)\u001b[0m\n\u001b[0;32m 982\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_signal_connector\u001b[38;5;241m.\u001b[39mregister_signal_handlers()\n\u001b[0;32m 984\u001b[0m \u001b[38;5;66;03m# ----------------------------\u001b[39;00m\n\u001b[0;32m 985\u001b[0m \u001b[38;5;66;03m# RUN THE TRAINER\u001b[39;00m\n\u001b[0;32m 986\u001b[0m \u001b[38;5;66;03m# ----------------------------\u001b[39;00m\n\u001b[1;32m--> 987\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_run_stage\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 989\u001b[0m \u001b[38;5;66;03m# ----------------------------\u001b[39;00m\n\u001b[0;32m 990\u001b[0m \u001b[38;5;66;03m# POST-Training CLEAN UP\u001b[39;00m\n\u001b[0;32m 991\u001b[0m \u001b[38;5;66;03m# ----------------------------\u001b[39;00m\n\u001b[0;32m 992\u001b[0m log\u001b[38;5;241m.\u001b[39mdebug(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m: trainer tearing down\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\trainer.py:1033\u001b[0m, in \u001b[0;36mTrainer._run_stage\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 1031\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_run_sanity_check()\n\u001b[0;32m 1032\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mautograd\u001b[38;5;241m.\u001b[39mset_detect_anomaly(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_detect_anomaly):\n\u001b[1;32m-> 1033\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit_loop\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1034\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m 1035\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUnexpected state \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\loops\\fit_loop.py:205\u001b[0m, in \u001b[0;36m_FitLoop.run\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 203\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m 204\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mon_advance_start()\n\u001b[1;32m--> 205\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43madvance\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 206\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mon_advance_end()\n\u001b[0;32m 207\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_restarting \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\loops\\fit_loop.py:363\u001b[0m, in \u001b[0;36m_FitLoop.advance\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 361\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrainer\u001b[38;5;241m.\u001b[39mprofiler\u001b[38;5;241m.\u001b[39mprofile(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrun_training_epoch\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m 362\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_data_fetcher \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m--> 363\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mepoch_loop\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_data_fetcher\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\loops\\training_epoch_loop.py:140\u001b[0m, in \u001b[0;36m_TrainingEpochLoop.run\u001b[1;34m(self, data_fetcher)\u001b[0m\n\u001b[0;32m 138\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdone:\n\u001b[0;32m 139\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 140\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43madvance\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata_fetcher\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 141\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mon_advance_end(data_fetcher)\n\u001b[0;32m 142\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_restarting \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\loops\\training_epoch_loop.py:250\u001b[0m, in \u001b[0;36m_TrainingEpochLoop.advance\u001b[1;34m(self, data_fetcher)\u001b[0m\n\u001b[0;32m 247\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m trainer\u001b[38;5;241m.\u001b[39mprofiler\u001b[38;5;241m.\u001b[39mprofile(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrun_training_batch\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m 248\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m trainer\u001b[38;5;241m.\u001b[39mlightning_module\u001b[38;5;241m.\u001b[39mautomatic_optimization:\n\u001b[0;32m 249\u001b[0m \u001b[38;5;66;03m# in automatic optimization, there can only be one optimizer\u001b[39;00m\n\u001b[1;32m--> 250\u001b[0m batch_output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mautomatic_optimization\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrainer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimizers\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 251\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 252\u001b[0m batch_output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmanual_optimization\u001b[38;5;241m.\u001b[39mrun(kwargs)\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\loops\\optimization\\automatic.py:190\u001b[0m, in \u001b[0;36m_AutomaticOptimization.run\u001b[1;34m(self, optimizer, batch_idx, kwargs)\u001b[0m\n\u001b[0;32m 183\u001b[0m closure()\n\u001b[0;32m 185\u001b[0m \u001b[38;5;66;03m# ------------------------------\u001b[39;00m\n\u001b[0;32m 186\u001b[0m \u001b[38;5;66;03m# BACKWARD PASS\u001b[39;00m\n\u001b[0;32m 187\u001b[0m \u001b[38;5;66;03m# ------------------------------\u001b[39;00m\n\u001b[0;32m 188\u001b[0m \u001b[38;5;66;03m# gradient update with accumulated gradients\u001b[39;00m\n\u001b[0;32m 189\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 190\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_optimizer_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbatch_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclosure\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 192\u001b[0m result \u001b[38;5;241m=\u001b[39m closure\u001b[38;5;241m.\u001b[39mconsume_result()\n\u001b[0;32m 193\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m result\u001b[38;5;241m.\u001b[39mloss \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\loops\\optimization\\automatic.py:268\u001b[0m, in \u001b[0;36m_AutomaticOptimization._optimizer_step\u001b[1;34m(self, batch_idx, train_step_and_backward_closure)\u001b[0m\n\u001b[0;32m 265\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptim_progress\u001b[38;5;241m.\u001b[39moptimizer\u001b[38;5;241m.\u001b[39mstep\u001b[38;5;241m.\u001b[39mincrement_ready()\n\u001b[0;32m 267\u001b[0m \u001b[38;5;66;03m# model hook\u001b[39;00m\n\u001b[1;32m--> 268\u001b[0m \u001b[43mcall\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_lightning_module_hook\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 269\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrainer\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 270\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43moptimizer_step\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 271\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrainer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcurrent_epoch\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 272\u001b[0m \u001b[43m \u001b[49m\u001b[43mbatch_idx\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 273\u001b[0m \u001b[43m \u001b[49m\u001b[43moptimizer\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 274\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrain_step_and_backward_closure\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 275\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 277\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m should_accumulate:\n\u001b[0;32m 278\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptim_progress\u001b[38;5;241m.\u001b[39moptimizer\u001b[38;5;241m.\u001b[39mstep\u001b[38;5;241m.\u001b[39mincrement_completed()\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\call.py:157\u001b[0m, in \u001b[0;36m_call_lightning_module_hook\u001b[1;34m(trainer, hook_name, pl_module, *args, **kwargs)\u001b[0m\n\u001b[0;32m 154\u001b[0m pl_module\u001b[38;5;241m.\u001b[39m_current_fx_name \u001b[38;5;241m=\u001b[39m hook_name\n\u001b[0;32m 156\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m trainer\u001b[38;5;241m.\u001b[39mprofiler\u001b[38;5;241m.\u001b[39mprofile(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m[LightningModule]\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mpl_module\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mhook_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m--> 157\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 159\u001b[0m \u001b[38;5;66;03m# restore current_fx when nested context\u001b[39;00m\n\u001b[0;32m 160\u001b[0m pl_module\u001b[38;5;241m.\u001b[39m_current_fx_name \u001b[38;5;241m=\u001b[39m prev_fx_name\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\core\\module.py:1303\u001b[0m, in \u001b[0;36mLightningModule.optimizer_step\u001b[1;34m(self, epoch, batch_idx, optimizer, optimizer_closure)\u001b[0m\n\u001b[0;32m 1264\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21moptimizer_step\u001b[39m(\n\u001b[0;32m 1265\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 1266\u001b[0m epoch: \u001b[38;5;28mint\u001b[39m,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1269\u001b[0m optimizer_closure: Optional[Callable[[], Any]] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[0;32m 1270\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 1271\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Override this method to adjust the default way the :class:`~pytorch_lightning.trainer.trainer.Trainer` calls\u001b[39;00m\n\u001b[0;32m 1272\u001b[0m \u001b[38;5;124;03m the optimizer.\u001b[39;00m\n\u001b[0;32m 1273\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1301\u001b[0m \n\u001b[0;32m 1302\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[1;32m-> 1303\u001b[0m \u001b[43moptimizer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43mclosure\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptimizer_closure\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\core\\optimizer.py:152\u001b[0m, in \u001b[0;36mLightningOptimizer.step\u001b[1;34m(self, closure, **kwargs)\u001b[0m\n\u001b[0;32m 149\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m MisconfigurationException(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWhen `optimizer.step(closure)` is called, the closure should be callable\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 151\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_strategy \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m--> 152\u001b[0m step_output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_strategy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimizer_step\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_optimizer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclosure\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 154\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_on_after_step()\n\u001b[0;32m 156\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m step_output\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\strategies\\strategy.py:239\u001b[0m, in \u001b[0;36mStrategy.optimizer_step\u001b[1;34m(self, optimizer, closure, model, **kwargs)\u001b[0m\n\u001b[0;32m 237\u001b[0m \u001b[38;5;66;03m# TODO(fabric): remove assertion once strategy's optimizer_step typing is fixed\u001b[39;00m\n\u001b[0;32m 238\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(model, pl\u001b[38;5;241m.\u001b[39mLightningModule)\n\u001b[1;32m--> 239\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprecision_plugin\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimizer_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43moptimizer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclosure\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mclosure\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\plugins\\precision\\precision.py:122\u001b[0m, in \u001b[0;36mPrecision.optimizer_step\u001b[1;34m(self, optimizer, model, closure, **kwargs)\u001b[0m\n\u001b[0;32m 120\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Hook to run the optimizer step.\"\"\"\u001b[39;00m\n\u001b[0;32m 121\u001b[0m closure \u001b[38;5;241m=\u001b[39m partial(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_wrap_closure, model, optimizer, closure)\n\u001b[1;32m--> 122\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43moptimizer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43mclosure\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mclosure\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\torch\\optim\\optimizer.py:391\u001b[0m, in \u001b[0;36mOptimizer.profile_hook_step..wrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 386\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 387\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\n\u001b[0;32m 388\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfunc\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m must return None or a tuple of (new_args, new_kwargs), but got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mresult\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 389\u001b[0m )\n\u001b[1;32m--> 391\u001b[0m out \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 392\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_optimizer_step_code()\n\u001b[0;32m 394\u001b[0m \u001b[38;5;66;03m# call optimizer step post hooks\u001b[39;00m\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\torch\\optim\\optimizer.py:76\u001b[0m, in \u001b[0;36m_use_grad_for_differentiable.._use_grad\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 74\u001b[0m torch\u001b[38;5;241m.\u001b[39mset_grad_enabled(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdefaults[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdifferentiable\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[0;32m 75\u001b[0m torch\u001b[38;5;241m.\u001b[39m_dynamo\u001b[38;5;241m.\u001b[39mgraph_break()\n\u001b[1;32m---> 76\u001b[0m ret \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 77\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[0;32m 78\u001b[0m torch\u001b[38;5;241m.\u001b[39m_dynamo\u001b[38;5;241m.\u001b[39mgraph_break()\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\torch\\optim\\adam.py:148\u001b[0m, in \u001b[0;36mAdam.step\u001b[1;34m(self, closure)\u001b[0m\n\u001b[0;32m 146\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m closure \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 147\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39menable_grad():\n\u001b[1;32m--> 148\u001b[0m loss \u001b[38;5;241m=\u001b[39m \u001b[43mclosure\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 150\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m group \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparam_groups:\n\u001b[0;32m 151\u001b[0m params_with_grad \u001b[38;5;241m=\u001b[39m []\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\plugins\\precision\\precision.py:108\u001b[0m, in \u001b[0;36mPrecision._wrap_closure\u001b[1;34m(self, model, optimizer, closure)\u001b[0m\n\u001b[0;32m 95\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_wrap_closure\u001b[39m(\n\u001b[0;32m 96\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 97\u001b[0m model: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpl.LightningModule\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m 98\u001b[0m optimizer: Optimizer,\n\u001b[0;32m 99\u001b[0m closure: Callable[[], Any],\n\u001b[0;32m 100\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[0;32m 101\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"This double-closure allows makes sure the ``closure`` is executed before the ``on_before_optimizer_step``\u001b[39;00m\n\u001b[0;32m 102\u001b[0m \u001b[38;5;124;03m hook is called.\u001b[39;00m\n\u001b[0;32m 103\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 106\u001b[0m \n\u001b[0;32m 107\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[1;32m--> 108\u001b[0m closure_result \u001b[38;5;241m=\u001b[39m \u001b[43mclosure\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 109\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_after_closure(model, optimizer)\n\u001b[0;32m 110\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m closure_result\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\loops\\optimization\\automatic.py:144\u001b[0m, in \u001b[0;36mClosure.__call__\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 142\u001b[0m \u001b[38;5;129m@override\u001b[39m\n\u001b[0;32m 143\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs: Any, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Optional[Tensor]:\n\u001b[1;32m--> 144\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclosure\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 145\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_result\u001b[38;5;241m.\u001b[39mloss\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\torch\\utils\\_contextlib.py:115\u001b[0m, in \u001b[0;36mcontext_decorator..decorate_context\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 112\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[0;32m 113\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdecorate_context\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m 114\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m ctx_factory():\n\u001b[1;32m--> 115\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\loops\\optimization\\automatic.py:129\u001b[0m, in \u001b[0;36mClosure.closure\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 126\u001b[0m \u001b[38;5;129m@override\u001b[39m\n\u001b[0;32m 127\u001b[0m \u001b[38;5;129m@torch\u001b[39m\u001b[38;5;241m.\u001b[39menable_grad()\n\u001b[0;32m 128\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mclosure\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs: Any, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ClosureResult:\n\u001b[1;32m--> 129\u001b[0m step_output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_step_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 131\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m step_output\u001b[38;5;241m.\u001b[39mclosure_loss \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 132\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mwarning_cache\u001b[38;5;241m.\u001b[39mwarn(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m`training_step` returned `None`. If this was on purpose, ignore this warning...\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\loops\\optimization\\automatic.py:318\u001b[0m, in \u001b[0;36m_AutomaticOptimization._training_step\u001b[1;34m(self, kwargs)\u001b[0m\n\u001b[0;32m 315\u001b[0m trainer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrainer\n\u001b[0;32m 317\u001b[0m \u001b[38;5;66;03m# manually capture logged metrics\u001b[39;00m\n\u001b[1;32m--> 318\u001b[0m training_step_output \u001b[38;5;241m=\u001b[39m \u001b[43mcall\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_strategy_hook\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrainer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtraining_step\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvalues\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 319\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrainer\u001b[38;5;241m.\u001b[39mstrategy\u001b[38;5;241m.\u001b[39mpost_training_step() \u001b[38;5;66;03m# unused hook - call anyway for backward compatibility\u001b[39;00m\n\u001b[0;32m 321\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moutput_result_cls\u001b[38;5;241m.\u001b[39mfrom_training_step_output(training_step_output, trainer\u001b[38;5;241m.\u001b[39maccumulate_grad_batches)\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\trainer\\call.py:309\u001b[0m, in \u001b[0;36m_call_strategy_hook\u001b[1;34m(trainer, hook_name, *args, **kwargs)\u001b[0m\n\u001b[0;32m 306\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m 308\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m trainer\u001b[38;5;241m.\u001b[39mprofiler\u001b[38;5;241m.\u001b[39mprofile(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m[Strategy]\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtrainer\u001b[38;5;241m.\u001b[39mstrategy\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mhook_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m--> 309\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 311\u001b[0m \u001b[38;5;66;03m# restore current_fx when nested context\u001b[39;00m\n\u001b[0;32m 312\u001b[0m pl_module\u001b[38;5;241m.\u001b[39m_current_fx_name \u001b[38;5;241m=\u001b[39m prev_fx_name\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\pytorch_lightning\\strategies\\strategy.py:391\u001b[0m, in \u001b[0;36mStrategy.training_step\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 389\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmodel \u001b[38;5;241m!=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlightning_module:\n\u001b[0;32m 390\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_redirection(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmodel, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlightning_module, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtraining_step\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m--> 391\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlightning_module\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtraining_step\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[1;32mIn[108], line 41\u001b[0m, in \u001b[0;36mTransformerAE.training_step\u001b[1;34m(self, x)\u001b[0m\n\u001b[0;32m 39\u001b[0m exprs_hat \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdecode(decoder_input_gene_idxs, z)\n\u001b[0;32m 40\u001b[0m kld_loss \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mencoder_head\u001b[38;5;241m.\u001b[39mkld(mu, sigma)\n\u001b[1;32m---> 41\u001b[0m reconstr_loss \u001b[38;5;241m=\u001b[39m \u001b[43mnn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunctional\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmse_loss\u001b[49m\u001b[43m(\u001b[49m\u001b[43mexprs_hat\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdecoder_input_exprs_lvls\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 43\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlog(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtrain_reconstr_loss\u001b[39m\u001b[38;5;124m'\u001b[39m, reconstr_loss, on_step\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, on_epoch\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, prog_bar\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, logger\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[0;32m 44\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlog(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtrain_kld_loss\u001b[39m\u001b[38;5;124m'\u001b[39m, kld_loss, on_step\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, on_epoch\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, prog_bar\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, logger\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\torch\\nn\\functional.py:3365\u001b[0m, in \u001b[0;36mmse_loss\u001b[1;34m(input, target, size_average, reduce, reduction)\u001b[0m\n\u001b[0;32m 3362\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m size_average \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m reduce \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 3363\u001b[0m reduction \u001b[38;5;241m=\u001b[39m _Reduction\u001b[38;5;241m.\u001b[39mlegacy_get_string(size_average, reduce)\n\u001b[1;32m-> 3365\u001b[0m expanded_input, expanded_target \u001b[38;5;241m=\u001b[39m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbroadcast_tensors\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3366\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m torch\u001b[38;5;241m.\u001b[39m_C\u001b[38;5;241m.\u001b[39m_nn\u001b[38;5;241m.\u001b[39mmse_loss(expanded_input, expanded_target, _Reduction\u001b[38;5;241m.\u001b[39mget_enum(reduction))\n", + "File \u001b[1;32md:\\bioml\\.venv\\Lib\\site-packages\\torch\\functional.py:76\u001b[0m, in \u001b[0;36mbroadcast_tensors\u001b[1;34m(*tensors)\u001b[0m\n\u001b[0;32m 74\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m has_torch_function(tensors):\n\u001b[0;32m 75\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m handle_torch_function(broadcast_tensors, tensors, \u001b[38;5;241m*\u001b[39mtensors)\n\u001b[1;32m---> 76\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_VF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbroadcast_tensors\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtensors\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[1;31mRuntimeError\u001b[0m: The size of tensor a (384) must match the size of tensor b (128) at non-singleton dimension 1" + ] + } + ], + "source": [ + "trainer.fit(model, train_loader)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index 312cbdf..0000000 Binary files a/requirements.txt and /dev/null differ diff --git a/requirements_old.txt b/requirements_old.txt new file mode 100644 index 0000000..dc33515 Binary files /dev/null and b/requirements_old.txt differ diff --git a/requirements_vaes.txt b/requirements_vaes.txt new file mode 100644 index 0000000..8c9fb12 --- /dev/null +++ b/requirements_vaes.txt @@ -0,0 +1,13 @@ +anndata==0.10.8 +matplotlib==3.9.1 +mrunner @ git+https://gitlab.com/awarelab/mrunner.git +neptune==1.10.4 +numpy==2.0.1 +pandas==2.2.2 +pytorch_lightning==2.3.3 +PyYAML==6.0.1 +scanpy +scikit_learn==1.5.1 +seaborn==0.13.2 +torch==2.3.1 +tqdm==4.66.4 diff --git a/specs/jw/jw000_sample_spec.py b/specs/jw/jw000_sample_spec.py new file mode 100644 index 0000000..5a46115 --- /dev/null +++ b/specs/jw/jw000_sample_spec.py @@ -0,0 +1,75 @@ +from mrunner.helpers.specification_helper import create_experiments_helper + +from src.global_utils.parser import combine_with_defaults + +name = globals()["script"][:-3] + + +modalities_draft_config = {} + +modalities_draft_config["gex"] = { + # "modality_name": "GEX", # you can add modality name, but it's not necessary -- deafult name is name.upper() + "dim": 13953, # max 13953 | MAY BE CHANGED FOR DEBUGGING +} + +modalities_draft_config["adt"] = { + "dim": 134, # max 134 | MAY BE CHANGED FOR DEBUGGING +} + + +base_config = { + "method": "omivae", + "model_name": "OmiAE", + "mode": "train", + "retrain": True, + "lr": 0.001, + "batch_size": 128, + "subsample_frac": 1, # MAY BE CHANGED FOR DEBUGGING + "data_normalization": "standarize", # "log1p", "standardize", "pearson_residuals", null -> None + "remove_batch_effect": True, + # include_class_labels: False + "target_hierarchy_level": -1, + "max_epochs": 10, + "log_every_n_steps": 1, + "early_stopping": True, + "early_stopping_delta": 0.001, + "early_stopping_patience": 5, + "hidden_dim": 128, + "encoder_hidden_dim": 128, + "encoder_out_dim": 16, + "latent_dim": 16, + "decoder_hidden_dim": 128, + # other + "batch_norm": False, + "dropout_rate": 0.1, + "recon_loss_coef": 1, + "kld_loss_coef": 0.1, +} + +base_config = combine_with_defaults(base_config, modalities_draft_config) + +params_grid = [{"target_hierarchy_level": [-1]}] + +print(params_grid) + + +experiments_list = create_experiments_helper( + experiment_name=name, + project_name="multimodal/vaes", + script="python3 -u mrun.py", + python_path="", + exclude=[ + "apptainer", + "venv", + "old_code", + "examples", + ], + tags=[name], + base_config=base_config, + params_grid=params_grid, +) + +# REMEMBER THAT YOU NEED TO EXPORT NEPTUNE_API_TOKEN, NEPTUNE_PROJECT AND SET PYTHONPATH. Example: +# export NEPTUNE_API_TOKEN="your_token" +# export NEPTUNE_PROJECT="multimodal/vaes" +# export PYTHONPATH=$PYTHONPATH:$(pwd) diff --git a/src/config/models/babel/babel_vae.yaml b/src/config/models/babel/babel_vae.yaml index 250ac41..19795f8 100644 --- a/src/config/models/babel/babel_vae.yaml +++ b/src/config/models/babel/babel_vae.yaml @@ -61,4 +61,4 @@ classification_head: False lr: 0.001 recon_loss_coef: 1 kld_loss_coef: 0.01 -batch_size: 128 \ No newline at end of file +batch_size: 128 diff --git a/src/config/models/omivae/omiae.yaml b/src/config/models/omivae/omiae.yaml index a3dbd95..0c3c12b 100644 --- a/src/config/models/omivae/omiae.yaml +++ b/src/config/models/omivae/omiae.yaml @@ -28,4 +28,4 @@ max_epochs: 10 log_every_n_steps: 1 early_stopping: False min_delta: 0.01 -patience: 5 \ No newline at end of file +patience: 5 diff --git a/src/config/models/omivae/omigmmiwae.yaml b/src/config/models/omivae/omigmmiwae.yaml index c17bf7a..16828b3 100644 --- a/src/config/models/omivae/omigmmiwae.yaml +++ b/src/config/models/omivae/omigmmiwae.yaml @@ -37,4 +37,4 @@ log_every_n_steps: 1 early_stopping: False min_delta: 0.01 patience: 5 -# logger: True \ No newline at end of file +# logger: True diff --git a/src/config/models/omivae/omiiwae_bn.yaml b/src/config/models/omivae/omiiwae_bn.yaml index 8141520..1e97ab7 100644 --- a/src/config/models/omivae/omiiwae_bn.yaml +++ b/src/config/models/omivae/omiiwae_bn.yaml @@ -36,5 +36,4 @@ min_delta: 0.01 patience: 2 gmm_likelihood_loss_coef: 0.002 entropy_loss_coef: 0.002 -recon_loss_coef: 1 -# logger: True \ No newline at end of file +# logger: True diff --git a/src/config/models/vae/vae.yaml b/src/config/models/vae/vae.yaml index b66e1c2..4d1be3b 100644 --- a/src/config/models/vae/vae.yaml +++ b/src/config/models/vae/vae.yaml @@ -60,4 +60,4 @@ log_every_n_steps: 1 early_stopping: False min_delta: 0.001 patience: 5 -# logger: True \ No newline at end of file +# logger: True diff --git a/src/data/BaseDataloader.py b/src/data/BaseDataloader.py new file mode 100644 index 0000000..e69de29 diff --git a/src/data/__init__.py b/src/data/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/data/add_hierarchies.py b/src/data/add_hierarchies.py new file mode 100644 index 0000000..9e18e35 --- /dev/null +++ b/src/data/add_hierarchies.py @@ -0,0 +1,78 @@ +import sys + +import anndata as ad +import numpy as np + +from src.global_utils.paths import RAW_ANNDATA_HIERARCHY_PATH + +default_hierarchies_mapping = { + "cite-seq": { + "CD14+ Mono": "Monocytes", + "CD16+ Mono": "Monocytes", + "CD4+ T activated": "T Cells", + "CD4+ T naive": "T Cells", + "CD8+ T naive": "T Cells", + "CD8+ T CD57+ CD45RO+": "T Cells", + "CD8+ T CD57+ CD45RA+": "T Cells", + "CD8+ T TIGIT+ CD45RO+": "T Cells", + "CD8+ T TIGIT+ CD45RA+": "T Cells", + "CD8+ T CD49f+": "T Cells", + "CD8+ T CD69+ CD45RO+": "T Cells", + "CD8+ T CD69+ CD45RA+": "T Cells", + "CD8+ T naive CD127+ CD26- CD101-": "T Cells", + "CD4+ T activated integrinB7+": "T Cells", + "CD4+ T CD314+ CD45RA+": "T Cells", + "MAIT": "T Cells", + "gdT CD158b+": "T Cells", + "gdT TCRVD2+": "T Cells", + "dnT": "T Cells", + "T reg": "T Cells", + "T prog cycling": "T Cells", + "Naive CD20+ B IGKC+": "B Cells", + "Naive CD20+ B IGKC-": "B Cells", + "Transitional B": "B Cells", + "B1 B IGKC+": "B Cells", + "B1 B IGKC-": "B Cells", + "Plasma cell IGKC+": "Plasma Cells", + "Plasma cell IGKC-": "Plasma Cells", + "Plasmablast IGKC+": "Plasma Cells", + "Plasmablast IGKC-": "Plasma Cells", + "NK": "NK Cells", + "NK CD158e1+": "NK Cells", + "cDC1": "Dendritic Cells", + "cDC2": "Dendritic Cells", + "pDC": "Dendritic Cells", + "HSC": "Progenitors and Stem Cells", + "Lymph prog": "Progenitors and Stem Cells", + "G/M prog": "Progenitors and Stem Cells", + "MK/E prog": "Progenitors and Stem Cells", + "Reticulocyte": "Erythroid Lineage", + "Erythroblast": "Erythroid Lineage", + "Proerythroblast": "Erythroid Lineage", + "Normoblast": "Erythroid Lineage", + "ILC": "Innate Lymphoid Cells", + "ILC1": "Innate Lymphoid Cells", + } +} + + +def add_second_hierarchy( + data, dataset_name, hierarchies_mapping: dict = default_hierarchies_mapping +): + labels = data.obs["cell_type"] + print(labels) + data.obs["second_hierarchy"] = labels.map(hierarchies_mapping[dataset_name]) + print("Second hierarchy mapping:", data.obs["second_hierarchy"].head()) + + data.write(filename=str(RAW_ANNDATA_HIERARCHY_PATH / dataset_name)) + return data + + +def main( + dataset, dataset_name="cite-seq" +): # TODO: for now set default. but remove later + add_second_hierarchy(dataset, dataset_name) + + +if __name__ == "__main__": + main() diff --git a/src/data/dataloader_todo.py b/src/data/dataloader_todo.py new file mode 100644 index 0000000..6d84455 --- /dev/null +++ b/src/data/dataloader_todo.py @@ -0,0 +1,356 @@ +import os +from types import SimpleNamespace +from typing import Dict + +import anndata as ad +import scanpy as sc +import torch +import torch.utils +from torch.utils.data import DataLoader, TensorDataset + +from src.data.add_hierarchies import add_second_hierarchy +from src.global_utils.paths import ( + PREPROCESSED_ANNDATA_PATH, + PREPROCESSED_DATA_PATH, + RAW_ANNDATA_PATH, +) + + +class Modality: + GEX = "GEX" + ADT = "ADT" + + +def _preprocess_modality(_data: ad.AnnData, modality_type: Modality): + if modality_type == Modality.GEX: + sc.pp.log1p(_data) + sc.pp.scale(_data) + # sc.experimental.pp.normalize_pearson_residuals(_data) + + # TODO: consider the following operations + # if scipy.sparse.issparse(X): + # mean = X.mean(axis=0).A1 + # std = np.sqrt(X.power(2).mean(axis=0).A1 - np.square(mean)) + # X = (X.toarray() - mean) / std + # else: + # mean = X.mean(axis=0) + # std = np.sqrt(X.square().mean(axis=0) - np.square(mean)) + # X = (X - mean) / std + # X = X.clip(-10, 10) + + +def _preprocess_anndata(remove_batch_effect: bool, normalize: bool) -> ad.AnnData: + if normalize == "standarize" and PREPROCESSED_ANNDATA_PATH.exists(): + print("Loading preprocessed data...") + return ad.read_h5ad(PREPROCESSED_ANNDATA_PATH) + + _data = ad.read_h5ad(RAW_ANNDATA_PATH) + + if normalize == "standarize": + gex_indicator = (_data.var["feature_types"] == "GEX").values + _preprocess_modality(_data.X[:, gex_indicator], Modality.GEX) + _preprocess_modality(_data.X[:, ~gex_indicator], Modality.ADT) + if remove_batch_effect: # Ensure data selection if needed + sc.external.pp.bbknn( + _data[:, gex_indicator], batch_key="Site", use_rep="GEX_X_pca" + ) + sc.external.pp.bbknn( + _data[:, ~gex_indicator], batch_key="Site", use_rep="ADT_X_pca" + ) + if not os.path.exists(PREPROCESSED_DATA_PATH): + os.makedirs(PREPROCESSED_DATA_PATH) + _data.write(filename=PREPROCESSED_ANNDATA_PATH) + return _data + + +def load_anndata( + mode: str, + plus_iid_holdout: bool = False, + normalize: str = "standarize", + remove_batch_effect: bool = True, + target_hierarchy_level: int = -1, + preload_subsample_frac: float = 1.0, +) -> ad.AnnData: + r""" + Load the full anndata object for the specified mode. + + Arguments: + mode : str + The mode to load the anndata object for. Must be one of ['train', 'test', 'train+test']. + plus_iid_holdout : bool + Whether to include the iid_holdout data in the anndata object. + + Returns: + data : anndata.AnnData + The full anndata object for the specified mode. + """ + assert mode in [ + "train", + "test", + "train+test", + ], f"mode must be one of ['train', 'test', 'train+test'], got {mode} instead." + assert isinstance( + plus_iid_holdout, bool + ), f"plus_iid_holdout must be a boolean, got {plus_iid_holdout} instead." + assert isinstance( + normalize, str + ), f"normalize must be a string, got {normalize} instead." + assert isinstance( + remove_batch_effect, bool + ), f"remove_batch_effect must be a boolean, got {remove_batch_effect} instead." + assert isinstance( + target_hierarchy_level, int + ), f"target_hierarchy_level must be a int, got {target_hierarchy_level} instead." + assert target_hierarchy_level in [ + -1, + -2, + ], f"target_hierarchy_level must be in [-1, -2], got {target_hierarchy_level} instead." + filter_set = mode.split("+") # ['train'] or ['test'] or ['train', 'test'] + + if plus_iid_holdout: + filter_set.append("iid_holdout") + + # Read and normalize + _data = ad.read_h5ad(RAW_ANNDATA_PATH) + if normalize == "standarize": + sc.pp.log1p(_data) + # _data = _preprocess_anndata(remove_batch_effect, normalize) + + if target_hierarchy_level == -2: + _data = add_second_hierarchy(_data) + + if preload_subsample_frac is not None: + print(f"Subsampling anndata with fraction {preload_subsample_frac}...") + sc.pp.subsample(_data, fraction=preload_subsample_frac) + + data = _data[_data.obs["is_train"].apply(lambda x: x in filter_set)] + + return data + + +def get_modality_data_from_anndata( + data: ad.AnnData, modality_cfg: SimpleNamespace +) -> torch.Tensor: + r""" + Get a TensorDataset object for the given modality. + + Arguments: + data : anndata.AnnData + The data to create a TensorDataset for. + modality_cfg : types.SimpleNamespace + The configuration for the modality. + + Returns: + modality_data : torch.Tensor + The TensorDataset object for the given modality. + """ + assert modality_cfg.modality_name in [ + Modality.GEX, + Modality.ADT, + ], f"modality must be one of [{Modality.GEX}, {Modality.ADT}], got {modality_cfg.modality_name} instead." + modality_indicator = ( + data.var["feature_types"] == modality_cfg.modality_name + ).values + assert modality_indicator.sum() >= modality_cfg.dim, ( + f"modality dim must be less than or equal to the number of {modality_cfg.modality_name} features, " + f"got {modality_cfg.dim} and {modality_indicator.sum()} instead." + ) + modality_data = torch.tensor( + data[:, modality_indicator][:, : modality_cfg.dim].X.toarray(), + dtype=torch.float32, + ) + if torch.isnan(modality_data).any(): + print( + f"{torch.isnan(modality_data).sum() / modality_data.numel() * 100}% of the values are nan in {modality_data} data." + ) + else: + print(f"There are no nan values in {modality_cfg.modality_name} data.") + return modality_data + + +def get_data_dict_from_anndata( + data: ad.AnnData, + modalities_cfg: SimpleNamespace, + include_class_labels: bool = False, + target_hierarchy_level: int = -1, +) -> Dict[str, torch.Tensor]: + r""" + Get a TensorDataset object for the given data. + + Arguments: + data : anndata.AnnData + The data to create a TensorDataset for. + + Returns: + data_dict : dict of torch.Tensor + """ + data_dict = { + cfg_name: get_modality_data_from_anndata(data, modality_cfg) + for cfg_name, modality_cfg in vars(modalities_cfg).items() + } + if include_class_labels: + if target_hierarchy_level == -1: + labels = torch.tensor( + data.obs["cell_type"].cat.codes.values, dtype=torch.long + ) + elif target_hierarchy_level == -2: + labels = torch.tensor( + data.obs["second_hierarchy"].cat.codes.values, dtype=torch.long + ) + + data_dict["labels"] = labels + return data_dict + + +def get_dataset_from_anndata( + data: ad.AnnData, + config, + include_class_labels: bool = True, + target_hierarchy_level: int = -1, +) -> TensorDataset: + r""" + Get a TensorDataset object for the given data. + + Arguments: + data : anndata.AnnData + The data to create a TensorDataset for. + modality_cfgs : Dict[str, SimpleNamespace] + A dictionary containing configurations for each modality. + + Returns: + dataset : torch.utils.data.TensorDataset + The TensorDataset object for the given data. + """ + data_list = [] + for modality_name in config.modalities_names: + modality_cfg = SimpleNamespace( + modality_name=modality_name.upper(), + dim=vars(config)[f"{modality_name}_dim"], + ) + modality_data = get_modality_data_from_anndata(data, modality_cfg) + data_list.append(modality_data) + + if include_class_labels: + if target_hierarchy_level == -1: + labels = torch.tensor( + data.obs["cell_type"].cat.codes.values, dtype=torch.long + ) + elif target_hierarchy_level == -2: + labels = torch.tensor( + data.obs["second_hierarchy"].cat.codes.values, dtype=torch.long + ) + data_list.append(labels) + + dataset = TensorDataset(*data_list) + return dataset + + +# def get_dataset_from_anndata( +# data: ad.AnnData, +# first_modality_dim: int = 13953, +# second_modality_dim: int = 134, +# include_class_labels: bool = True, +# target_hierarchy_level: int = -1, +# ) -> TensorDataset: +# r""" +# Get a TensorDataset object for the given data. + +# Arguments: +# data : anndata.AnnData +# The data to create a TensorDataset for. +# first_modality_dim, second_modality_dim : int +# Number of sizes of each modality. +# include_class_labels : bool +# Number of sizes of each modality. +# target_hierarchy_level : int +# What hierarchy to use when include_class_labels=True. +# If equal -1, "cell_type" will be used, and if -2, "second_hierarchy". + +# Returns: +# dataset : torch.utils.data.TensorDataset +# The TensorDataset object for the given data. +# """ +# modalities_cfg = SimpleNamespace( +# gex=SimpleNamespace(modality_name=Modality.GEX, dim=first_modality_dim), +# adt=SimpleNamespace(modality_name=Modality.ADT, dim=second_modality_dim), +# ) +# data_dict = get_data_dict_from_anndata( +# data, modalities_cfg, include_class_labels, target_hierarchy_level +# ) +# data_list = [data_dict["gex"], data_dict["adt"]] +# if include_class_labels: +# data_list.append(data_dict["labels"]) +# dataset = TensorDataset(*data_list) +# return dataset + + +def get_dataloader_from_anndata( + data: ad.AnnData, + batch_size: int, + config, + shuffle: bool = True, + include_class_labels: bool = True, + target_hierarchy_level: int = -1, +) -> DataLoader: + r""" + Get a DataLoader object for the given data. + + Arguments: + data : anndata.AnnData + The data to create a DataLoader for. + batch_size : int + The batch size to use for the DataLoader. + + Returns: + dataloader : torch.utils.data.DataLoader + The DataLoader object for the given data starting with the GEX data. + """ + dataset = get_dataset_from_anndata( + data, + config, + include_class_labels, + target_hierarchy_level, + ) + dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=shuffle) + return dataloader + + +def get_dataloader_dict_from_anndata( + data: ad.AnnData, + cfg: SimpleNamespace, + train: bool = True, +) -> Dict[str, DataLoader]: + r""" + Get a DataLoader object for the given data. + + Arguments: + data : anndata.AnnData + The data to create a DataLoader for. + batch_size : int + The batch size to use for the DataLoader. + + Returns: + dataloader : torch.utils.data.DataLoader + The DataLoader object for the given data. With the GEX data first. + """ + modalities_cfg = cfg.modalities + data_dict = get_data_dict_from_anndata( + data, modalities_cfg, cfg.include_class_labels, cfg.target_hierarchy_level + ) + + dataloader_dict = { + cfg_modality_name: DataLoader( + ( + TensorDataset(data_dict[cfg_modality_name], data_dict["labels"]) + if cfg.include_class_labels + else TensorDataset(data_dict[cfg_modality_name]) + ), + batch_size=cfg_modality.batch_size, + shuffle=False, # train, + ) + for cfg_modality_name, cfg_modality in vars(cfg.modalities).items() + } + return dataloader_dict + + +# def pearson_residuals_transform diff --git a/src/data/preprocess_transformer.py b/src/data/preprocess_transformer.py new file mode 100644 index 0000000..aaa8560 --- /dev/null +++ b/src/data/preprocess_transformer.py @@ -0,0 +1,66 @@ +import random + +import numpy as np +import torch +from torch import Tensor +from utils.data_utils import load_anndata +from utils.paths import TRANSFORMER_DATA_PATH + + +def split_nonzero_zero_with_medians(data: Tensor): + all_medians = torch.median(data, dim=0).values # po wymiarze markerow + assert all_medians.shape[0] == data.shape[1] + nonzero_mask = all_medians != 0 + zero_mask = all_medians == 0 + + medians_nonzero = all_medians[nonzero_mask] + data_nonzero = data[:, nonzero_mask] + assert data_nonzero.shape[0] == data.shape[0] + data_zero = data[:, zero_mask] + assert data_zero.shape[0] == data.shape[0] + print("print number of markers with median zero:", data_zero.shape[1]) + print("print number of markers with median nonzero:", data_nonzero.shape[1]) + return medians_nonzero, data_nonzero, data_zero + + +def get_top_nonzeros(medians_nonzero, data_nonzero, n: int): + top_n_indices = torch.argsort(medians_nonzero, descending=True)[:n] + return data_nonzero[:, top_n_indices] + + +def get_random_zeros(data_zero, k: int): + num_cols = data_zero.shape[1] + random_indices = random.sample(range(num_cols), k) + return data_zero[:, random_indices] + + +def select_top_n_and_random_k(data: Tensor, n: int, k: int): + medians_nonzero, data_nonzero, data_zero = split_nonzero_zero_with_medians(data) + + top_n_data = get_top_nonzeros(medians_nonzero, data_nonzero, n) + random_k_data = get_random_zeros(data_zero, k) + + combined_data = torch.cat((top_n_data, random_k_data), dim=1) + print("Shape of combined data: ", combined_data.shape) + return combined_data + + +def get_and_save_markers_subset(n: int = 256, k: int = 50, mode: str = "train"): + data = load_anndata(mode=mode) + gex_indicator = (data.var["feature_types"] == "GEX").values + + first_modality = torch.tensor( + data.layers["counts"].toarray()[:, gex_indicator], + dtype=torch.float32, + ) + + markers_subset = select_top_n_and_random_k(first_modality, n=n, k=k) + torch.save(markers_subset, TRANSFORMER_DATA_PATH) + + +def main(): + get_and_save_markers_subset() + + +if __name__ == "__main__": + main() diff --git a/src/data/utils/data_utils.py b/src/data/utils/data_utils.py new file mode 100644 index 0000000..2398633 --- /dev/null +++ b/src/data/utils/data_utils.py @@ -0,0 +1,314 @@ +import os +from types import SimpleNamespace +from typing import Dict + +import anndata as ad +import scanpy as sc +import torch +import torch.utils +from torch.utils.data import DataLoader, TensorDataset +from utils.add_hierarchies import add_second_hierarchy +from utils.paths import ( + PREPROCESSED_ANNDATA_PATH, + PREPROCESSED_DATA_PATH, + RAW_ANNDATA_PATH, +) + + +class Modality: + GEX = "GEX" + ADT = "ADT" + + +def _preprocess_modality(_data: ad.AnnData, modality_type: Modality): + if modality_type == Modality.GEX: + sc.pp.log1p(_data) + sc.pp.scale(_data) + # sc.experimental.pp.normalize_pearson_residuals(_data) + + # TODO: consider the following operations + # if scipy.sparse.issparse(X): + # mean = X.mean(axis=0).A1 + # std = np.sqrt(X.power(2).mean(axis=0).A1 - np.square(mean)) + # X = (X.toarray() - mean) / std + # else: + # mean = X.mean(axis=0) + # std = np.sqrt(X.square().mean(axis=0) - np.square(mean)) + # X = (X - mean) / std + # X = X.clip(-10, 10) + + +def _preprocess_anndata(remove_batch_effect: bool, normalize: bool) -> ad.AnnData: + if normalize and PREPROCESSED_ANNDATA_PATH.exists(): + print("Loading preprocessed data...") + return ad.read_h5ad(PREPROCESSED_ANNDATA_PATH) + + _data = ad.read_h5ad(RAW_ANNDATA_PATH) + + if normalize: + gex_indicator = (_data.var["feature_types"] == "GEX").values + _preprocess_modality(_data.X[:, gex_indicator], Modality.GEX) + _preprocess_modality(_data.X[:, ~gex_indicator], Modality.ADT) + if remove_batch_effect: # Ensure data selection if needed + sc.external.pp.bbknn( + _data[:, gex_indicator], batch_key="Site", use_rep="GEX_X_pca" + ) + sc.external.pp.bbknn( + _data[:, ~gex_indicator], batch_key="Site", use_rep="ADT_X_pca" + ) + if not os.path.exists(PREPROCESSED_DATA_PATH): + os.makedirs(PREPROCESSED_DATA_PATH) + _data.write(filename=PREPROCESSED_ANNDATA_PATH) + return _data + + +def load_anndata( + mode: str, + plus_iid_holdout: bool = False, + normalize: bool = True, + remove_batch_effect: bool = True, + target_hierarchy_level: int = -1, + preload_subsample_frac: float = 1.0, +) -> ad.AnnData: + r""" + Load the full anndata object for the specified mode. + + Arguments: + mode : str + The mode to load the anndata object for. Must be one of ['train', 'test', 'train+test']. + plus_iid_holdout : bool + Whether to include the iid_holdout data in the anndata object. + + Returns: + data : anndata.AnnData + The full anndata object for the specified mode. + """ + assert mode in [ + "train", + "test", + "train+test", + ], f"mode must be one of ['train', 'test', 'train+test'], got {mode} instead." + assert isinstance( + plus_iid_holdout, bool + ), f"plus_iid_holdout must be a boolean, got {plus_iid_holdout} instead." + assert isinstance( + normalize, bool + ), f"normalize must be a boolean, got {normalize} instead." + assert isinstance( + remove_batch_effect, bool + ), f"remove_batch_effect must be a boolean, got {remove_batch_effect} instead." + assert isinstance( + target_hierarchy_level, int + ), f"target_hierarchy_level must be a int, got {target_hierarchy_level} instead." + assert target_hierarchy_level in [ + -1, + -2, + ], f"target_hierarchy_level must be in [-1, -2], got {target_hierarchy_level} instead." + filter_set = mode.split("+") # ['train'] or ['test'] or ['train', 'test'] + + if plus_iid_holdout: + filter_set.append("iid_holdout") + + # Read and normalize + _data = ad.read_h5ad(RAW_ANNDATA_PATH) + if normalize: + sc.pp.log1p(_data) + # _data = _preprocess_anndata(remove_batch_effect, normalize) + + if target_hierarchy_level == -2: + _data = add_second_hierarchy(_data) + + if preload_subsample_frac is not None: + print(f"Subsampling anndata with fraction {preload_subsample_frac}...") + sc.pp.subsample(_data, fraction=preload_subsample_frac) + + data = _data[_data.obs["is_train"].apply(lambda x: x in filter_set)] + + return data + + +def get_modality_data_from_anndata( + data: ad.AnnData, modality_cfg: SimpleNamespace +) -> torch.Tensor: + r""" + Get a TensorDataset object for the given modality. + + Arguments: + data : anndata.AnnData + The data to create a TensorDataset for. + modality_cfg : types.SimpleNamespace + The configuration for the modality. + + Returns: + modality_data : torch.Tensor + The TensorDataset object for the given modality. + """ + assert modality_cfg.modality_name in [ + Modality.GEX, + Modality.ADT, + ], f"modality must be one of [{Modality.GEX}, {Modality.ADT}], got {modality_cfg.modality_name} instead." + modality_indicator = ( + data.var["feature_types"] == modality_cfg.modality_name + ).values + assert modality_indicator.sum() >= modality_cfg.dim, ( + f"modality dim must be less than or equal to the number of {modality_cfg.modality_name} features, " + f"got {modality_cfg.dim} and {modality_indicator.sum()} instead." + ) + modality_data = torch.tensor( + data[:, modality_indicator][:, : modality_cfg.dim].X.toarray(), + dtype=torch.float32, + ) + if torch.isnan(modality_data).any(): + print( + f"{torch.isnan(modality_data).sum() / modality_data.numel() * 100}% of the values are nan in {modality_data} data." + ) + else: + print(f"There are no nan values in {modality_cfg.modality_name} data.") + return modality_data + + +def get_data_dict_from_anndata( + data: ad.AnnData, + modalities_cfg: SimpleNamespace, + include_class_labels: bool = False, + target_hierarchy_level: int = -1, +) -> Dict[str, torch.Tensor]: + r""" + Get a TensorDataset object for the given data. + + Arguments: + data : anndata.AnnData + The data to create a TensorDataset for. + + Returns: + data_dict : dict of torch.Tensor + """ + data_dict = { + cfg_name: get_modality_data_from_anndata(data, modality_cfg) + for cfg_name, modality_cfg in vars(modalities_cfg).items() + } + if include_class_labels: + if target_hierarchy_level == -1: + labels = torch.tensor( + data.obs["cell_type"].cat.codes.values, dtype=torch.long + ) + elif target_hierarchy_level == -2: + labels = torch.tensor( + data.obs["second_hierarchy"].cat.codes.values, dtype=torch.long + ) + + data_dict["labels"] = labels + return data_dict + + +def get_dataset_from_anndata( + data: ad.AnnData, + first_modality_dim: int = 13953, + second_modality_dim: int = 134, + include_class_labels: bool = True, + target_hierarchy_level: int = -1, +) -> TensorDataset: + r""" + Get a TensorDataset object for the given data. + + Arguments: + data : anndata.AnnData + The data to create a TensorDataset for. + first_modality_dim, second_modality_dim : int + Number of sizes of each modality. + include_class_labels : bool + Number of sizes of each modality. + target_hierarchy_level : int + What hierarchy to use when include_class_labels=True. + If equal -1, "cell_type" will be used, and if -2, "second_hierarchy". + + Returns: + dataset : torch.utils.data.TensorDataset + The TensorDataset object for the given data. + """ + modalities_cfg = SimpleNamespace( + gex=SimpleNamespace(modality_name=Modality.GEX, dim=first_modality_dim), + adt=SimpleNamespace(modality_name=Modality.ADT, dim=second_modality_dim), + ) + data_dict = get_data_dict_from_anndata( + data, modalities_cfg, include_class_labels, target_hierarchy_level + ) + data_list = [data_dict["gex"], data_dict["adt"]] + if include_class_labels: + data_list.append(data_dict["labels"]) + dataset = TensorDataset(*data_list) + return dataset + + +def get_dataloader_from_anndata( + data: ad.AnnData, + batch_size: int, + shuffle: bool = True, + first_modality_dim: int = 13953, + second_modality_dim: int = 134, + include_class_labels: bool = True, + target_hierarchy_level: int = -1, +) -> DataLoader: + r""" + Get a DataLoader object for the given data. + + Arguments: + data : anndata.AnnData + The data to create a DataLoader for. + batch_size : int + The batch size to use for the DataLoader. + + Returns: + dataloader : torch.utils.data.DataLoader + The DataLoader object for the given data starting with the GEX data. + """ + dataset = get_dataset_from_anndata( + data, + first_modality_dim, + second_modality_dim, + include_class_labels, + target_hierarchy_level, + ) + dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=shuffle) + return dataloader + + +def get_dataloader_dict_from_anndata( + data: ad.AnnData, + cfg: SimpleNamespace, + train: bool = True, +) -> Dict[str, DataLoader]: + r""" + Get a DataLoader object for the given data. + + Arguments: + data : anndata.AnnData + The data to create a DataLoader for. + batch_size : int + The batch size to use for the DataLoader. + + Returns: + dataloader : torch.utils.data.DataLoader + The DataLoader object for the given data. With the GEX data first. + """ + modalities_cfg = cfg.modalities + data_dict = get_data_dict_from_anndata( + data, modalities_cfg, cfg.include_class_labels, cfg.target_hierarchy_level + ) + + dataloader_dict = { + cfg_modality_name: DataLoader( + ( + TensorDataset(data_dict[cfg_modality_name], data_dict["labels"]) + if cfg.include_class_labels + else TensorDataset(data_dict[cfg_modality_name]) + ), + batch_size=cfg_modality.batch_size, + shuffle=False, # train, + ) + for cfg_modality_name, cfg_modality in vars(cfg.modalities).items() + } + return dataloader_dict + + +# def pearson_residuals_transform diff --git a/src/global_utils/__init__.py b/src/global_utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/global_utils/logger_utils.py b/src/global_utils/logger_utils.py new file mode 100644 index 0000000..c25a656 --- /dev/null +++ b/src/global_utils/logger_utils.py @@ -0,0 +1,55 @@ +from mrunner.helpers import client_helper +from pytorch_lightning.loggers import NeptuneLogger, TensorBoardLogger + +from src.global_utils.paths import LOGS_PATH + + +def get_loggers(config): + return [ + TensorBoardLogger(LOGS_PATH, name=config.model_name), + NeptuneLogger(run=client_helper.experiment_), + ] + + +from typing import Any, Dict + +import neptune.new as neptune +from mrunner.helpers import client_helper + +# def get_metrics_callback(config): +# if config.neptune_logger: +# metrics_callback = _log_with_neptune +# else: +# metrics_callback = _print_metrics + + +# def _print_metrics(stage, step, metrics, throttle=None): +# for k, v in metrics.items(): +# print(" %s:" % k, v) + + +# class NeptuneLogger: +# DEFAULT_STAGE_NAME = "logs" + +# def __init__(self) -> None: +# self.neptune_run: neptune.Run = client_helper.experiment_ + +# def log(self, stage: str, step: int, metric: str, value: Any): +# self._ensure_run() +# self.neptune_run[f"{stage}/{metric}"].log(value=value, step=step) +# print(" %s:" % metric, value) + +# def log_dict(self, stage: str, step: int, metrics: Dict[str, Any]): +# for k, v in metrics.items(): +# self.log(stage, step, k, v) + +# def _ensure_run(self): +# if self.neptune_run is None: +# self.neptune_run: neptune.Run = client_helper.experiment_ + + +# NEPTUNE_LOGGER = NeptuneLogger() + + +# def _log_with_neptune(stage: str, step: int, metrics: Dict[str, Any]): +# NEPTUNE_LOGGER.log_dict(stage, step, metrics) diff --git a/src/global_utils/parser.py b/src/global_utils/parser.py new file mode 100644 index 0000000..e9ad974 --- /dev/null +++ b/src/global_utils/parser.py @@ -0,0 +1,311 @@ +import argparse +from copy import deepcopy +from typing import Any, Callable + + +def combine_with_defaults(config, modalities_draft_config): + modalities_names = list(modalities_draft_config.keys()) + defaults = vars(_parse_args(modalities_names, [])) + res = deepcopy(defaults) + + for modalitiy_name, modality_config in modalities_draft_config.items(): + modality_dict = { + f"{modalitiy_name}_{key}": value for key, value in modality_config.items() + } + config = config | modality_dict + + for k, v in config.items(): + assert k in res.keys(), "{} not in default values".format(k) + res[k] = v + + res["modalities_names"] = modalities_names + return res + + +def _parse_args(modalities_names, args=None): + parser = _get_parser(modalities_names) + return parser.parse_args() + + +def _get_parser(modalities_names): + """Parses command line arguments.""" + parser = argparse.ArgumentParser() + _main_parser(parser) + _data_parser(parser) + _train_parser(parser) + _modality_parser(parser, modalities_names) + return parser + + +def _main_parser(parser): # Check if needs to return parser + parser.add_argument( + "--ex", type=str, default="/exp", help="Path to the experiment." + ) + parser.add_argument( + "--method", + choices=["omivae", "babel", "advae", "vae"], + help="Name of the method to use.", + ) + parser.add_argument( + "--mode", + type=str, + choices=["train", "test"], + default="train", + help="Mode to run the model.", + ) + parser.add_argument( + "--cv-seed", default=42, help="Seed used to make k folds for cross validation." + ) + parser.add_argument( + "--n-folds", default=5, type=int, help="Number of folds in cross validation." + ) + parser.add_argument( + "--preload-subsample-frac", + default=None, + type=float, + help="Fraction of the data to load. If None, use all data. Don't use subsample-frac with this option.", + ) + parser.add_argument( + "--subsample-frac", + default=None, + type=float, + help="Fraction of the data to use for cross validation. If None, use all data.", + ) + parser.add_argument( + "--retrain", default=True, help="Retrain a model using the whole dataset." + ) + parser.add_argument( + "--neptune-logger", default=False, help="If to log experiment to neptune." + ) + + +def _data_parser(parser): + parser.add_argument( + "--path-to-dataset", + help="Path to the dataset.", + ) + + parser.add_argument( + "--dataset-name", + choices=["cite-seq"], + help="Name of the dataset. Used for adding hierarchies and creating correct dataloader.", + ) + + parser.add_argument( + "--plus-iid-holdout", + action="store_true", + help="Whether to include the iid_holdout data in the anndata object.", + ) + parser.add_argument( + "--data_normalization", + type=str, + choices=["log1p", "standardize", "pearson_residuals", None], + default="standardize", + help="Normalization method for the data.", + ) + parser.add_argument( + "--remove_batch_effect", + type=bool, + default=True, + help="Whether to remove batch effects.", + ) + parser.add_argument( + "--target_hierarchy_level", + type=int, + default=-1, + help="Target hierarchy level for classification.", + ) + + +def _train_parser(parser): + parser.add_argument("--lr", default=1e-3, type=float, help="Learning rate.") + parser.add_argument("--batch-size", default=64, type=int, help="Batch size.") + parser.add_argument("--model-name", type=str, help="Name of a current model.") + parser.add_argument( + "--log-every-n-steps", + default=2, + type=int, + help="How often do logging during training.", + ) + parser.add_argument( + "--max-epochs", default=10, type=int, help="Number of training epochs." + ) + parser.add_argument( + "--early-stopping", default=False, type=bool, help="If to use EarlyStopping." + ) + parser.add_argument( # prevoisly min_delta + "--early-stopping-delta", + default=0.001, + type=float, + help="Delta used in EarlyStopping.", + ) + parser.add_argument( # previously patience + "--early-stopping-patience", + default=2, + type=int, + help="Patience for EarlyStopping.", + ) + parser.add_argument( + f"--hidden_dim", + type=int, + default=128, + help=f"Hidden dimension .", + ) + parser.add_argument( + f"--encoder_hidden_dim", + type=int, + default=128, + help=f"Encoder hidden dimension.", + ) + parser.add_argument( + f"--encoder_out_dim", + type=int, + default=32, + help=f"Encoder output dimension.", + ) + parser.add_argument( + f"--latent_dim", + type=int, + default=16, + help=f"Latent dimension.", + ) + parser.add_argument( + f"--decoder_hidden_dim", + type=int, + default=128, + help=f"Decoder hidden dimension.", + ) + parser.add_argument( + f"--batch_norm", + type=bool, + default=False, + help=f"Whether to use batch normalization.", + ) + parser.add_argument( + f"--dropout_rate", + type=float, + default=0.1, + help=f"Dropout rate.", + ) + parser.add_argument( + f"--recon_loss_coef", + type=float, + default=1, + help=f"Reconstruction loss coefficient.", + ) + parser.add_argument( + f"--kld_loss_coef", + type=float, + default=0.1, + help=f"KLD loss coefficient.", + ) + + +def _test_parser(parser): + parser.add_argument( # previously patience + "--model-path", type=str, help="Path of the model." + ) + + +def _modality_parser(parser, modalities_names): + for modality_name in modalities_names: + prefix = f"{modality_name}_" + parser.add_argument( + f"--{prefix}modality_name", + type=str, + default=modality_name.upper(), + help=f"Modality name for {modality_name.upper()}.", + ) + parser.add_argument( + f"--{prefix}dim", + type=int, + default=13953 if modality_name == "gex" else 134, + help=f"Dimension of the {modality_name.upper()} modality.", + ) + # parser.add_argument( + # f"--{prefix}hidden_dim", + # type=int, + # default=128, + # help=f"Hidden dimension for the {modality_name.upper()} modality.", + # ) + # parser.add_argument( + # f"--{prefix}encoder_hidden_dim", + # type=int, + # default=128, + # help=f"Encoder hidden dimension for the {modality_name.upper()} modality.", + # ) + # parser.add_argument( + # f"--{prefix}encoder_out_dim", + # type=int, + # default=32, + # help=f"Encoder output dimension for the {modality_name.upper()} modality.", + # ) + # parser.add_argument( + # f"--{prefix}latent_dim", + # type=int, + # default=16, + # help=f"Latent dimension for the {modality_name.upper()} modality.", + # ) + # parser.add_argument( + # f"--{prefix}decoder_hidden_dim", + # type=int, + # default=128, + # help=f"Decoder hidden dimension for the {modality_name.upper()} modality.", + # ) + # parser.add_argument( + # f"--{prefix}batch_norm", + # type=bool, + # default=False, + # help=f"Whether to use batch normalization for the {modality_name.upper()} modality.", + # ) + # parser.add_argument( + # f"--{prefix}dropout_rate", + # type=float, + # default=0.1, + # help=f"Dropout rate for the {modality_name.upper()} modality.", + # ) + # parser.add_argument( + # f"--{prefix}recon_loss_coef", + # type=float, + # default=1, + # help=f"Reconstruction loss coefficient for the {modality_name.upper()} modality.", + # ) + # parser.add_argument( + # f"--{prefix}kld_loss_coef", + # type=float, + # default=0.1, + # help=f"KLD loss coefficient for the {modality_name.upper()} modality.", + # ) + + +# Babel + +# Transformer + + +def apply_to_all_modalities(config: dict, field_name: str, func: Callable) -> Any: + """Applies a function to values from all modalities in the config. + + Args: + config: A dictionary containing configuration data. + field_name: The name of the field to extract from each modality. + func: The function to apply to the extracted values. + + Returns: + The result of applying the function to the list of extracted values. + + Raises: + TypeError: If the function cannot be applied to the extracted data types. + """ + config_dict = vars(config) + values = [ + config_dict[f"{modality_name}_{field_name}"] + for modality_name in config.modalities_names + ] + try: + return func(values) + except TypeError: + # Handle the case where func cannot handle the data types + raise TypeError( + f"Function '{func.__name__}' cannot be applied to the extracted data types." + ) diff --git a/src/utils/paths.py b/src/global_utils/paths.py similarity index 99% rename from src/utils/paths.py rename to src/global_utils/paths.py index 9236036..8cc9747 100644 --- a/src/utils/paths.py +++ b/src/global_utils/paths.py @@ -1,6 +1,5 @@ from pathlib import Path - # Data paths DATA_PATH: Path = Path(__file__).parent.parent.parent / "data" RAW_DATA_PATH: Path = DATA_PATH / "raw" diff --git a/src/global_utils/train_and_validate_utils.py b/src/global_utils/train_and_validate_utils.py new file mode 100644 index 0000000..074e091 --- /dev/null +++ b/src/global_utils/train_and_validate_utils.py @@ -0,0 +1,130 @@ +import datetime +import os +import random +from typing import Generator + +import anndata as ad +import numpy as np +import pandas as pd +import torch +import yaml +from sklearn.model_selection import KFold + +from src.global_utils.paths import RESULTS_PATH +from src.models.babel import BabelModel +from src.models.ModelBase import ModelBase +from src.models.omivae import OmiModel +from src.models.vae import VAE + +# from utils.metrics import calculate_metrics, latent_metrics + + +def set_random_seed_all(seed=0): + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + # torch.cuda.manual_seed(seed) + + +def create_model(config) -> ModelBase: + if config.method == "omivae": + model = OmiModel(config) + return model + elif config.method == "babel": + model = BabelModel(config) + return model + elif config.method == "advae": + raise NotImplementedError(f"{config.method} method not implemented.") + elif config.method == "vae": + return VAE(config) + else: + raise NotImplementedError(f"{config.method} method not implemented.") + + +def create_results_dir(args): + """Creates directories for saving results.""" + current_time = datetime.datetime.now() + formatted_time = current_time.strftime("%Y-%m-%d_%H-%M-%S") + + results_path = ( + RESULTS_PATH + / args.method + / f"{args.config}_{formatted_time}_{args.cv_seed}_seeds_{args.n_folds}_folds" + ) + + os.makedirs(results_path, exist_ok=True) # Create directories if necessary + + return results_path + + +def save_model_and_latent(model, latent_representation, results_path): + """Saves the configuration, model, and latent representation.""" + # Save config + with open(results_path / "config.yaml", "w") as file: + yaml.dump(model.config.__dict__, file) + print(f"Config saved to: {results_path / 'config.yaml'}") + + # Save model + saved_model_path = model.save(str(results_path / "saved_model")) + print(f"Model saved to: {saved_model_path}") + + # Save latent + if isinstance(latent_representation, dict): # BABEL model + for modality_name, latent in latent_representation.items(): + torch.save(latent, str(results_path / f"latent_train_{modality_name}")) + else: + torch.save(latent_representation, str(results_path / "latent")) + + +class CrossValidator: + def __init__(self, model, random_state=41, n_folds=5, subsample_frac=None): + self.model = model + self.random_state = random_state + self.n_folds = n_folds + self.subsample_frac = subsample_frac + + def cross_validate_and_save(self, data, test_data, results_path): + cv_metrics = self.cross_validate(data, test_data) + print("Saving cross validation metrics to CSV...") + cv_metrics.to_csv(str(results_path / "cv_metrics")) + + def cross_validate(self, data, test_data) -> pd.DataFrame: + torch.manual_seed(self.random_state) + cv_results = [] + for i, (train_data, val_data) in enumerate(self._k_folds(data)): + self.model.fit(train_data) + fold_metrics = self._evaluate(self.model, val_data) + cv_results.append(fold_metrics) + + test_data_results = self._evaluate(self.model, test_data) + + return pd.DataFrame.from_dict( + {"fold_wise": cv_results, "test_data": test_data_results} + ) + + def _evaluate(self, model, data): + print(f"Evaluating model on fold...") + return None # Replace with actual metrics calculation + + def _k_folds(self, data: ad.AnnData): + r""" + Generate indices for k-folds cross validation. + + Arguments: + data (anndata.AnnData): The data to perform cross validation on. + Yields: + Tuple[anndata.AnnData, anndata.AnnData]: The training and test data for each fold. + """ + obs_names = data.obs_names.values + if self.subsample_frac is not None: + np.random.seed(self.random_state) + obs_names = np.random.choice( + obs_names, size=int(self.subsample_frac * len(obs_names)), replace=False + ) + kfold = KFold( + n_splits=self.n_folds, shuffle=True, random_state=self.random_state + ) + split = kfold.split(obs_names) + + for train_obs_names, val_obs_names in split: + yield (data[train_obs_names], data[val_obs_names]) diff --git a/src/main.py b/src/main.py new file mode 100644 index 0000000..22421f0 --- /dev/null +++ b/src/main.py @@ -0,0 +1,17 @@ +import numpy as np +import torch + +from src.train import train +from src.validate import validate + + +def main(args): + torch.manual_seed(100) + np.random.seed(100) + + if args.mode == "train": + train(args) + elif args.mode == "test": + validate(args) + else: + raise NotImplementedError(f"Mode {args.mode} not implemented yet.") diff --git a/src/metrics/__init__.py b/src/metrics/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/metrics/metrics.py b/src/metrics/metrics.py new file mode 100644 index 0000000..fb50d3f --- /dev/null +++ b/src/metrics/metrics.py @@ -0,0 +1,246 @@ +import argparse +import os +from argparse import Namespace +from itertools import cycle + +import matplotlib.pyplot as plt +import numpy as np +import pytorch_lightning as pl +import seaborn as sns +import sklearn +import torch +from pytorch_lightning import LightningModule +from sklearn.decomposition import PCA +from sklearn.metrics import ( + adjusted_rand_score, + auc, + normalized_mutual_info_score, + roc_curve, + silhouette_score, +) +from sklearn.preprocessing import label_binarize +from torch import nn +from utils.paths import CONFIG_PATH, RESULTS_PATH + +from models.building_blocks import Block +from src.data.dataloader_todo import load_anndata +from src.global_utils.paths import RESULTS_PATH +from src.global_utils.train_and_validate_utils import create_model +from src.models.building_blocks import Block + + +class ClassificationModel(pl.LightningModule): + def __init__(self, latent_dim, num_classes, do_batch_norm=False): + super().__init__() + self.classification_head = Block( + input_size=latent_dim, + output_size=num_classes, + hidden_size=num_classes * 2, + batch_norm=do_batch_norm, + ) + self.loss = nn.CrossEntropyLoss() # Adjust + + def forward(self, z): + return self.classification_head(z) + + def training_step(self, batch, batch_idx): + x, y = batch + y_hat = self.forward(x) + loss = self.loss(y_hat, y) + self.log( + "train_loss", loss, on_step=True, on_epoch=True, prog_bar=True, logger=True + ) + return loss + + def validation_step(self, batch, batch_idx): + x, y = batch + y_hat = self.forward(x) + loss = self.loss(y_hat, y) + self.log( + "val_loss", loss, on_step=False, on_epoch=True, prog_bar=True, logger=True + ) + # Calculate metrics here + # preds = F.softmax(y_hat, dim=1) # Adjust for other activation functions + # self.log("val_accuracy", accuracy, on_step=False, on_epoch=True, prog_bar=True, logger=True) + return loss + + def predict(self, z): + y_hat = self(z) + return y_hat + + def configure_optimizers(self): + # Define optimizer here + optimizer = torch.optim.Adam( + self.parameters(), lr=0.001 + ) # Adjust learning rate + return optimizer + + +from torch.utils.data import DataLoader, TensorDataset + + +def train_classification_head(model, data): + print("train_classification_head...") + latent_representation = model.predict(data) + print(latent_representation.shape) + latent_dim = latent_representation.shape[1] + num_classes = len(data.obs["cell_type"].cat.categories) + print("Number of classes is:", num_classes) + print("Init classification head...") + classification_head = ClassificationModel(latent_dim, num_classes) + print("Train classification head...") + # Create trainer here + trainer = pl.Trainer(max_epochs=1) # Adjust epochs as needed + print(torch.tensor(data.obs["cell_type"].cat.codes.values, dtype=torch.long)) + curr_dataset = TensorDataset( + latent_representation, + torch.tensor(data.obs["cell_type"].cat.codes.values, dtype=torch.long), + ) + dataloader = DataLoader(curr_dataset, batch_size=128, shuffle=False) + trainer.fit(classification_head, dataloader) # Pass data as a PyTorch DataLoader + return classification_head + + +def get_predictions_gt_classes(model, classification_head, data): + print("Predict latent") + test_latent_representation = model.predict(data) + print("Predict classification head") + prediction = classification_head.predict(test_latent_representation) + print("Finished prediction") + prediction_probability = torch.softmax(prediction, dim=1) + ground_truth = data.obs["cell_type"].cat.codes.values + classes = data.obs["cell_type"].cat.categories + return ( + prediction.detach().numpy(), + prediction_probability, + ground_truth, + classes, + test_latent_representation.detach().numpy(), + ) + + +def evaluate_clustering(y_true, y_pred, data): + # silhouette = silhouette_score(data, y_pred) # figure out what data is + # print("Silhouette finished") + # # ari = adjusted_rand_score(y_true, y_pred) + # # print("Ari finished") + # # nmi = normalized_mutual_info_score(y_true, y_pred) + # # print("Normalized MI finished") + # metrics = { + # "silhouette_score": silhouette, + # # "adjusted_rand_index": ari, + # # "normalized_mutual_info": nmi, + # } + # print(metrics) + plot_clustering(data, y_pred) + # return metrics + + +def get_metrics(model, classification_head, test_data): + ( + prediction, + prediction_probability, + ground_truth, + classes, + test_latent_representation, + ) = get_predictions_gt_classes(model, classification_head, test_data) + metrics = evaluate_clustering(ground_truth, prediction, test_data) + + metrics["f1_score_per_cell_type"] = sklearn.metrics.f1_score( + ground_truth, prediction, labels=classes, average=None + ) + metrics["f1_score"] = sklearn.metrics.f1_score( + ground_truth, prediction, labels=classes, average="macro" + ) + metrics["accuracy"] = sklearn.metrics.accuracy_score(ground_truth, prediction) + metrics["average_precision_per_cell_type"] = ( + sklearn.metrics.average_precision_score( + ground_truth, prediction_probability, average=None + ) + ) + metrics["roc_auc_per_cell_type"] = sklearn.metrics.roc_auc_score( + ground_truth, + prediction_probability, + multi_class="ovr", + average=None, + labels=classes, + ) + plot_roc_auc(ground_truth, prediction_probability, len(classes)) + metrics["confusion_matrix"] = sklearn.metrics.confusion_matrix( + ground_truth, prediction, labels=classes + ) + return metrics + + +def calculate_metrics(model, train_data, test_data): + classification_head = train_classification_head(model, train_data) + print("Finished training classification head.") + metrics = get_metrics(model, classification_head, test_data) + return metrics + + +def latent_metrics(model, test_data): + latent_representation = model.predict(test_data) + ground_truth = test_data.obs["cell_type"] + # todo: umap + clustering + + +def plot_roc_auc(y_true, y_pred, num_classes): # what to do with this? + y_true_bin = label_binarize(y_true, classes=[i for i in range(num_classes)]) + fpr = dict() + tpr = dict() + roc_auc = dict() + for i in range(num_classes): + fpr[i], tpr[i], _ = roc_curve(y_true_bin[:, i], y_pred[:, i]) + roc_auc[i] = auc(fpr[i], tpr[i]) + + plt.figure() + colors = cycle(["aqua", "darkorange", "cornflowerblue"]) + for i, color in zip(range(num_classes), colors): + plt.plot( + fpr[i], + tpr[i], + color=color, + lw=2, + label="ROC curve of class {0} (area = {1:0.2f})" "".format(i, roc_auc[i]), + ) + + plt.plot([0, 1], [0, 1], "k--", lw=2) + plt.xlim([0.0, 1.0]) + plt.ylim([0.0, 1.05]) + plt.xlabel("False Positive Rate") + plt.ylabel("True Positive Rate") + plt.title("Receiver Operating Characteristic") + plt.legend(loc="lower right") + plt.show() + + +def plot_clustering(data, y_pred): + import scanpy as sc + from sklearn.decomposition import PCA + + # Extract the latent embedding + latent_embedding = GEX_anndata.obsm["latent_embedding"] + + # Perform PCA on the latent embedding + pca = PCA(n_components=2) + latent_pca = pca.fit_transform(latent_embedding) + + # Store the PCA results back in the AnnData object + GEX_anndata.obsm["X_pca_latent"] = latent_pca + GEX_anndata.uns["pca_latent_variance_ratio"] = pca.explained_variance_ratio_ + + # Create a new AnnData object for visualization purposes + pca_gex_anndata = sc.AnnData(X=latent_pca) + pca_gex_anndata.obs = GEX_anndata.obs + pca_gex_anndata.var_names = [f"PC{i+1}" for i in range(latent_pca.shape[1])] + + # Visualize the PCA results + sc.pl.scatter( + pca_gex_anndata, x="PC1", y="PC2", color="level1", title="GEX latent by PCA" + ) + + # plt.figure(figsize=(10, 6)) + # sns.scatterplot(x=data[:, 0], y=data[:, 1], hue=y_pred, palette="viridis") + # plt.title("Clustering Results") + # plt.show() diff --git a/src/models/babel.py b/src/models/babel.py index 2800994..4a4aac9 100644 --- a/src/models/babel.py +++ b/src/models/babel.py @@ -9,16 +9,16 @@ import torch.optim as optim from anndata import AnnData from pytorch_lightning.utilities.combined_loader import CombinedLoader -from sklearn.metrics import balanced_accuracy_score from torch import Tensor from models.ModelBase import ModelBase +from src.global_utils.paths import LOGS_PATH from src.models.components.blocks import Decoder, Encoder +from src.models.ModelBase import ModelBase from src.utils.old.data_utils import ( get_dataloader_dict_from_anndata, get_dataloader_from_anndata, ) -from utils.paths import LOGS_PATH class SingleModalityVAE(nn.Module): diff --git a/src/models/building_blocks.py b/src/models/building_blocks.py new file mode 100644 index 0000000..f6d813b --- /dev/null +++ b/src/models/building_blocks.py @@ -0,0 +1,39 @@ +import torch +import torch.nn as nn + + +class Block(nn.Module): + def __init__(self, input_size, output_size, hidden_size, batch_norm=False): + super(Block, self).__init__() + self.block = nn.Sequential( + nn.Linear(input_size, hidden_size), + nn.BatchNorm1d(hidden_size) if batch_norm else nn.Identity(), + nn.SiLU(), + nn.Linear(hidden_size, output_size), + ) + + def forward(self, x): + return self.block(x) + + +class ResidualBlock(nn.Module): + def __init__(self, input_size, hidden_size, batch_norm=False): + super(ResidualBlock, self).__init__() + self.block = nn.Sequential( + Block(input_size, input_size, hidden_size, batch_norm), nn.SiLU() + ) + + def forward(self, x): + return x + self.block(x) + + +class ShortcutBlock(nn.Module): + def __init__(self, input_size, output_size, hidden_size, batch_norm=False): + super(ShortcutBlock, self).__init__() + self.block = nn.Sequential( + Block(input_size, output_size, hidden_size, batch_norm), nn.SiLU() + ) + self.shortcut = nn.Linear(input_size, output_size) + + def forward(self, x): + return self.shortcut(x) + self.block(x) diff --git a/src/models/components/omivae.py b/src/models/components/omivae.py index 2f58aa5..e6b4a66 100644 --- a/src/models/components/omivae.py +++ b/src/models/components/omivae.py @@ -1,5 +1,5 @@ from argparse import Namespace -from typing import Dict, Tuple +from typing import Tuple import pytorch_lightning as pl import torch @@ -30,12 +30,22 @@ def forward(self, x): return x_hat, z def training_step(self, batch, batch_idx): - x1, x2 = batch + x1, x2, _ = batch + x = torch.cat((x1, x2), dim=-1) + z = self.encoder(x) + x_hat = self.decoder(z) + loss = F.mse_loss(x_hat, x) + self.log("train/loss", loss, on_step=True, on_epoch=True, prog_bar=True) + return loss + + def validation_step(self, batch, batch_idx): + print("validation") + x1, x2, _ = batch x = torch.cat((x1, x2), dim=-1) z = self.encoder(x) x_hat = self.decoder(z) loss = F.mse_loss(x_hat, x) - self.log("Train loss", loss, on_epoch=True, prog_bar=True) + self.log("val/loss", loss, on_step=True, on_epoch=True, prog_bar=True) return loss def predict_step(self, batch: Tensor) -> Tensor: @@ -221,25 +231,26 @@ def configure_optimizers(self): "OmiGMPriorProbabilisticAE": OmiGMPriorProbabilisticAE, } +from src.global_utils.logger_utils import get_loggers + class OmiModel(ModelBase): def __init__(self, cfg): super(OmiModel, self).__init__() self.cfg = cfg - self.model = _OMIVAE_IMPLEMENTATIONS[cfg.omivae_implementation](cfg) + self.model = _OMIVAE_IMPLEMENTATIONS[cfg.model_name](cfg) self.trainer = pl.Trainer( max_epochs=cfg.max_epochs, - logger=pl.loggers.TensorBoardLogger(LOGS_PATH, name=cfg.model_name), + logger=get_loggers(cfg), + val_check_interval=1.0, ) def fit(self, train_anndata: AnnData, val_anndata: AnnData | None = None): train_loader = get_dataloader_from_anndata( data=train_anndata, batch_size=self.cfg.batch_size, + config=self.cfg, shuffle=True, - first_modality_dim=self.cfg.first_modality_dim, - second_modality_dim=self.cfg.second_modality_dim, - include_class_labels=self.cfg.include_class_labels, target_hierarchy_level=self.cfg.target_hierarchy_level, ) val_loader = ( @@ -247,9 +258,7 @@ def fit(self, train_anndata: AnnData, val_anndata: AnnData | None = None): data=val_anndata, batch_size=self.cfg.batch_size, shuffle=False, - first_modality_dim=self.cfg.first_modality_dim, - second_modality_dim=self.cfg.second_modality_dim, - include_class_labels=self.cfg.include_class_labels, + config=self.cfg, target_hierarchy_level=self.cfg.target_hierarchy_level, ) if val_anndata is not None diff --git a/src/models/components/vae_old.py b/src/models/components/vae_old.py index e4406d8..3b50be1 100644 --- a/src/models/components/vae_old.py +++ b/src/models/components/vae_old.py @@ -10,16 +10,14 @@ from torch import Tensor from tqdm import tqdm -from models.building_blocks import Block, ShortcutBlock -from models.ModelBase import ModelBase -from utils.data_utils import get_dataloader_dict_from_anndata -from utils.paths import LOGS_PATH +from src.data.dataloader_todo import get_dataloader_dict_from_anndata +from src.models.building_blocks import Block, ShortcutBlock +from src.models.ModelBase import ModelBase class SingleModalityVAE(nn.Module): def __init__(self, cfg_name: str, modality_cfg: Namespace): super(SingleModalityVAE, self).__init__() - self.assert_modality_cfg(cfg_name, modality_cfg) self.cfg_name = cfg_name self.modality_cfg = modality_cfg @@ -113,45 +111,13 @@ def predict(self, batch: Tensor) -> Tensor: z = self.reparameterize(mu, logvar) return z - def assert_modality_cfg(self, cfg_name: str, modality_cfg: Namespace) -> None: - print(modality_cfg) - print(modality_cfg.dim) - assert hasattr(modality_cfg, "modality_name"), AttributeError( - f'{cfg_name} modality cfg does not have the attribute "modality_name"' - ) - assert hasattr(modality_cfg, "dim"), AttributeError( - f'{cfg_name} modality cfg does not have the attribute "dim"' - ) - assert hasattr(modality_cfg, "embedding_dim"), AttributeError( - f'{cfg_name} modality cfg does not have the attribute "embedding_dim"' - ) - assert hasattr(modality_cfg, "hidden_dim"), AttributeError( - f'{cfg_name} modality cfg does not have the attribute "hidden_dim"' - ) - assert hasattr(modality_cfg, "latent_dim"), AttributeError( - f'{cfg_name} modality cfg does not have the attribute "latent_dim"' - ) - assert hasattr(modality_cfg, "latent_hidden_dim"), AttributeError( - f'{cfg_name} modality cfg does not have the attribute "latent_hidden_dim"' - ) - assert hasattr(modality_cfg, "batch_norm"), AttributeError( - f'{cfg_name} modality cfg does not have the attribute "batch_norm"' - ) - assert hasattr(modality_cfg, "kld_weight"), AttributeError( - f'{cfg_name} modality cfg does not have the attribute "kld_weight"' - ) - assert hasattr(modality_cfg, "batch_size"), AttributeError( - f'{cfg_name} modality does not have the attribute "batch_size"' - ) - assert hasattr(modality_cfg, "lr"), AttributeError( - f'{cfg_name} modality does not have the attribute "lr"' - ) + +from src.global_utils.logger_utils import get_loggers class VAE(pl.LightningModule, ModelBase): def __init__(self, cfg: Namespace): super(VAE, self).__init__() - self.assert_cfg(cfg) self.cfg = cfg self.automatic_optimization = False self.model = nn.ModuleDict( @@ -164,7 +130,7 @@ def __init__(self, cfg: Namespace): self.trainer = pl.Trainer( max_epochs=cfg.max_epochs, log_every_n_steps=cfg.log_every_n_steps, - logger=pl.loggers.TensorBoardLogger(LOGS_PATH, name=cfg.model_name), + logger=get_loggers(cfg), callbacks=( [ pl.callbacks.EarlyStopping( @@ -268,61 +234,3 @@ def configure_optimizers(self): for model in self.model.values() ] return optimizers - - @staticmethod - def assert_cfg_general(cfg: Namespace) -> None: - assert hasattr(cfg, "model_name"), AttributeError( - 'cfg does not have the attribute "model_name"' - ) - assert hasattr(cfg, "modalities"), AttributeError( - 'cfg does not have the attribute "modalities"' - ) - assert hasattr(cfg, "max_epochs"), AttributeError( - 'cfg does not have the attribute "max_epochs"' - ) - assert hasattr(cfg, "log_every_n_steps"), AttributeError( - 'cfg does not have the attribute "log_every_n_steps"' - ) - assert hasattr(cfg, "early_stopping"), AttributeError( - 'cfg does not have the attribute "early_stopping"' - ) - assert hasattr(cfg, "min_delta"), AttributeError( - 'cfg does not have the attribute "min_delta"' - ) - assert hasattr(cfg, "patience"), AttributeError( - 'cfg does not have the attribute "patience"' - ) - - def assert_cfg(self, cfg: Namespace) -> None: - self.assert_cfg_general(cfg) - for cfg_name, modality_cfg in vars(cfg.modalities).items(): - assert hasattr(modality_cfg, "modality_name"), AttributeError( - f'{cfg_name} modality cfg does not have the attribute "modality_name"' - ) - assert hasattr(modality_cfg, "dim"), AttributeError( - f'{cfg_name} modality cfg does not have the attribute "dim"' - ) - assert hasattr(modality_cfg, "embedding_dim"), AttributeError( - f'{cfg_name} modality cfg does not have the attribute "embedding_dim"' - ) - assert hasattr(modality_cfg, "hidden_dim"), AttributeError( - f'{cfg_name} modality cfg does not have the attribute "hidden_dim"' - ) - assert hasattr(modality_cfg, "latent_dim"), AttributeError( - f'{cfg_name} modality cfg does not have the attribute "latent_dim"' - ) - assert hasattr(modality_cfg, "latent_hidden_dim"), AttributeError( - f'{cfg_name} modality cfg does not have the attribute "latent_hidden_dim"' - ) - assert hasattr(modality_cfg, "batch_norm"), AttributeError( - f'{cfg_name} modality cfg does not have the attribute "batch_norm"' - ) - assert hasattr(modality_cfg, "kld_weight"), AttributeError( - f'{cfg_name} modality cfg does not have the attribute "kld_weight"' - ) - assert hasattr(modality_cfg, "batch_size"), AttributeError( - f'{cfg_name} modality does not have the attribute "batch_size"' - ) - assert hasattr(modality_cfg, "lr"), AttributeError( - f'{cfg_name} modality does not have the attribute "lr"' - ) diff --git a/src/models/utils/loss_utils.py b/src/models/utils/loss_utils.py new file mode 100644 index 0000000..935f25b --- /dev/null +++ b/src/models/utils/loss_utils.py @@ -0,0 +1,100 @@ +from typing import Tuple + +import torch +import torch.optim as optim +from torch import Tensor +from tqdm import tqdm + + +def kld_stdgaussian(mu: Tensor, logvar: Tensor) -> Tensor: + return -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp()) + + +def gex_reconstruction_loss(x_hat: Tensor, x: Tensor) -> Tensor: + return torch.nn.functional.mse_loss(x_hat, x) + + +def adt_reconstruction_loss(x_hat: Tensor, x: Tensor) -> Tensor: + return torch.nn.functional.mse_loss(x_hat, x) + + +def estimate_initial_negative_binomial_params(counts: Tensor) -> Tuple[Tensor]: + """ + Estimate the initial dispersion parameter (alpha) for each gene using a moment-based approach. + + Parameters: + counts (Tensor): The count matrix with genes as rows and cells as columns. + + Returns: + Tuple[Tensor]: A tuple of initial mean counts and dispersions for each gene. + """ + mean_counts = counts.mean(dim=1) + var_counts = counts.var(dim=1) + dispersions = (var_counts - mean_counts) / (mean_counts**2) + dispersions = dispersions.clamp(min=1e-10) # Ensure non-negative dispersions + return mean_counts, dispersions + + +def negative_binomial_log_likelihood( + x: Tensor, mu: Tensor, theta: Tensor, eps: float = 1e-10 +) -> Tensor: + r""" + Compute the negative binomial log likelihood for the given data. + + Arguments: + x : torch.Tensor + The data. + mu : torch.Tensor + The mean of the data. + theta : torch.Tensor + The dispersion parameter. + + Returns: + nll : torch.Tensor + The negative binomial log likelihood. + """ + assert eps > 0, f"eps must be positive, got {eps} instead." + + return ( + -theta * (torch.log(theta + eps) - torch.log(theta + mu + eps)) + - x * (torch.log(theta + eps) - torch.log(theta + mu + eps)) + - torch.lgamma(x + theta + eps).sum() + + torch.lgamma(x + 1).sum() + + torch.lgamma(theta + eps).sum() + ) + + +def estimate_negative_binomial_parameters( + counts: Tensor, eps: float = 1e-10 +) -> Tuple[Tensor]: + """ + Estimate the mean and dispersion parameters for each gene using the negative binomial log likelihood. + + Parameters: + counts (Tensor): The count matrix with cells as rows and featuers as columns. + mu (Tensor): The mean of the data. + theta (Tensor): The initial dispersion parameter. + eps (float): A small value to ensure numerical stability. + + Returns: + Tuple[Tensor]: A tuple of mean counts and dispersions for each gene. + """ + means, dispersions = estimate_initial_negative_binomial_params(counts) + n_features = counts.shape[1] + progress_bar = tqdm(range(n_features), desc="Estimating NB parameters") + for i in progress_bar: + mean = means[i].clone() + mean.requires_grad_(True) + dispersion = dispersions[i].clone() + dispersion.requires_grad_(True) + optimizer = optim.Adam([mean, dispersion], lr=0.01) + for _ in range(100): + optimizer.zero_grad() + nll = negative_binomial_log_likelihood(counts[:, i], mean, dispersion, eps) + nll.backward() + optimizer.step() + means[i] = mean.item() + dispersions[i] = dispersion.item() + progress_bar.set_postfix_str( + f"Feature {i + 1}/{n_features} - NLL: {nll.item():.2f}" + ) diff --git a/src/train.py b/src/train.py index c19a133..32fd5c3 100644 --- a/src/train.py +++ b/src/train.py @@ -1,126 +1,46 @@ -import argparse -import datetime -import json -import os -from types import SimpleNamespace +from src.data.dataloader_todo import load_anndata +from src.global_utils.train_and_validate_utils import ( + CrossValidator, + create_model, + create_results_dir, + save_model_and_latent, +) +from src.utils.old.data_utils import load_anndata +from src.utils.paths import CONFIG_PATH, RESULTS_PATH -import anndata as ad -import numpy as np -import pandas as pd -import torch -import yaml -from models.babel import BabelModel -from models.ModelBase import ModelBase -from src.models.components import VAE -from src.models.components.omivae import OmiModel -from utils.data_utils import load_anndata -from utils.paths import CONFIG_PATH, RESULTS_PATH - - -def main(): - parser = argparse.ArgumentParser(description="Validate model") - parser.add_argument( - "--method", - choices=["omivae", "babel", "advae", "vae"], - help="Name of the method to use.", - ) - parser.add_argument( - "--mode", - choices=["train", "test", "train+test"], - default="train", - help="Mode to load the data for. Must be one of ['train', 'test', 'train+test'].", - ) - parser.add_argument( - "--plus-iid-holdout", - action="store_true", - help="Whether to include the iid_holdout data in the anndata object.", - ) - parser.add_argument( - "--config", - default="standard", - help="Name of a configuration in src/config/{method}.yaml.", - ) - parser.add_argument( - "--preload-subsample-frac", - default=None, - type=float, - help="Fraction of the data to load. If None, use all data. Don't use subsample-frac with this option.", - ) - - args = parser.parse_args() - - config = load_config(args) - model = create_model(args, config) +def train(config): + model = create_model(config) train_data = load_anndata( mode="train", - normalize=config.normalize, + normalize=config.data_normalization, remove_batch_effect=config.remove_batch_effect, target_hierarchy_level=config.target_hierarchy_level, - preload_subsample_frac=args.preload_subsample_frac, + preload_subsample_frac=config.preload_subsample_frac, + ) + val_data = load_anndata( + mode="test", + normalize=config.data_normalization, + remove_batch_effect=config.remove_batch_effect, + target_hierarchy_level=config.target_hierarchy_level, + preload_subsample_frac=config.preload_subsample_frac, ) model.fit(train_data) - # Save results - current_time = datetime.datetime.now() - formatted_time = current_time.strftime("%Y-%m-%d_%H-%M-%S") - - # Create directories if they don't exist - if not os.path.exists(RESULTS_PATH): - os.mkdir(RESULTS_PATH) - - results_path = RESULTS_PATH / args.method - if not os.path.exists(results_path): - os.makedirs(results_path) - - results_path = RESULTS_PATH / args.method / f"{args.config}_{formatted_time}" - if not os.path.exists(results_path): - os.mkdir(results_path) - - # Save config - with open(results_path / "config.yaml", "w") as file: - yaml.dump(config.__dict__, file) - print(f"Config saved to: {results_path / 'config.yaml'}") + cross_validator = CrossValidator( + model, config.cv_seed, config.n_folds, config.subsample_frac + ) - # Save model - saved_model_path = model.save(str(results_path / "saved_model")) - print(f"Model saved to: {saved_model_path}") + cross_validation_metrics = cross_validator.cross_validate(train_data, val_data) - # Save latent latent_representation = model.predict(train_data) - if isinstance(latent_representation, dict): # BABEL model - for modality_name, latent in latent_representation.items(): - torch.save(latent, str(results_path / f"latent_train_{modality_name}")) - else: - torch.save(latent_representation, str(results_path / "latent")) - - -def load_config(args) -> SimpleNamespace: - def load_object(dct): - return SimpleNamespace(**dct) - - with open(CONFIG_PATH / args.method / f"{args.config}.yaml") as file: - config_dict = yaml.safe_load(file) - config_namespace = json.loads(json.dumps(config_dict), object_hook=load_object) - return config_namespace - -def create_model(args, config) -> ModelBase: - if args.method == "omivae": - model = OmiModel(config) - return model - elif args.method == "babel": - model = BabelModel(config) - return model - elif args.method == "advae": - raise NotImplementedError(f"{args.method} method not implemented.") - elif args.method == "vae": - return VAE(config) - else: - raise NotImplementedError(f"{args.method} method not implemented.") + results_path = create_results_dir(config) + # compute_latent_and_save_model(model, latent_representation, results_path) + # compute_and_save_metrics(model) if __name__ == "__main__": - main() + train() diff --git a/src/utils/data/add_hierarchies.py b/src/utils/data/add_hierarchies.py index e9a539c..61def9c 100644 --- a/src/utils/data/add_hierarchies.py +++ b/src/utils/data/add_hierarchies.py @@ -2,7 +2,6 @@ import anndata as ad import numpy as np - from utils.paths import RAW_ANNDATA_HIERARCHY_PATH default_hierarchies_mapping = { diff --git a/src/utils/evaluation/metrics_old.py b/src/utils/evaluation/metrics_old.py index adb49db..0160a2a 100644 --- a/src/utils/evaluation/metrics_old.py +++ b/src/utils/evaluation/metrics_old.py @@ -1,3 +1,4 @@ +import argparse import os from argparse import Namespace from itertools import cycle @@ -19,10 +20,13 @@ ) from sklearn.preprocessing import label_binarize from torch import nn -from torch.nn import functional as F +from utils.paths import CONFIG_PATH, RESULTS_PATH from models.building_blocks import Block -from utils.paths import CONFIG_PATH, RESULTS_PATH +from src.data.dataloader_todo import load_anndata +from src.global_utils.paths import RESULTS_PATH +from src.global_utils.train_and_validate_utils import create_model +from src.models.building_blocks import Block class ClassificationModel(pl.LightningModule): @@ -242,73 +246,48 @@ def plot_clustering(data, y_pred): # plt.show() +# def main(config): +# model = create_model(config) +# model.load(args.path) + +# # train_data = load_anndata( +# # mode="train", +# # normalize=config.normalize, +# # remove_batch_effect=config.remove_batch_effect, +# # target_hierarchy_level=config.target_hierarchy_level, +# # preload_subsample_frac=None, +# # ) import argparse import pandas as pd - -from train import create_model, load_config from utils.data_utils import load_anndata +from train import create_model, load_config -def main(): - parser = argparse.ArgumentParser(description="Validate model") - parser.add_argument( - "--path", - help="Path to load config from.", - ) - parser.add_argument( - "--method", - choices=["omivae", "babel", "advae", "vae"], - help="Name of the method to use.", - ) - parser.add_argument( - "--config", - default="standard", - help="Name of a configuration in src/config/{method}.yaml.", - ) - args = parser.parse_args() - - config = load_config(args) - model = create_model(args, config) - - model.load(args.path) - - # train_data = load_anndata( - # mode="train", - # normalize=config.normalize, - # remove_batch_effect=config.remove_batch_effect, - # target_hierarchy_level=config.target_hierarchy_level, - # preload_subsample_frac=None, - # ) - - test_data = load_anndata( - mode="test", - normalize=config.normalize, - remove_batch_effect=config.remove_batch_effect, - target_hierarchy_level=config.target_hierarchy_level, - preload_subsample_frac=None, - ) - - results_path = RESULTS_PATH / args.method - if not os.path.exists(results_path): - os.makedirs(results_path) - - results_path = RESULTS_PATH / args.method / f"{args.config}" - if not os.path.exists(results_path): - os.mkdir(results_path) - - latent_test = model.predict(test_data) - - if isinstance(latent_test, dict): # BABEL model - for modality_name, latent in latent_test.items(): - print(modality_name, type(latent), latent.shape) - torch.save(latent, str(results_path / f"latent_test_{modality_name}.pt")) - else: - torch.save(latent_test, str(results_path / "latent_test.pt")) - - # metrics_dict = calculate_metrics(model, train_data, test_data) - # pd.DataFrame.from_dict(metrics_dict).to_csv(args.path + "metrics.csv") - - -if __name__ == "__main__": - main() +# test_data = load_anndata( +# mode="test", +# normalize=config.normalize, +# remove_batch_effect=config.remove_batch_effect, +# target_hierarchy_level=config.target_hierarchy_level, +# preload_subsample_frac=None, +# ) + +# results_path = RESULTS_PATH / args.method +# if not os.path.exists(results_path): +# os.makedirs(results_path) + +# results_path = RESULTS_PATH / args.method / f"{args.config}" +# if not os.path.exists(results_path): +# os.mkdir(results_path) + +# latent_test = model.predict(test_data) + +# if isinstance(latent_test, dict): # BABEL model +# for modality_name, latent in latent_test.items(): +# print(modality_name, type(latent), latent.shape) +# torch.save(latent, str(results_path / f"latent_test_{modality_name}.pt")) +# else: +# torch.save(latent_test, str(results_path / "latent_test.pt")) + +# # metrics_dict = calculate_metrics(model, train_data, test_data) +# pd.DataFrame.from_dict(metrics_dict).to_csv(args.path + "metrics.csv") diff --git a/src/utils/old/data_utils.py b/src/utils/old/data_utils.py index 6e5a767..2398633 100644 --- a/src/utils/old/data_utils.py +++ b/src/utils/old/data_utils.py @@ -7,7 +7,6 @@ import torch import torch.utils from torch.utils.data import DataLoader, TensorDataset - from utils.add_hierarchies import add_second_hierarchy from utils.paths import ( PREPROCESSED_ANNDATA_PATH, diff --git a/src/utils/old/preprocess_transformer.py b/src/utils/old/preprocess_transformer.py index 5e33536..aaa8560 100644 --- a/src/utils/old/preprocess_transformer.py +++ b/src/utils/old/preprocess_transformer.py @@ -3,7 +3,6 @@ import numpy as np import torch from torch import Tensor - from utils.data_utils import load_anndata from utils.paths import TRANSFORMER_DATA_PATH diff --git a/src/validate.py b/src/validate.py new file mode 100644 index 0000000..af878a4 --- /dev/null +++ b/src/validate.py @@ -0,0 +1,10 @@ +from src.metrics.metrics import * + + +def validate(config): + # cross_validation_metrics.to_json(config.results_path / "metrics.json", indent=4) + print(f"Metrics saved to: {config.results_path / 'metrics.json'}") + + +if __name__ == "__main__": + validate()